From 5241f4f2a4cdafc314c08bc34ff8bef2541e1167 Mon Sep 17 00:00:00 2001 From: Kenichi Maehashi Date: Fri, 8 Feb 2019 20:07:27 +0900 Subject: [PATCH 1/3] fix typo --- docs/tutorial.md | 8 ++++---- example/example_mnist.rb | 4 ++-- example/example_mnist_with_block.rb | 4 ++-- example/example_vgg16.rb | 4 ++-- test/menoh_test.rb | 16 ++++++++-------- 5 files changed, 18 insertions(+), 18 deletions(-) diff --git a/docs/tutorial.md b/docs/tutorial.md index 0255c8c..7805b39 100644 --- a/docs/tutorial.md +++ b/docs/tutorial.md @@ -106,14 +106,14 @@ Now we can run the inference. ```ruby # execute inference -inferenced_results = model.run image_set +inference_results = model.run image_set ``` -The `inferenced_results` is the array that contains the hash of results of `output_layers`. So you can get each value as follows. +The `inference_results` is the array that contains the hash of results of `output_layers`. So you can get each value as follows. ```ruby -fc6_out = inferenced_results.find { |x| x[:name] == FC6_OUT_NAME } -softmax_out = inferenced_results.find { |x| x[:name] == SOFTMAX_OUT_NAME } +fc6_out = inference_results.find { |x| x[:name] == FC6_OUT_NAME } +softmax_out = inference_results.find { |x| x[:name] == SOFTMAX_OUT_NAME } ``` That's it. diff --git a/example/example_mnist.rb b/example/example_mnist.rb index 6b74e2a..5d47d0e 100644 --- a/example/example_mnist.rb +++ b/example/example_mnist.rb @@ -58,11 +58,11 @@ } ] # execute inference -inferenced_results = model.run image_set +inference_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 = inference_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] } diff --git a/example/example_mnist_with_block.rb b/example/example_mnist_with_block.rb index ad0a7ee..f170572 100644 --- a/example/example_mnist_with_block.rb +++ b/example/example_mnist_with_block.rb @@ -57,10 +57,10 @@ } ] # execute inference - model.run image_set do |inferenced_results| + model.run image_set do |inference_results| categories = (0..9).to_a TOP_K = 1 - layer_result = inferenced_results.find { |x| x[:name] == MNIST_OUT_NAME } + layer_result = inference_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] } diff --git a/example/example_vgg16.rb b/example/example_vgg16.rb index 0d913d6..c3b3439 100644 --- a/example/example_vgg16.rb +++ b/example/example_vgg16.rb @@ -78,12 +78,12 @@ def download_file(url, output) ] # execute inference -inferenced_results = model.run image_set +inference_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 = inference_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} ===" diff --git a/test/menoh_test.rb b/test/menoh_test.rb index 5f9a93d..6f71888 100644 --- a/test/menoh_test.rb +++ b/test/menoh_test.rb @@ -32,10 +32,10 @@ def test_menoh_basic_function data: (0..(batch_size - 1)).map { |_i| (0..(1 * 28 * 28 - 1)).to_a }.flatten } ] - inferenced_results = model.run imageset - assert_instance_of(Array, inferenced_results) - assert_equal(MNIST_OUT_NAME, inferenced_results.first[:name]) - assert_equal(batch_size, inferenced_results.first[:data].length) + inference_results = model.run imageset + assert_instance_of(Array, inference_results) + assert_equal(MNIST_OUT_NAME, inference_results.first[:name]) + assert_equal(batch_size, inference_results.first[:data].length) end end @@ -61,10 +61,10 @@ def test_menoh_basic_function_with_block assert_instance_of(Menoh::Menoh, onnx) onnx.make_model(model_opt) do |model| assert_instance_of(Menoh::MenohModel, model) - model.run(imageset) do |inferenced_results| - assert_instance_of(Array, inferenced_results) - assert_equal(MNIST_OUT_NAME, inferenced_results.first[:name]) - assert_equal(batch_size, inferenced_results.first[:data].length) + model.run(imageset) do |inference_results| + assert_instance_of(Array, inference_results) + assert_equal(MNIST_OUT_NAME, inference_results.first[:name]) + assert_equal(batch_size, inference_results.first[:data].length) end end end From 41dcf1099a968f1735779a206e52429fd8be237c Mon Sep 17 00:00:00 2001 From: Kunihiko MIYOSHI Date: Sun, 5 May 2019 11:32:43 +0900 Subject: [PATCH 2/3] integrate `run` and `run_numo` --- lib/menoh.rb | 60 ++++++++++++++++++++++------------------------ test/menoh_test.rb | 50 +++++++++++++++++++++++--------------- 2 files changed, 59 insertions(+), 51 deletions(-) diff --git a/lib/menoh.rb b/lib/menoh.rb index f384667..5d62e0e 100644 --- a/lib/menoh.rb +++ b/lib/menoh.rb @@ -28,14 +28,15 @@ class MenohModel int8: Numo::Int8, int16: Numo::Int16, int32: Numo::Int32, - int64: Numo::Int64, - } - + int64: Numo::Int64 + }.freeze + def initialize(menoh, option) if option[:input_layers].nil? || option[:input_layers].empty? raise "Required ':input_layers'" end raise "Required ':input_layers'" unless option[:input_layers].instance_of?(Array) + option[:input_layers].each_with_index do |input_layer, i| raise 'Invalid option : input_layers' unless input_layer.instance_of?(Hash) raise "Invalid name for input_layer[#{i}]" unless input_layer[:name].instance_of?(String) @@ -46,7 +47,7 @@ def initialize(menoh, option) end option = option.dup - if option.has_key?(:backend_config) + if option.key?(:backend_config) config = option[:backend_config] unless config.nil? || config.is_a?(String) option[:backend_config] = JSON.dump(config) @@ -58,16 +59,25 @@ def initialize(menoh, option) yield self if block_given? end - def run(dataset) + def run(dataset, numo_narray: false) raise 'Invalid dataset' if !dataset.instance_of?(Array) || dataset.empty? if dataset.length != @option[:input_layers].length raise "Invalid input num: expected==#{@option[:input_layers].length} actual==#{dataset.length}" end + dataset.each do |input| - if !input[:data].instance_of?(Array) || input[:data].empty? + raise "Empty data for layer #{input[:name]}" if input[:data].empty? + + if input[:data].instance_of?(Array) + set_data(input[:name], input[:data]) + elsif input[:data].instance_of?(Numo::SFloat) + if dataset.length != @option[:input_layers].length + raise "Invalid input num: expected==#{@option[:input_layers].length} actual==#{dataset.length}" + end + set_data_str(input[:name], input[:data].to_binary) + else raise "Invalid dataset for layer #{input[:name]}" end - set_data(input[:name], input[:data]) end # run @@ -75,33 +85,19 @@ def run(dataset) # reshape result results = @option[:output_layers].map do |name| - buffer = get_data(name) + dtype = get_dtype(name) shape = get_shape(name) - { name: name, shape: shape, data: Util.reshape(buffer, shape) } - end - - yield results if block_given? - results - end - - def run_numo(dataset) - raise 'Invalid dataset' if !dataset.instance_of?(Array) || dataset.empty? - if dataset.length != @option[:input_layers].length - raise "Invalid input num: expected==#{@option[:input_layers].length} actual==#{dataset.length}" - end - dataset.each do |input| - set_data_str(input[:name], input[:data].to_binary) - end + data = nil + if numo_narray + c = DTYPE_TO_NUMO_NARRAY_CLASS[dtype] + raise InvalidDType, "unsupported dtype: #{dtype}" if c.nil? - # run - native_run - - results = {} - @option[:output_layers].each do |name| - dtype = get_dtype(name) - c = DTYPE_TO_NUMO_NARRAY_CLASS[dtype] - raise InvalidDTypeError.new("unsupported dtype: #{dtype}") if c.nil? - results[name] = c.from_binary(get_data_str(name), get_shape(name)) + data = c.from_binary(get_data_str(name), get_shape(name)) + else + buffer = get_data(name) + data = Util.reshape(buffer, shape) + end + { name: name, shape: shape, data: data } end yield results if block_given? diff --git a/test/menoh_test.rb b/test/menoh_test.rb index 162180f..9ad5a19 100644 --- a/test/menoh_test.rb +++ b/test/menoh_test.rb @@ -26,6 +26,7 @@ def test_menoh_basic_function } model = onnx.make_model(model_opt) assert_instance_of(Menoh::MenohModel, model) + # input: Array, output: Array 10.times do imageset = [ { @@ -38,24 +39,21 @@ def test_menoh_basic_function assert_equal(MNIST_OUT_NAME, inferenced_results.first[:name]) assert_equal(batch_size, inferenced_results.first[:data].length) end - end - - def test_menoh_basic_function_numo - onnx = Menoh::Menoh.new(MNIST_ONNX_FILE) - assert_instance_of(Menoh::Menoh, onnx) - batch_size = 3 - model_opt = { - backend: 'mkldnn', - input_layers: [ + # input: Array, output: Numo::SFloat + 10.times do + imageset = [ { name: MNIST_IN_NAME, - dims: [batch_size, 1, 28, 28] + data: (0..(batch_size - 1)).map { |_i| (0..(1 * 28 * 28 - 1)).to_a }.flatten } - ], - output_layers: [MNIST_OUT_NAME] - } - model = onnx.make_model(model_opt) - assert_instance_of(Menoh::MenohModel, model) + ] + inferenced_results = model.run(imageset, numo_narray: true) + assert_instance_of(Array, inferenced_results) + assert_equal(MNIST_OUT_NAME, inferenced_results.first[:name]) + assert_instance_of(Numo::SFloat, inferenced_results.first[:data]) + assert_equal([batch_size, 10], inferenced_results.first[:data].shape) + end + # input: Numo::SFloat, output: Numo::SFloat 10.times do imageset = [ { @@ -63,10 +61,24 @@ def test_menoh_basic_function_numo data: Numo::SFloat.zeros(batch_size, 1, 28, 28) } ] - inferenced_results = model.run_numo imageset - assert_instance_of(Hash, inferenced_results) - assert_instance_of(Numo::SFloat, inferenced_results[MNIST_OUT_NAME]) - assert_equal([batch_size, 10], inferenced_results[MNIST_OUT_NAME].shape) + inferenced_results = model.run(imageset, numo_narray: true) + assert_instance_of(Array, inferenced_results) + assert_equal(MNIST_OUT_NAME, inferenced_results.first[:name]) + assert_instance_of(Numo::SFloat, inferenced_results.first[:data]) + assert_equal([batch_size, 10], inferenced_results.first[:data].shape) + end + # input: Numo::SFloat, output: Array + 10.times do + imageset = [ + { + name: MNIST_IN_NAME, + data: Numo::SFloat.zeros(batch_size, 1, 28, 28) + } + ] + inferenced_results = model.run(imageset) + assert_instance_of(Array, inferenced_results) + assert_equal(MNIST_OUT_NAME, inferenced_results.first[:name]) + assert_equal(batch_size, inferenced_results.first[:data].length) end end From bc58f24b938d8933a1e472eefc16da772bb03cab Mon Sep 17 00:00:00 2001 From: Kunihiko MIYOSHI Date: Sun, 5 May 2019 11:35:48 +0900 Subject: [PATCH 3/3] fix misspelled variable --- test/menoh_test.rb | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/test/menoh_test.rb b/test/menoh_test.rb index edfd5fc..fdb9a77 100644 --- a/test/menoh_test.rb +++ b/test/menoh_test.rb @@ -47,11 +47,11 @@ def test_menoh_basic_function data: (0..(batch_size - 1)).map { |_i| (0..(1 * 28 * 28 - 1)).to_a }.flatten } ] - inferenced_results = model.run(imageset, numo_narray: true) - assert_instance_of(Array, inferenced_results) - assert_equal(MNIST_OUT_NAME, inferenced_results.first[:name]) - assert_instance_of(Numo::SFloat, inferenced_results.first[:data]) - assert_equal([batch_size, 10], inferenced_results.first[:data].shape) + inference_results = model.run(imageset, numo_narray: true) + assert_instance_of(Array, inference_results) + assert_equal(MNIST_OUT_NAME, inference_results.first[:name]) + assert_instance_of(Numo::SFloat, inference_results.first[:data]) + assert_equal([batch_size, 10], inference_results.first[:data].shape) end # input: Numo::SFloat, output: Numo::SFloat 10.times do @@ -61,11 +61,11 @@ def test_menoh_basic_function data: Numo::SFloat.zeros(batch_size, 1, 28, 28) } ] - inferenced_results = model.run(imageset, numo_narray: true) - assert_instance_of(Array, inferenced_results) - assert_equal(MNIST_OUT_NAME, inferenced_results.first[:name]) - assert_instance_of(Numo::SFloat, inferenced_results.first[:data]) - assert_equal([batch_size, 10], inferenced_results.first[:data].shape) + inference_results = model.run(imageset, numo_narray: true) + assert_instance_of(Array, inference_results) + assert_equal(MNIST_OUT_NAME, inference_results.first[:name]) + assert_instance_of(Numo::SFloat, inference_results.first[:data]) + assert_equal([batch_size, 10], inference_results.first[:data].shape) end # input: Numo::SFloat, output: Array 10.times do @@ -75,10 +75,10 @@ def test_menoh_basic_function data: Numo::SFloat.zeros(batch_size, 1, 28, 28) } ] - inferenced_results = model.run(imageset) - assert_instance_of(Array, inferenced_results) - assert_equal(MNIST_OUT_NAME, inferenced_results.first[:name]) - assert_equal(batch_size, inferenced_results.first[:data].length) + inference_results = model.run(imageset) + assert_instance_of(Array, inference_results) + assert_equal(MNIST_OUT_NAME, inference_results.first[:name]) + assert_equal(batch_size, inference_results.first[:data].length) end end