onnxruntime 0.2.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa019e016dea45f795caba9b06e972edc6ae705d1599826fb17adf10af572851
-  data.tar.gz: e0704039d0c8a94bf523dce7f707636493696ee92aa3f741d5b49ea62561e6d5
+  metadata.gz: b7d22851572b35128d1e2bbcc041b4989851e02354cace5389afc25855674b11
+  data.tar.gz: f1eee285e5dbff1fbf6de4e350560e3e386e1f4d26d53810f154cd16117e38e6
 SHA512:
-  metadata.gz: 07dbde3621a15379bceb5b0fe7bfbb2bb581cb54a1b78d0f104f432396bac9086ab3c6186798fab52026515c8331074b35a68f6cce6748d3315e10bc375c3a9a
-  data.tar.gz: ccc9ee30c55d0c8ae611b70adeab1b8707bc15bce42281ce05ca6bb9d4d6ff4953c2795a3931f4ff325401a3caea95d62e08243732d125cebda9dfb4587bdbc8
+  metadata.gz: f89ba13181bfcc8cdf35356efae175d0e2c7a0787a13af8d46788645046f057bce466e28566c0f2982f52893dbb7cc1553a741b1ca4923066e90c0a5fb230edf
+  data.tar.gz: 3843b9c1e5a9432d3b72ebb33498aaef0fb6edf8942a9f0b6794bed36fb95df67290e6c4385e19927e5404510d89ad8965b15de0a96246b7f1770c4fb01216f6

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 0.3.3 (2020-06-17)
+
+- Fixed segmentation fault on exit on Linux
+
+## 0.3.2 (2020-06-16)
+
+- Fixed error with FFI 1.13.0+
+- Added friendly graph optimization levels
+
+## 0.3.1 (2020-05-18)
+
+- Updated ONNX Runtime to 1.3.0
+- Added `custom_metadata_map` to model metadata
+
+## 0.3.0 (2020-03-11)
+
+- Updated ONNX Runtime to 1.2.0
+- Added model metadata
+- Added `end_profiling` method
+- Added support for loading from IO objects
+- Improved `input` and `output` for `seq` and `map` types
+
+## 0.2.3 (2020-01-23)
+
+- Updated ONNX Runtime to 1.1.1
+
 ## 0.2.2 (2019-12-24)
 
 - Added support for session options

data/LICENSE.txt

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

data/README.md

