onnxruntime 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2405ad6cda55897be52cbb6afd3854d2cf2ed5ed01abc09bf78568557af446ff
-  data.tar.gz: 1e04e516b4726f510bf489108c1f684e398f8d63718c9717106ac9659773d3f0
+  metadata.gz: fa019e016dea45f795caba9b06e972edc6ae705d1599826fb17adf10af572851
+  data.tar.gz: e0704039d0c8a94bf523dce7f707636493696ee92aa3f741d5b49ea62561e6d5
 SHA512:
-  metadata.gz: a2a38af03a82eecc60e28b6fb7b012c28188af69af9a7521cb4b1e4c2519c99c6d328045f0f20fe509787942d304a15e92e43ad94483c55f895cf4bbaf21b53e
-  data.tar.gz: c782475317186f24c7e34285584ee7761522cc1f792e092c896abe32a041cf593ef4e7f0736a12688ad3e7539101234123d8948ab8ebe0c7986bfb40f33ff236
+  metadata.gz: 07dbde3621a15379bceb5b0fe7bfbb2bb581cb54a1b78d0f104f432396bac9086ab3c6186798fab52026515c8331074b35a68f6cce6748d3315e10bc375c3a9a
+  data.tar.gz: ccc9ee30c55d0c8ae611b70adeab1b8707bc15bce42281ce05ca6bb9d4d6ff4953c2795a3931f4ff325401a3caea95d62e08243732d125cebda9dfb4587bdbc8

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.2.2 (2019-12-24)
+
+- Added support for session options
+- Added support for run options
+- Added `Datasets` module
+
 ## 0.2.1 (2019-12-19)
 
 - Updated ONNX Runtime to 1.1.0

data/LICENSE.txt

@@ -1,4 +1,5 @@
 Copyright (c) 2019 Andrew Kane
+Datasets Copyright (c) Microsoft Corporation
 
 MIT License
 

data/README.md

@@ -50,6 +50,35 @@ Get specific outputs
 model.predict({x: [1, 2, 3]}, output_names: ["label"])
 ```
 
+## Session Options
+
+```ruby
+OnnxRuntime::Model.new(path_or_bytes, {
+  enable_cpu_mem_arena: true,
+  enable_mem_pattern: true,
+  enable_profiling: false,
+  execution_mode: :sequential,
+  graph_optimization_level: nil,
+  inter_op_num_threads: nil,
+  intra_op_num_threads: nil,
+  log_severity_level: 2,
+  log_verbosity_level: 0,
+  logid: nil,
+  optimized_model_filepath: nil
+})
+```
+
+## Run Options
+
+```ruby
+model.predict(input_feed, {
+  log_severity_level: 2,
+  log_verbosity_level: 0,
+  logid: nil,
+  terminate: false
+})
+```
+
 ## Inference Session API
 
 You can also use the Inference Session API, which follows the [Python API](https://microsoft.github.io/onnxruntime/python/api_summary.html).
@@ -59,6 +88,20 @@ session = OnnxRuntime::InferenceSession.new("model.onnx")
 session.run(nil, {x: [1, 2, 3]})
 ```
 
