menoh 1.0.0

data/example/example_mnist.rb

@@ -0,0 +1,74 @@
+require 'rmagick'
+require 'menoh'
+
+# load dataset
+image_list = [
+  './data/0.png',
+  './data/1.png',
+  './data/2.png',
+  './data/3.png',
+  './data/4.png',
+  './data/5.png',
+  './data/6.png',
+  './data/7.png',
+  './data/8.png',
+  './data/9.png'
+]
+input_shape = {
+  channel_num: 1,
+  width: 28,
+  height: 28
+}
+
+# load ONNX file
+onnx_obj = Menoh::Menoh.new './data/mnist.onnx'
+
+# onnx variable name
+MNIST_IN_NAME = '139900320569040'.freeze
+MNIST_OUT_NAME = '139898462888656'.freeze
+
+# model options for model
+model_opt = {
+  backend: 'mkldnn',
+  input_layers: [
+    {
+      name: MNIST_IN_NAME,
+      dims: [
+        image_list.length,
+        input_shape[:channel_num],
+        input_shape[:width],
+        input_shape[:height]
+      ]
+    }
+  ],
+  output_layers: [MNIST_OUT_NAME]
+}
+# make model for inference under 'model_opt'
+model = onnx_obj.make_model model_opt
+
+# prepare dataset
+image_set = [
+  {
+    name: MNIST_IN_NAME,
+    data: image_list.map do |image_filepath|
+      image = Magick::Image.read(image_filepath).first
+      image = image.resize_to_fill(input_shape[:width], input_shape[:height])
+      image.export_pixels(0, 0, image.columns, image.rows, 'i').map { |pix| pix / 256 }
+    end.flatten
+  }
+]
+# execute inference
+inferenced_results = model.run image_set
+
+categories = (0..9).to_a
+TOP_K = 1
+layer_result = inferenced_results.find { |x| x[:name] == MNIST_OUT_NAME }
+layer_result[:data].zip(image_list).each do |image_result, image_filepath|
+  # sort by score
+  sorted_result = image_result.zip(categories).sort_by { |x| -x[0] }
+
+  # display result
+  sorted_result[0, TOP_K].each do |score, category|
+    puts "#{image_filepath} = #{category} : #{score}"
+  end
+end

data/example/example_mnist_with_block.rb

@@ -0,0 +1,75 @@
+require 'rmagick'
+require 'menoh'
+
+# load dataset
+image_list = [
+  './data/0.png',
+  './data/1.png',
+  './data/2.png',
+  './data/3.png',
+  './data/4.png',
+  './data/5.png',
+  './data/6.png',
+  './data/7.png',
+  './data/8.png',
+  './data/9.png'
+]
+input_shape = {
+  channel_num: 1,
+  width: 28,
+  height: 28
+}
+
+# onnx variable name
+MNIST_IN_NAME = '139900320569040'.freeze
+MNIST_OUT_NAME = '139898462888656'.freeze
+
+# model options for model
+model_opt = {
+  backend: 'mkldnn',
+  input_layers: [
+    {
+      name: MNIST_IN_NAME,
+      dims: [
+        image_list.length,
+        input_shape[:channel_num],
+        input_shape[:width],
+        input_shape[:height]
+      ]
+    }
+  ],
+  output_layers: [MNIST_OUT_NAME]
+}
+
+# load ONNX file
+Menoh::Menoh.new './data/mnist.onnx' do |onnx_obj|
+  # make model for inference under 'model_opt'
+  onnx_obj.make_model model_opt do |model|
+    # prepare dataset
+    image_set = [
+      {
+        name: MNIST_IN_NAME,
+        data: image_list.map do |image_filepath|
+          image = Magick::Image.read(image_filepath).first
+          image = image.resize_to_fill(input_shape[:width], input_shape[:height])
+          image.export_pixels(0, 0, image.columns, image.rows, 'i').map { |pix| pix / 256 }
+        end.flatten
+      }
+    ]
+    # execute inference
+    model.run image_set do |inferenced_results|
+      categories = (0..9).to_a
+      TOP_K = 1
+      layer_result = inferenced_results.find { |x| x[:name] == MNIST_OUT_NAME }
+      layer_result[:data].zip(image_list).each do |image_result, image_filepath|
+        # sort by score
+        sorted_result = image_result.zip(categories).sort_by { |x| -x[0] }
+
+        # display result
+        sorted_result[0, TOP_K].each do |score, category|
+          puts "#{image_filepath} = #{category} : #{score}"
+        end
+      end
+    end
+  end
+end

data/example/example_vgg16.rb