@@ -20,7 +20,7 @@ Load a model and make predictions
 
 ```ruby
 model = OnnxRuntime::Model.new("model.onnx")
-model.predict(x: [1, 2, 3])
+model.predict({x: [1, 2, 3]})
 ```
 
 > Download pre-trained models from the [ONNX Model Zoo](https://github.com/onnx/models)
@@ -37,10 +37,16 @@ Get outputs
 model.outputs
 ```
 
+Get metadata
+
+```ruby
+model.metadata
+```
+
 Load a model from a string
 
 ```ruby
-byte_str = File.binread("model.onnx")
+byte_str = StringIO.new("...")
 model = OnnxRuntime::Model.new(byte_str)
 ```
 
@@ -57,8 +63,8 @@ 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,
+  execution_mode: :sequential,    # :sequential or :parallel
+  graph_optimization_level: nil,  # :none, :basic, :extended, or :all
   inter_op_num_threads: nil,
   intra_op_num_threads: nil,
   log_severity_level: 2,

data/lib/onnxruntime.rb

@@ -19,7 +19,7 @@ module OnnxRuntime
   self.ffi_lib = [vendor_lib]
 
   def self.lib_version
-    FFI.OrtGetApiBase[:GetVersionString].call
+    FFI.OrtGetApiBase[:GetVersionString].call.read_string
   end
 
   # friendlier error message

data/lib/onnxruntime/ffi.rb

@@ -20,7 +20,7 @@ module OnnxRuntime
       layout \
         :CreateStatus, callback(%i[int string], :pointer),
         :GetErrorCode, callback(%i[pointer], :pointer),
-        :GetErrorMessage, callback(%i[pointer], :string),
+        :GetErrorMessage, callback(%i[pointer], :pointer),
         :CreateEnv, callback(%i[int string pointer], :pointer),
         :CreateEnvWithCustomLogger, callback(%i[], :pointer),
         :EnableTelemetryEvents, callback(%i[pointer], :pointer),
@@ -119,7 +119,30 @@ module OnnxRuntime
         :ReleaseTypeInfo, callback(%i[pointer], :void),
         :ReleaseTensorTypeAndShapeInfo, callback(%i[pointer], :void),
         :ReleaseSessionOptions, callback(%i[pointer], :void),
-        :ReleaseCustomOpDomain, callback(%i[pointer], :void)
+        :ReleaseCustomOpDomain, callback(%i[pointer], :void),
+        :GetDenotationFromTypeInfo, callback(%i[], :pointer),
+        :CastTypeInfoToMapTypeInfo, callback(%i[pointer pointer], :pointer),
+        :CastTypeInfoToSequenceTypeInfo, callback(%i[pointer pointer], :pointer),
+        :GetMapKeyType, callback(%i[pointer pointer], :pointer),
+        :GetMapValueType, callback(%i[pointer pointer], :pointer),
+        :GetSequenceElementType, callback(%i[pointer pointer], :pointer),
+        :ReleaseMapTypeInfo, callback(%i[pointer], :void),
+        :ReleaseSequenceTypeInfo, callback(%i[pointer], :void),
+        :SessionEndProfiling, callback(%i[pointer pointer pointer], :pointer),
+        :SessionGetModelMetadata, callback(%i[pointer pointer], :pointer),
+        :ModelMetadataGetProducerName, callback(%i[pointer pointer pointer], :pointer),
+        :ModelMetadataGetGraphName, callback(%i[pointer pointer pointer], :pointer),
+        :ModelMetadataGetDomain, callback(%i[pointer pointer pointer], :pointer),
+        :ModelMetadataGetDescription, callback(%i[pointer pointer pointer], :pointer),
+        :ModelMetadataLookupCustomMetadataMap, callback(%i[pointer pointer pointer pointer], :pointer),
+        :ModelMetadataGetVersion, callback(%i[pointer pointer], :pointer),
+        :ReleaseModelMetadata, callback(%i[pointer], :void),
+        :CreateEnvWithGlobalThreadPools, callback(%i[], :pointer),
+        :DisablePerSessionThreads, callback(%i[], :pointer),
+        :CreateThreadingOptions, callback(%i[], :pointer),
+        :ReleaseThreadingOptions, callback(%i[], :pointer),
+        :ModelMetadataGetCustomMetadataMapKeys, callback(%i[pointer pointer pointer pointer], :pointer),
+        :AddFreeDimensionOverrideByName, callback(%i[], :pointer)
     end
 
     class ApiBase < ::FFI::Struct
@@ -127,7 +150,7 @@ module OnnxRuntime
       # to prevent "unable to resolve type" error on Ubuntu
       layout \
         :GetApi, callback(%i[uint32], Api.by_ref),
-        :GetVersionString, callback(%i[], :string)
+        :GetVersionString, callback(%i[], :pointer)
     end
 
     attach_function :OrtGetApiBase, %i[], ApiBase.by_ref

data/lib/onnxruntime/inference_session.rb

@@ -10,18 +10,17 @@ module OnnxRuntime
       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
+        execution_modes = {sequential: 0, parallel: 1}
+        mode = execution_modes[execution_mode]
+        raise ArgumentError, "Invalid execution mode" unless mode
         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
+      if graph_optimization_level
+        optimization_levels = {none: 0, basic: 1, extended: 2, all: 99}
+        # TODO raise error in 0.4.0
+        level = optimization_levels[graph_optimization_level] || graph_optimization_level
+        check_status api[:SetSessionGraphOptimizationLevel].call(session_options.read_pointer, level)
+      end
       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
@@ -31,18 +30,27 @@ module OnnxRuntime
 
       # session
       @session = ::FFI::MemoryPointer.new(:pointer)
-      path_or_bytes = path_or_bytes.to_str
+      from_memory =
+        if path_or_bytes.respond_to?(:read)
+          path_or_bytes = path_or_bytes.read
+          true
+        else
+          path_or_bytes = path_or_bytes.to_str
+          path_or_bytes.encoding == Encoding::BINARY
+        end
 
       # fix for Windows "File doesn't exist"
-      if Gem.win_platform? && path_or_bytes.encoding != Encoding::BINARY
+      if Gem.win_platform? && !from_memory
         path_or_bytes = File.binread(path_or_bytes)
+        from_memory = true
       end
 
-      if path_or_bytes.encoding == Encoding::BINARY
+      if from_memory
         check_status api[:CreateSessionFromArray].call(env.read_pointer, path_or_bytes, path_or_bytes.bytesize, session_options.read_pointer, @session)
       else
         check_status api[:CreateSession].call(env.read_pointer, path_or_bytes, session_options.read_pointer, @session)
       end
+      ObjectSpace.define_finalizer(self, self.class.finalize(@session))
 
       # input info
       allocator = ::FFI::MemoryPointer.new(:pointer)
@@ -73,6 +81,8 @@ module OnnxRuntime
         check_status api[:SessionGetOutputTypeInfo].call(read_pointer, i, typeinfo)
         @outputs << {name: name_ptr.read_pointer.read_string}.merge(node_info(typeinfo))
       end
+    ensure
+      # release :SessionOptions, session_options
     end
 
     # TODO support logid
@@ -98,6 +108,58 @@ module OnnxRuntime
       output_names.size.times.map do |i|
         create_from_onnx_value(output_tensor[i].read_pointer)
       end
+    ensure
+      release :RunOptions, run_options
+      if input_tensor
+        input_feed.size.times do |i|
+          release :Value, input_tensor[i]
+        end
+      end
+    end
+
+    def modelmeta
+      keys = ::FFI::MemoryPointer.new(:pointer)
+      num_keys = ::FFI::MemoryPointer.new(:int64_t)
+      description = ::FFI::MemoryPointer.new(:string)
+      domain = ::FFI::MemoryPointer.new(:string)
+      graph_name = ::FFI::MemoryPointer.new(:string)
+      producer_name = ::FFI::MemoryPointer.new(:string)
+      version = ::FFI::MemoryPointer.new(:int64_t)
+
+      metadata = ::FFI::MemoryPointer.new(:pointer)
+      check_status api[:SessionGetModelMetadata].call(read_pointer, metadata)
+
+      custom_metadata_map = {}
+      check_status = api[:ModelMetadataGetCustomMetadataMapKeys].call(metadata.read_pointer, @allocator.read_pointer, keys, num_keys)
+      num_keys.read(:int64_t).times do |i|
+        key = keys.read_pointer[i * ::FFI::Pointer.size].read_pointer.read_string
+        value = ::FFI::MemoryPointer.new(:string)
+        check_status api[:ModelMetadataLookupCustomMetadataMap].call(metadata.read_pointer, @allocator.read_pointer, key, value)
+        custom_metadata_map[key] = value.read_pointer.read_string
+      end
+
+      check_status api[:ModelMetadataGetDescription].call(metadata.read_pointer, @allocator.read_pointer, description)
+      check_status api[:ModelMetadataGetDomain].call(metadata.read_pointer, @allocator.read_pointer, domain)
+      check_status api[:ModelMetadataGetGraphName].call(metadata.read_pointer, @allocator.read_pointer, graph_name)
+      check_status api[:ModelMetadataGetProducerName].call(metadata.read_pointer, @allocator.read_pointer, producer_name)
+      check_status api[:ModelMetadataGetVersion].call(metadata.read_pointer, version)
+
+      {
+        custom_metadata_map: custom_metadata_map,
+        description: description.read_pointer.read_string,
+        domain: domain.read_pointer.read_string,
+        graph_name: graph_name.read_pointer.read_string,
+        producer_name: producer_name.read_pointer.read_string,
+        version: version.read(:int64_t)
+      }
+    ensure
+      release :ModelMetadata, metadata
+    end
+
+    def end_profiling
+      out = ::FFI::MemoryPointer.new(:string)
+      check_status api[:SessionEndProfiling].call(read_pointer, @allocator.read_pointer, out)
+      out.read_pointer.read_string
     end
 
     private
@@ -181,6 +243,8 @@ module OnnxRuntime
         output_tensor_size = api[:GetTensorShapeElementCount].call(typeinfo.read_pointer, out_size)
         output_tensor_size = read_size_t(out_size)
 
+        release :TensorTypeAndShapeInfo, typeinfo
+
         # TODO support more types
         type = FFI::TensorElementDataType[type]
         arr =
@@ -213,6 +277,7 @@ module OnnxRuntime
         check_status api[:GetValue].call(out_ptr, 1, @allocator.read_pointer, map_values)
         check_status api[:GetTensorTypeAndShape].call(map_keys.read_pointer, type_shape)
         check_status api[:GetTensorElementType].call(type_shape.read_pointer, elem_type)
+        release :TensorTypeAndShapeInfo, type_shape
 
         # TODO support more types
         elem_type = FFI::TensorElementDataType[elem_type.read_int]
@@ -239,7 +304,7 @@ module OnnxRuntime
 
     def check_status(status)
       unless status.null?
-        message = api[:GetErrorMessage].call(status)
+        message = api[:GetErrorMessage].call(status).read_string
         api[:ReleaseStatus].call(status)
         raise OnnxRuntime::Error, message
       end
@@ -253,6 +318,7 @@ module OnnxRuntime
       case type
       when :tensor
         tensor_info = ::FFI::MemoryPointer.new(:pointer)
+        # don't free tensor_info
         check_status api[:CastTypeInfoToTensorInfo].call(typeinfo.read_pointer, tensor_info)
 
         type, shape = tensor_type_and_shape(tensor_info)
@@ -261,22 +327,39 @@ module OnnxRuntime
           shape: shape
         }
       when :sequence
-        # TODO show nested
+        sequence_type_info = ::FFI::MemoryPointer.new(:pointer)
+        check_status api[:CastTypeInfoToSequenceTypeInfo].call(typeinfo.read_pointer, sequence_type_info)
+        nested_type_info = ::FFI::MemoryPointer.new(:pointer)
+        check_status api[:GetSequenceElementType].call(sequence_type_info.read_pointer, nested_type_info)
+        v = node_info(nested_type_info)[:type]
+
         {
-          type: "seq",
+          type: "seq(#{v})",
           shape: []
         }
       when :map
-        # TODO show nested
+        map_type_info = ::FFI::MemoryPointer.new(:pointer)
+        check_status api[:CastTypeInfoToMapTypeInfo].call(typeinfo.read_pointer, map_type_info)
+
+        # key
+        key_type = ::FFI::MemoryPointer.new(:int)
+        check_status api[:GetMapKeyType].call(map_type_info.read_pointer, key_type)
+        k = FFI::TensorElementDataType[key_type.read_int]
+
+        # value
+        value_type_info = ::FFI::MemoryPointer.new(:pointer)
+        check_status api[:GetMapValueType].call(map_type_info.read_pointer, value_type_info)
+        v = node_info(value_type_info)[:type]
+
         {
-          type: "map",
+          type: "map(#{k},#{v})",
           shape: []
         }
       else
         unsupported_type("ONNX", type)
       end
     ensure
-      api[:ReleaseTypeInfo].call(typeinfo.read_pointer)
+      release :TypeInfo, typeinfo
     end
 
     def tensor_type_and_shape(tensor_info)
@@ -307,7 +390,24 @@ module OnnxRuntime
     end
 
     def api
-      @api ||= FFI.OrtGetApiBase[:GetApi].call(1)
+      self.class.api
+    end
+
+    def release(*args)
+      self.class.release(*args)
+    end
+
+    def self.api
+      @api ||= FFI.OrtGetApiBase[:GetApi].call(3)
+    end
+
+    def self.release(type, pointer)
+      api[:"Release#{type}"].call(pointer.read_pointer) if pointer && !pointer.null?
+    end
+
+    def self.finalize(session)
+      # must use proc instead of stabby lambda
+      proc { release :Session, session }
     end
 
     def env
@@ -316,7 +416,7 @@ module OnnxRuntime
         @@env ||= begin
           env = ::FFI::MemoryPointer.new(:pointer)
           check_status api[:CreateEnv].call(3, "Default", env)
-          at_exit { api[:ReleaseEnv].call(env.read_pointer) }
+          at_exit { release :Env, env }
           # disable telemetry
           # https://github.com/microsoft/onnxruntime/blob/master/docs/Privacy.md
           check_status api[:DisableTelemetryEvents].call(env)

data/lib/onnxruntime/model.rb

@@ -22,5 +22,9 @@ module OnnxRuntime
     def outputs
       @session.outputs
     end
+
+    def metadata
+      @session.modelmeta
+    end
   end
 end

data/lib/onnxruntime/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: onnxruntime
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-24 00:00:00.000000000 Z
+date: 2020-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -106,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: High performance scoring engine for ML models