+The Python example models are included as well.
+
+```ruby
+OnnxRuntime::Datasets.example("sigmoid.onnx")
+```
+
+## GPU Support
+
+To enable GPU support on Linux and Windows, download the appropriate [GPU release](https://github.com/microsoft/onnxruntime/releases) and set:
+
+```ruby
+OnnxRuntime.ffi_lib = "path/to/lib/libonnxruntime.so" # onnxruntime.dll for Windows
+```
+
 ## History
 
 View the [changelog](https://github.com/ankane/onnxruntime/blob/master/CHANGELOG.md)

data/lib/onnxruntime.rb

@@ -2,6 +2,7 @@
 require "ffi"
 
 # modules
+require "onnxruntime/datasets"
 require "onnxruntime/inference_session"
 require "onnxruntime/model"
 require "onnxruntime/utils"

data/lib/onnxruntime/datasets.rb

@@ -0,0 +1,10 @@
+module OnnxRuntime
+  module Datasets
+    def self.example(name)
+      unless %w(logreg_iris.onnx mul_1.onnx sigmoid.onnx).include?(name)
+        raise ArgumentError, "Unable to find example '#{name}'"
+      end
+      File.expand_path("../../datasets/#{name}", __dir__)
+    end
+  end
+end

data/lib/onnxruntime/ffi.rb

@@ -3,7 +3,7 @@ module OnnxRuntime
     extend ::FFI::Library
 
     begin
-      ffi_lib OnnxRuntime.ffi_lib
+      ffi_lib Array(OnnxRuntime.ffi_lib)
     rescue LoadError => e
       raise e if ENV["ONNXRUNTIME_DEBUG"]
       raise LoadError, "Could not find ONNX Runtime"
@@ -29,21 +29,21 @@ module OnnxRuntime
         :CreateSessionFromArray, callback(%i[pointer pointer size_t pointer pointer], :pointer),
         :Run, callback(%i[pointer pointer pointer pointer size_t pointer size_t pointer], :pointer),
         :CreateSessionOptions, callback(%i[pointer], :pointer),
-        :SetOptimizedModelFilePath, callback(%i[], :pointer),
+        :SetOptimizedModelFilePath, callback(%i[pointer string], :pointer),
         :CloneSessionOptions, callback(%i[], :pointer),
         :SetSessionExecutionMode, callback(%i[], :pointer),
-        :EnableProfiling, callback(%i[], :pointer),
-        :DisableProfiling, callback(%i[], :pointer),
-        :EnableMemPattern, callback(%i[], :pointer),
-        :DisableMemPattern, callback(%i[], :pointer),
-        :EnableCpuMemArena, callback(%i[], :pointer),
-        :DisableCpuMemArena, callback(%i[], :pointer),
-        :SetSessionLogId, callback(%i[], :pointer),
-        :SetSessionLogVerbosityLevel, callback(%i[], :pointer),
-        :SetSessionLogSeverityLevel, callback(%i[], :pointer),
-        :SetSessionGraphOptimizationLevel, callback(%i[], :pointer),
-        :SetIntraOpNumThreads, callback(%i[], :pointer),
-        :SetInterOpNumThreads, callback(%i[], :pointer),
+        :EnableProfiling, callback(%i[pointer string], :pointer),
+        :DisableProfiling, callback(%i[pointer], :pointer),
+        :EnableMemPattern, callback(%i[pointer], :pointer),
+        :DisableMemPattern, callback(%i[pointer], :pointer),
+        :EnableCpuMemArena, callback(%i[pointer], :pointer),
+        :DisableCpuMemArena, callback(%i[pointer], :pointer),
+        :SetSessionLogId, callback(%i[pointer string], :pointer),
+        :SetSessionLogVerbosityLevel, callback(%i[pointer int], :pointer),
+        :SetSessionLogSeverityLevel, callback(%i[pointer int], :pointer),
+        :SetSessionGraphOptimizationLevel, callback(%i[pointer int], :pointer),
+        :SetIntraOpNumThreads, callback(%i[pointer int], :pointer),
+        :SetInterOpNumThreads, callback(%i[pointer int], :pointer),
         :CreateCustomOpDomain, callback(%i[], :pointer),
         :CustomOpDomain_Add, callback(%i[], :pointer),
         :AddCustomOpDomain, callback(%i[], :pointer),
@@ -57,15 +57,15 @@ module OnnxRuntime
         :SessionGetInputName, callback(%i[pointer size_t pointer pointer], :pointer),
         :SessionGetOutputName, callback(%i[pointer size_t pointer pointer], :pointer),
         :SessionGetOverridableInitializerName, callback(%i[], :pointer),
-        :CreateRunOptions, callback(%i[], :pointer),
-        :RunOptionsSetRunLogVerbosityLevel, callback(%i[], :pointer),
-        :RunOptionsSetRunLogSeverityLevel, callback(%i[], :pointer),
-        :RunOptionsSetRunTag, callback(%i[], :pointer),
+        :CreateRunOptions, callback(%i[pointer], :pointer),
+        :RunOptionsSetRunLogVerbosityLevel, callback(%i[pointer int], :pointer),
+        :RunOptionsSetRunLogSeverityLevel, callback(%i[pointer int], :pointer),
+        :RunOptionsSetRunTag, callback(%i[pointer string], :pointer),
         :RunOptionsGetRunLogVerbosityLevel, callback(%i[], :pointer),
         :RunOptionsGetRunLogSeverityLevel, callback(%i[], :pointer),
         :RunOptionsGetRunTag, callback(%i[], :pointer),
-        :RunOptionsSetTerminate, callback(%i[], :pointer),
-        :RunOptionsUnsetTerminate, callback(%i[], :pointer),
+        :RunOptionsSetTerminate, callback(%i[pointer], :pointer),
+        :RunOptionsUnsetTerminate, callback(%i[pointer], :pointer),
         :CreateTensorAsOrtValue, callback(%i[pointer pointer size_t int pointer], :pointer),
         :CreateTensorWithDataAsOrtValue, callback(%i[pointer pointer size_t pointer size_t int pointer], :pointer),
         :IsTensor, callback(%i[], :pointer),

data/lib/onnxruntime/inference_session.rb

@@ -2,10 +2,32 @@ module OnnxRuntime
   class InferenceSession
     attr_reader :inputs, :outputs
 
-    def initialize(path_or_bytes)
+    def initialize(path_or_bytes, enable_cpu_mem_arena: true, enable_mem_pattern: true, enable_profiling: false, execution_mode: nil, graph_optimization_level: nil, inter_op_num_threads: nil, intra_op_num_threads: nil, log_severity_level: nil, log_verbosity_level: nil, logid: nil, optimized_model_filepath: nil)
       # session options
       session_options = ::FFI::MemoryPointer.new(:pointer)
       check_status api[:CreateSessionOptions].call(session_options)
+      check_status api[:EnableCpuMemArena].call(session_options.read_pointer) if enable_cpu_mem_arena
+      check_status api[:EnableMemPattern].call(session_options.read_pointer) if enable_mem_pattern
+      check_status api[:EnableProfiling].call(session_options.read_pointer, "onnxruntime_profile_") if enable_profiling
+      if execution_mode
+        mode =
+          case execution_mode
+          when :sequential
+            0
+          when :parallel
+            1
+          else
+            raise ArgumentError, "Invalid execution mode"
+          end
+        check_status api[:SetSessionExecutionMode].call(session_options.read_pointer, mode)
+      end
+      check_status api[:SetSessionGraphOptimizationLevel].call(session_options.read_pointer, graph_optimization_level) if graph_optimization_level
+      check_status api[:SetInterOpNumThreads].call(session_options.read_pointer, inter_op_num_threads) if inter_op_num_threads
+      check_status api[:SetIntraOpNumThreads].call(session_options.read_pointer, intra_op_num_threads) if intra_op_num_threads
+      check_status api[:SetSessionLogSeverityLevel].call(session_options.read_pointer, log_severity_level) if log_severity_level
+      check_status api[:SetSessionLogVerbosityLevel].call(session_options.read_pointer, log_verbosity_level) if log_verbosity_level
+      check_status api[:SetSessionLogId].call(session_options.read_pointer, logid) if logid
+      check_status api[:SetOptimizedModelFilePath].call(session_options.read_pointer, optimized_model_filepath) if optimized_model_filepath
 
       # session
       @session = ::FFI::MemoryPointer.new(:pointer)
@@ -53,7 +75,8 @@ module OnnxRuntime
       end
     end
 
-    def run(output_names, input_feed)
+    # TODO support logid
+    def run(output_names, input_feed, log_severity_level: nil, log_verbosity_level: nil, logid: nil, terminate: nil)
       input_tensor = create_input_tensor(input_feed)
 
       output_names ||= @outputs.map { |v| v[:name] }
@@ -61,8 +84,16 @@ module OnnxRuntime
       output_tensor = ::FFI::MemoryPointer.new(:pointer, outputs.size)
       input_node_names = create_node_names(input_feed.keys.map(&:to_s))
       output_node_names = create_node_names(output_names.map(&:to_s))
-      # TODO support run options
-      check_status api[:Run].call(read_pointer, nil, input_node_names, input_tensor, input_feed.size, output_node_names, output_names.size, output_tensor)
+
+      # run options
+      run_options = ::FFI::MemoryPointer.new(:pointer)
+      check_status api[:CreateRunOptions].call(run_options)
+      check_status api[:RunOptionsSetRunLogSeverityLevel].call(run_options.read_pointer, log_severity_level) if log_severity_level
+      check_status api[:RunOptionsSetRunLogVerbosityLevel].call(run_options.read_pointer, log_verbosity_level) if log_verbosity_level
+      check_status api[:RunOptionsSetRunTag].call(run_options.read_pointer, logid) if logid
+      check_status api[:RunOptionsSetTerminate].call(run_options.read_pointer) if terminate
+
+      check_status api[:Run].call(read_pointer, run_options.read_pointer, input_node_names, input_tensor, input_feed.size, output_node_names, output_names.size, output_tensor)
 
       output_names.size.times.map do |i|
         create_from_onnx_value(output_tensor[i].read_pointer)

data/lib/onnxruntime/model.rb

@@ -1,11 +1,11 @@
 module OnnxRuntime
   class Model
-    def initialize(path_or_bytes)
-      @session = InferenceSession.new(path_or_bytes)
+    def initialize(path_or_bytes, **session_options)
+      @session = InferenceSession.new(path_or_bytes, **session_options)
     end
 
-    def predict(input_feed, output_names: nil)
-      predictions = @session.run(output_names, input_feed)
+    def predict(input_feed, output_names: nil, **run_options)
+      predictions = @session.run(output_names, input_feed, **run_options)
       output_names ||= outputs.map { |o| o[:name] }
 
       result = {}

data/lib/onnxruntime/version.rb

@@ -1,3 +1,3 @@
 module OnnxRuntime
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: onnxruntime
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-20 00:00:00.000000000 Z
+date: 2019-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -76,6 +76,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/onnxruntime.rb
+- lib/onnxruntime/datasets.rb
 - lib/onnxruntime/ffi.rb
 - lib/onnxruntime/inference_session.rb
 - lib/onnxruntime/model.rb