@@ -0,0 +1,89 @@
+require 'open-uri'
+require 'rmagick'
+require 'menoh'
+# TODO revise api
+# download dependencies
+def download_file(url, output)
+  return if File.exist? output
+  puts "downloading... #{url}"
+  File.open(output, 'wb') do |f_output|
+    open(url, 'rb') do |f_input|
+      f_output.write f_input.read
+    end
+  end
+end
+download_file('https://www.dropbox.com/s/bjfn9kehukpbmcm/VGG16.onnx?dl=1', './data/VGG16.onnx')
+download_file('https://raw.githubusercontent.com/HoldenCaulfieldRye/caffe/master/data/ilsvrc12/synset_words.txt', './data/synset_words.txt')
+download_file('https://upload.wikimedia.org/wikipedia/commons/5/54/Light_sussex_hen.jpg', './data/Light_sussex_hen.jpg')
+download_file('https://upload.wikimedia.org/wikipedia/commons/f/fd/FoS20162016_0625_151036AA_%2827826100631%29.jpg', './data/honda_nsx.jpg')
+
+# load dataset
+image_list = [
+  './data/Light_sussex_hen.jpg',
+  './data/honda_nsx.jpg'
+]
+input_shape = {
+  channel_num: 3,
+  width: 224,
+  height: 224
+}
+
+# load ONNX file
+onnx_obj = Menoh::Menoh.new './data/VGG16.onnx'
+
+# onnx variable name
+CONV1_1_IN_NAME = '140326425860192'.freeze
+FC6_OUT_NAME = '140326200777584'.freeze
+SOFTMAX_OUT_NAME = '140326200803680'.freeze
+
+# model options for model
+model_opt = {
+  backend: 'mkldnn',
+  input_layers: [
+    {
+      name: CONV1_1_IN_NAME,
+      dims: [
+        image_list.length,
+        input_shape[:channel_num],
+        input_shape[:width],
+        input_shape[:height]
+      ]
+    }
+  ],
+  output_layers: [FC6_OUT_NAME, SOFTMAX_OUT_NAME]
+}
+# make model for inference under 'model_opt'
+model = onnx_obj.make_model model_opt
+
+# prepare dataset
+image_set = [
+  {
+    name: CONV1_1_IN_NAME,
+    data: image_list.map do |image_filepath|
+      image = Magick::Image.read(image_filepath).first
+      image = image.resize_to_fill(input_shape[:width], input_shape[:height])
+      'BGR'.split('').map do |color|
+        image.export_pixels(0, 0, image.columns, image.rows, color).map { |pix| pix / 256 }
+      end.flatten
+    end.flatten
+  }
+]
+
+# execute inference
+inferenced_results = model.run image_set
+
+# load category definition
+categories = File.read('./data/synset_words.txt').split("\n")
+TOP_K = 5
+layer_result = inferenced_results.find { |x| x[:name] == SOFTMAX_OUT_NAME }
+layer_result[:data].zip(image_list).each do |image_result, image_filepath|
+  puts "=== Result for #{image_filepath} ==="
+
+  # sort by score
+  sorted_result = image_result.zip(categories).sort_by { |x| -x[0] }
+
+  # display result
+  sorted_result[0, TOP_K].each do |score, category|
+    puts "#{category} : #{score}"
+  end
+end

data/ext/menoh_native/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+# have_library("stdc++")
+have_library('mkldnn')
+have_library('protobuf')
+
+menoh_dir = dir_config('menoh')
+$INCFLAGS << " -I#{menoh_dir[0]}/menoh"
+have_library('menoh')
+
+# $CPPFLAGS << " -std=c++14"
+$DLDFLAGS << ' -rdynamic'
+
+create_makefile('menoh/menoh_native')

data/ext/menoh_native/menoh_ruby.c

@@ -0,0 +1,328 @@
+#include "menoh_ruby.h"
+
+#define ERROR_CHECK(statement, exceptiontype)                        \
+  {                                                                  \
+    menoh_error_code ec = statement;                                 \
+    if (ec) {                                                        \
+      rb_raise(exceptiontype, "%s", menoh_get_last_error_message()); \
+      return Qnil;                                                   \
+    }                                                                \
+  }
+
+typedef struct menoh_ruby {
+  menoh_model_data_handle model_data;
+} menoh_ruby;
+
+static menoh_ruby *getONNX(VALUE self) {
+  menoh_ruby *p;
+  Data_Get_Struct(self, menoh_ruby, p);
+  return p;
+}
+
+static void wrap_menoh_free(menoh_ruby *p) {
+  if (p) {
+    if (p->model_data) menoh_delete_model_data(p->model_data);
+    ruby_xfree(p);
+  }
+}
+
+static VALUE wrap_menoh_alloc(VALUE klass) {
+  void *p = ruby_xmalloc(sizeof(menoh_ruby));
+  memset(p, 0, sizeof(menoh_ruby));
+  return Data_Wrap_Struct(klass, NULL, wrap_menoh_free, p);
+}
+
+static VALUE wrap_menoh_init(VALUE self, VALUE vfilename) {
+  menoh_error_code ec = menoh_error_code_success;
+  FilePathValue(vfilename);
+  char *filename = StringValueCStr(vfilename);
+
+  // Load ONNX model
+  menoh_model_data_handle model_data;
+  ERROR_CHECK(menoh_make_model_data_from_onnx(filename, &model_data),
+              rb_eArgError);
+  getONNX(self)->model_data = model_data;
+
+  return Qnil;
+}
+
+typedef struct menohModel {
+  menoh_model_data_handle model_data;
+  VALUE vbackend;
+  float **input_buffs;
+  float **output_buffs;
+  menoh_variable_profile_table_builder_handle vpt_builder;
+  menoh_variable_profile_table_handle variable_profile_table;
+  menoh_model_builder_handle model_builder;
+  menoh_model_handle model;
+  VALUE vinput_layers;
+  VALUE voutput_layers;
+  int32_t input_layer_num;
+} menohModel;
+
+static menohModel *getModel(VALUE self) {
+  menohModel *p;
+  Data_Get_Struct(self, menohModel, p);
+  return p;
+}
+
+static void wrap_model_free(menohModel *p) {
+  if (p) {
+    if (p->variable_profile_table)
+      menoh_delete_variable_profile_table(p->variable_profile_table);
+    if (p->vpt_builder)
+      menoh_delete_variable_profile_table_builder(p->vpt_builder);
+    if (p->model) menoh_delete_model(p->model);
+    if (p->model_builder) menoh_delete_model_builder(p->model_builder);
+    if (p->input_buffs) {
+      for (int32_t i = 0; i < p->input_layer_num; i++) {
+        if (p->input_buffs[i]) ruby_xfree(p->input_buffs[i]);
+      }
+      ruby_xfree(p->input_buffs);
+    }
+    if (p->output_buffs) ruby_xfree(p->output_buffs);
+    ruby_xfree(p);
+  }
+}
+
+static void wrap_model_mark(menohModel *p) {
+  if (p) {
+    if (p->vbackend) rb_gc_mark(p->vbackend);
+    if (p->vinput_layers) rb_gc_mark(p->vinput_layers);
+    if (p->voutput_layers) rb_gc_mark(p->voutput_layers);
+  }
+}
+
+static VALUE wrap_model_alloc(VALUE klass) {
+  void *p = ruby_xmalloc(sizeof(menohModel));
+  memset(p, 0, sizeof(menohModel));
+  return Data_Wrap_Struct(klass, wrap_model_mark, wrap_model_free, p);
+}
+
+static VALUE wrap_model_init(VALUE self, VALUE vonnx, VALUE option) {
+  // option
+  getModel(self)->model_data = getONNX(vonnx)->model_data;
+  VALUE vbackend = rb_hash_aref(option, rb_to_symbol(rb_str_new2("backend")));
+  getModel(self)->vbackend = vbackend;
+
+  // option
+  VALUE vinput_layers =
+      rb_hash_aref(option, rb_to_symbol(rb_str_new2("input_layers")));
+  VALUE voutput_layers =
+      rb_hash_aref(option, rb_to_symbol(rb_str_new2("output_layers")));
+
+  getModel(self)->vinput_layers = vinput_layers;
+  getModel(self)->voutput_layers = voutput_layers;
+
+  // get vpt builder
+  ERROR_CHECK(
+      menoh_make_variable_profile_table_builder(&(getModel(self)->vpt_builder)),
+      rb_eStandardError);
+
+  // set output_layer
+  int32_t output_layer_num =
+      NUM2INT(rb_funcall(voutput_layers, rb_intern("length"), 0, NULL));
+  for (int32_t i = 0; i < output_layer_num; i++) {
+    VALUE voutput_layer = rb_ary_entry(voutput_layers, i);
+    ERROR_CHECK(menoh_variable_profile_table_builder_add_output_profile(
+                    getModel(self)->vpt_builder, StringValueCStr(voutput_layer),
+                    menoh_dtype_float),
+                rb_eStandardError);
+  }
+
+  // set input layer
+  int32_t input_layer_num =
+      NUM2INT(rb_funcall(vinput_layers, rb_intern("length"), 0, NULL));
+  getModel(self)->input_layer_num = input_layer_num;
+  for (int32_t i = 0; i < input_layer_num; i++) {
+    VALUE vinput_layer = rb_ary_entry(vinput_layers, i);
+    VALUE vname = rb_hash_aref(vinput_layer, rb_to_symbol(rb_str_new2("name")));
+    VALUE vdims = rb_hash_aref(vinput_layer, rb_to_symbol(rb_str_new2("dims")));
+    int32_t dims_length =
+        NUM2INT(rb_funcall(vdims, rb_intern("length"), 0, NULL));
+
+    switch (dims_length) {
+      case 2:
+        ERROR_CHECK(
+            menoh_variable_profile_table_builder_add_input_profile_dims_2(
+                getModel(self)->vpt_builder, StringValueCStr(vname),
+                menoh_dtype_float, NUM2INT(rb_ary_entry(vdims, 0)),
+                NUM2INT(rb_ary_entry(vdims, 1))),
+            rb_eStandardError);
+        break;
+      case 4:
+        ERROR_CHECK(
+            menoh_variable_profile_table_builder_add_input_profile_dims_4(
+                getModel(self)->vpt_builder, StringValueCStr(vname),
+                menoh_dtype_float, NUM2INT(rb_ary_entry(vdims, 0)),
+                NUM2INT(rb_ary_entry(vdims, 1)),
+                NUM2INT(rb_ary_entry(vdims, 2)),
+                NUM2INT(rb_ary_entry(vdims, 3))),
+            rb_eStandardError);
+        break;
+      default:
+        rb_raise(rb_eStandardError, "invalid dimension length");
+        return Qnil;
+    }
+
+    // build variable provile table
+    ERROR_CHECK(menoh_build_variable_profile_table(
+                    getModel(self)->vpt_builder, getModel(self)->model_data,
+                    &(getModel(self)->variable_profile_table)),
+                rb_eStandardError);
+
+    // optimize
+    ERROR_CHECK(
+        menoh_model_data_optimize(getModel(self)->model_data,
+                                  getModel(self)->variable_profile_table),
+        rb_eStandardError);
+
+    // get model buildler
+    ERROR_CHECK(menoh_make_model_builder(getModel(self)->variable_profile_table,
+                                         &(getModel(self)->model_builder)),
+                rb_eStandardError);
+
+    // attach input buffer to model builder
+    getModel(self)->input_buffs =
+        (float **)ruby_xmalloc(sizeof(float **) * input_layer_num);
+    for (int32_t i = 0; i < input_layer_num; i++) {
+      VALUE vinput_layer = rb_ary_entry(vinput_layers, i);
+      VALUE vname =
+          rb_hash_aref(vinput_layer, rb_to_symbol(rb_str_new2("name")));
+      VALUE vdims =
+          rb_hash_aref(vinput_layer, rb_to_symbol(rb_str_new2("dims")));
+      int32_t dims_length =
+          NUM2INT(rb_funcall(vdims, rb_intern("length"), 0, NULL));
+
+      // prepare input buffer
+      int32_t buffer_length = 1;
+      for (int32_t j = 0; j < dims_length; j++)
+        buffer_length *= NUM2INT(rb_ary_entry(vdims, j));
+
+      float *input_buff = (float *)ruby_xmalloc(sizeof(float) * buffer_length);
+      getModel(self)->input_buffs[i] = input_buff;
+      ERROR_CHECK(
+          menoh_model_builder_attach_external_buffer(
+              getModel(self)->model_builder, StringValueCStr(vname), input_buff),
+          rb_eStandardError);
+    }
+
+    // build model
+    ERROR_CHECK(menoh_build_model(
+                    getModel(self)->model_builder, getModel(self)->model_data,
+                    StringValueCStr(vbackend), "", &(getModel(self)->model)),
+                rb_eStandardError);
+
+    return Qnil;
+  }
+}
+
+static VALUE wrap_model_run(VALUE self, VALUE dataset) {
+  VALUE vbackend = getModel(self)->vbackend;
+  VALUE vinput_layers = getModel(self)->vinput_layers;
+  VALUE voutput_layers = getModel(self)->voutput_layers;
+
+  int32_t input_layer_num =
+      NUM2INT(rb_funcall(vinput_layers, rb_intern("length"), 0, NULL));
+  int32_t output_layer_num =
+      NUM2INT(rb_funcall(voutput_layers, rb_intern("length"), 0, NULL));
+
+  // Copy input image data to model's input array
+  for (int32_t i = 0; i < input_layer_num; i++) {
+    VALUE vinput_layer = rb_ary_entry(vinput_layers, i);
+    VALUE vname = rb_hash_aref(vinput_layer, rb_to_symbol(rb_str_new2("name")));
+    VALUE vdims = rb_hash_aref(vinput_layer, rb_to_symbol(rb_str_new2("dims")));
+    int32_t dims_length =
+        NUM2INT(rb_funcall(vdims, rb_intern("length"), 0, NULL));
+    int32_t buffer_length = 1;
+    for (int32_t j = 0; j < dims_length; j++)
+      buffer_length *= NUM2INT(rb_ary_entry(vdims, j));
+
+    VALUE data = rb_ary_entry(dataset, i);
+    for (int32_t j = 0; j < buffer_length; j++) {
+      getModel(self)->input_buffs[i][j] =
+          (float)(NUM2DBL(rb_ary_entry(data, j)));
+    }
+  }
+
+  // attach output buffer to model
+  getModel(self)->output_buffs =
+      (float **)ruby_xmalloc(sizeof(float *) * output_layer_num);
+  for (int32_t i = 0; i < output_layer_num; i++) {
+    VALUE voutput_layer = rb_ary_entry(voutput_layers, i);
+    float *output_buff;
+    ERROR_CHECK(menoh_model_get_variable_buffer_handle(
+                    getModel(self)->model, StringValueCStr(voutput_layer),
+                    (void **)&output_buff),
+                rb_eStandardError);
+    getModel(self)->output_buffs[i] = output_buff;
+  }
+
+  // run model
+  ERROR_CHECK(menoh_model_run(getModel(self)->model), rb_eStandardError);
+
+  // Get output
+  VALUE results = rb_ary_new();
+  for (int32_t output_layer_i = 0; output_layer_i < output_layer_num;
+       output_layer_i++) {
+    VALUE voutput_layer = rb_ary_entry(voutput_layers, output_layer_i);
+    VALUE result_each = rb_hash_new();
+
+    // get dimention of output layers
+    int32_t dim_size;
+    int32_t output_buffer_length = 1;
+    ERROR_CHECK(menoh_variable_profile_table_get_dims_size(
+                    getModel(self)->variable_profile_table,
+                    StringValueCStr(voutput_layer), &(dim_size)),
+                rb_eStandardError);
+    VALUE vresult_shape = rb_ary_new();
+    // get each size of dimention
+    for (int32_t dim = 0; dim < dim_size; dim++) {
+      int32_t size;
+      ERROR_CHECK(menoh_variable_profile_table_get_dims_at(
+                      getModel(self)->variable_profile_table,
+                      StringValueCStr(voutput_layer), dim, &(size)),
+                  rb_eStandardError);
+      rb_ary_push(vresult_shape, INT2NUM(size));
+      output_buffer_length *= size;
+    }
+
+    // Convert result to Ruby Array
+    VALUE vresult_buffer = rb_ary_new();
+    for (int32_t j = 0; j < output_buffer_length; j++) {
+      float *output_buff;
+      output_buff = getModel(self)->output_buffs[output_layer_i];
+      rb_ary_push(vresult_buffer, DBL2NUM(*(output_buff + j)));
+    }
+
+    rb_hash_aset(result_each, rb_to_symbol(rb_str_new2("name")), voutput_layer);
+    rb_hash_aset(result_each, rb_to_symbol(rb_str_new2("shape")),
+                 vresult_shape);
+    rb_hash_aset(result_each, rb_to_symbol(rb_str_new2("data")),
+                 vresult_buffer);
+    rb_ary_push(results, result_each);
+  }
+
+  return results;
+}
+
+VALUE mMenoh;
+
+void Init_menoh_native() {
+  mMenoh = rb_define_module("Menoh");
+
+  VALUE onnx = rb_define_class_under(mMenoh, "Menoh", rb_cObject);
+
+  rb_define_alloc_func(onnx, wrap_menoh_alloc);
+  rb_define_private_method(onnx, "native_init",
+                           RUBY_METHOD_FUNC(wrap_menoh_init), 1);
+
+  VALUE model = rb_define_class_under(mMenoh, "MenohModel", rb_cObject);
+
+  rb_define_alloc_func(model, wrap_model_alloc);
+  rb_define_private_method(model, "native_init",
+                           RUBY_METHOD_FUNC(wrap_model_init), 2);
+
+  rb_define_private_method(model, "native_run",
+                           RUBY_METHOD_FUNC(wrap_model_run), 1);
+}