onnxruntime 0.3.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d4b9ddc710644eab07227fe005c92ad039643e989236e5f112a83df2266fc55
-  data.tar.gz: d15c9ac4ae98130499d1411d3be2e7b822df8248550c0ad44c2e7a02d88f95d8
+  metadata.gz: 316527780be2781a474d0813aff47d840654423823ad83b8b52b13752caf6814
+  data.tar.gz: 5954ba2dc4223b8330fb52e8474be78542360c2f4c1cb5946529d062c0b1b864
 SHA512:
-  metadata.gz: 83a2e3699506460b8b280376ec8935a680e7e2cffe6bf7dd6766a85eea84bf06273e13889b6a2961c9df3c277be6ea7d8afbb67a4d4be62d50b266d7ccd8dc55
-  data.tar.gz: 5086c2c04f76ec67224e7dbc9ccc36366b394840296536232b29d92009c7a4ef637fb4f39daec8abb7a5e3fdcca591675cfaf3e4a8e31ec939f9aa1e2ae6f112
+  metadata.gz: c127874dd75a10b8cb9d9d033e607f9d73069bb5709d7b9ecee04c1d59f969f61db6ec88fd569188b0a35c8276f7611619f81662f3735fbd53e61938f15c6822
+  data.tar.gz: 77a7c9f8c98b25fd82ee8818c63176d2005f846db489b5973330220344be8fd47d8e5279517a716f8c1222f729a248fc8ac80cb610633dbdc35c49418a42ea1c

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+## 0.5.1 (2020-11-01)
+
+- Updated ONNX Runtime to 1.5.2
+- Added support for string output
+- Added `output_type` option
+- Improved performance for Numo array inputs
+
+## 0.5.0 (2020-10-01)
+
+- Updated ONNX Runtime to 1.5.1
+- OpenMP is now required on Mac
+- Fixed `mul_1.onnx` example
+
+## 0.4.0 (2020-07-20)
+
+- Updated ONNX Runtime to 1.4.0
+- Added `providers` method
+- Fixed errors on Windows
+
+## 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

data/LICENSE.txt

@@ -1,23 +1,22 @@
-Copyright (c) 2019-2020 Andrew Kane
-Datasets Copyright (c) Microsoft Corporation
-
 MIT License
 
-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:
+Copyright (c) 2018 Microsoft Corporation
+Copyright (c) 2019-2020 Andrew Kane
+
+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 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.
+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

@@ -14,6 +14,12 @@ Add this line to your application’s Gemfile:
 gem 'onnxruntime'
 ```
 
+On Mac, also install OpenMP:
+
+```sh
+brew install libomp
+```
+
 ## Getting Started
 
 Load a model and make predictions
@@ -63,8 +69,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,
@@ -81,7 +87,8 @@ model.predict(input_feed, {
   log_severity_level: 2,
   log_verbosity_level: 0,
   logid: nil,
-  terminate: false
+  terminate: false,
+  output_type: :ruby       # :ruby or :numo
 })
 ```
 

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

@@ -3,10 +3,13 @@ module OnnxRuntime
     extend ::FFI::Library
 
     begin
-      ffi_lib Array(OnnxRuntime.ffi_lib)
+      ffi_lib OnnxRuntime.ffi_lib
     rescue LoadError => e
-      raise e if ENV["ONNXRUNTIME_DEBUG"]
-      raise LoadError, "Could not find ONNX Runtime"
+      if e.message.include?("Library not loaded: /usr/local/opt/libomp/lib/libomp.dylib") && e.message.include?("Reason: image not found")
+        raise LoadError, "OpenMP not found. Run `brew install libomp`"
+      else
+        raise e
+      end
     end
 
     # https://github.com/microsoft/onnxruntime/blob/master/include/onnxruntime/core/session/onnxruntime_c_api.h
@@ -20,19 +23,19 @@ 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),
         :DisableTelemetryEvents, callback(%i[pointer], :pointer),
-        :CreateSession, callback(%i[pointer string pointer pointer], :pointer),
+        :CreateSession, callback(%i[pointer pointer pointer pointer], :pointer),
         :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 string], :pointer),
+        :SetOptimizedModelFilePath, callback(%i[pointer pointer], :pointer),
         :CloneSessionOptions, callback(%i[], :pointer),
         :SetSessionExecutionMode, callback(%i[], :pointer),
-        :EnableProfiling, callback(%i[pointer string], :pointer),
+        :EnableProfiling, callback(%i[pointer pointer], :pointer),
         :DisableProfiling, callback(%i[pointer], :pointer),
         :EnableMemPattern, callback(%i[pointer], :pointer),
         :DisableMemPattern, callback(%i[pointer], :pointer),
@@ -71,8 +74,8 @@ module OnnxRuntime
         :IsTensor, callback(%i[], :pointer),
         :GetTensorMutableData, callback(%i[pointer pointer], :pointer),
         :FillStringTensor, callback(%i[pointer pointer size_t], :pointer),
-        :GetStringTensorDataLength, callback(%i[], :pointer),
-        :GetStringTensorContent, callback(%i[], :pointer),
+        :GetStringTensorDataLength, callback(%i[pointer pointer], :pointer),
+        :GetStringTensorContent, callback(%i[pointer pointer size_t pointer size_t], :pointer),
         :CastTypeInfoToTensorInfo, callback(%i[pointer pointer], :pointer),
         :GetOnnxTypeFromTypeInfo, callback(%i[pointer pointer], :pointer),
         :CreateTensorTypeAndShapeInfo, callback(%i[], :pointer),
@@ -142,7 +145,9 @@ module OnnxRuntime
         :CreateThreadingOptions, callback(%i[], :pointer),
         :ReleaseThreadingOptions, callback(%i[], :pointer),
         :ModelMetadataGetCustomMetadataMapKeys, callback(%i[pointer pointer pointer pointer], :pointer),
-        :AddFreeDimensionOverrideByName, callback(%i[], :pointer)
+        :AddFreeDimensionOverrideByName, callback(%i[], :pointer),
+        :GetAvailableProviders, callback(%i[pointer pointer], :pointer),
+        :ReleaseAvailableProviders, callback(%i[pointer int], :pointer)
     end
 
     class ApiBase < ::FFI::Struct
@@ -150,9 +155,17 @@ 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
+
+    if Gem.win_platform?
+      class Libc
+        extend ::FFI::Library
+        ffi_lib ::FFI::Library::LIBC
+        attach_function :mbstowcs, %i[pointer string size_t], :size_t
+      end
+    end
   end
 end

data/lib/onnxruntime/inference_session.rb

@@ -8,26 +8,25 @@ module OnnxRuntime
       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
+      check_status api[:EnableProfiling].call(session_options.read_pointer, ort_string("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}
+        level = optimization_levels[graph_optimization_level]
+        raise ArgumentError, "Invalid graph optimization level" unless 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
       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
+      check_status api[:SetOptimizedModelFilePath].call(session_options.read_pointer, ort_string(optimized_model_filepath)) if optimized_model_filepath
 
       # session
       @session = ::FFI::MemoryPointer.new(:pointer)
@@ -40,17 +39,12 @@ module OnnxRuntime
           path_or_bytes.encoding == Encoding::BINARY
         end
 
-      # fix for Windows "File doesn't exist"
-      if Gem.win_platform? && !from_memory
-        path_or_bytes = File.binread(path_or_bytes)
-        from_memory = true
-      end
-
       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)
+        check_status api[:CreateSession].call(env.read_pointer, ort_string(path_or_bytes), session_options.read_pointer, @session)
       end
+      ObjectSpace.define_finalizer(self, self.class.finalize(@session))
 
       # input info
       allocator = ::FFI::MemoryPointer.new(:pointer)
@@ -63,7 +57,7 @@ module OnnxRuntime
       # input
       num_input_nodes = ::FFI::MemoryPointer.new(:size_t)
       check_status api[:SessionGetInputCount].call(read_pointer, num_input_nodes)
-      read_size_t(num_input_nodes).times do |i|
+      num_input_nodes.read(:size_t).times do |i|
         name_ptr = ::FFI::MemoryPointer.new(:string)
         check_status api[:SessionGetInputName].call(read_pointer, i, @allocator.read_pointer, name_ptr)
         typeinfo = ::FFI::MemoryPointer.new(:pointer)
@@ -74,17 +68,19 @@ module OnnxRuntime
       # output
       num_output_nodes = ::FFI::MemoryPointer.new(:size_t)
       check_status api[:SessionGetOutputCount].call(read_pointer, num_output_nodes)
-      read_size_t(num_output_nodes).times do |i|
+      num_output_nodes.read(:size_t).times do |i|
         name_ptr = ::FFI::MemoryPointer.new(:string)
         check_status api[:SessionGetOutputName].call(read_pointer, i, allocator.read_pointer, name_ptr)
         typeinfo = ::FFI::MemoryPointer.new(:pointer)
         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
-    def run(output_names, input_feed, log_severity_level: nil, log_verbosity_level: nil, logid: nil, terminate: nil)
+    def run(output_names, input_feed, log_severity_level: nil, log_verbosity_level: nil, logid: nil, terminate: nil, output_type: :ruby)
       input_tensor = create_input_tensor(input_feed)
 
       output_names ||= @outputs.map { |v| v[:name] }
@@ -104,7 +100,14 @@ module OnnxRuntime
       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)
+        create_from_onnx_value(output_tensor[i].read_pointer, output_type)
+      end
+    ensure
+      release :RunOptions, run_options
+      if input_tensor
+        input_feed.size.times do |i|
+          release :Value, input_tensor[i]
+        end
       end
     end
 
@@ -121,7 +124,7 @@ module OnnxRuntime
       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)
+      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)
@@ -134,7 +137,6 @@ module OnnxRuntime
       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)
-      api[:ReleaseModelMetadata].call(metadata.read_pointer)
 
       {
         custom_metadata_map: custom_metadata_map,
@@ -144,58 +146,90 @@ module OnnxRuntime
         producer_name: producer_name.read_pointer.read_string,
         version: version.read(:int64_t)
       }
+    ensure
+      release :ModelMetadata, metadata
     end
 
+    # return value has double underscore like Python
     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
 
+    # no way to set providers with C API yet
+    # so we can return all available providers
+    def providers
+      out_ptr = ::FFI::MemoryPointer.new(:pointer)
+      length_ptr = ::FFI::MemoryPointer.new(:int)
+      check_status api[:GetAvailableProviders].call(out_ptr, length_ptr)
+      length = length_ptr.read_int
+      providers = []
+      length.times do |i|
+        providers << out_ptr.read_pointer[i * ::FFI::Pointer.size].read_pointer.read_string
+      end
+      api[:ReleaseAvailableProviders].call(out_ptr.read_pointer, length)
+      providers
+    end
+
     private
 
     def create_input_tensor(input_feed)
       allocator_info = ::FFI::MemoryPointer.new(:pointer)
-      check_status = api[:CreateCpuMemoryInfo].call(1, 0, allocator_info)
+      check_status api[:CreateCpuMemoryInfo].call(1, 0, allocator_info)
       input_tensor = ::FFI::MemoryPointer.new(:pointer, input_feed.size)
 
       input_feed.each_with_index do |(input_name, input), idx|
-        input = input.to_a unless input.is_a?(Array)
+        if numo_array?(input)
+          shape = input.shape
+        else
+          input = input.to_a unless input.is_a?(Array)
 
-        shape = []
-        s = input
-        while s.is_a?(Array)
-          shape << s.size
-          s = s.first
+          shape = []
+          s = input
+          while s.is_a?(Array)
+            shape << s.size
+            s = s.first
+          end
         end
 
-        flat_input = input.flatten
-        input_tensor_size = flat_input.size
-
         # TODO support more types
         inp = @inputs.find { |i| i[:name] == input_name.to_s }
-        raise "Unknown input: #{input_name}" unless inp
+        raise Error, "Unknown input: #{input_name}" unless inp
 
         input_node_dims = ::FFI::MemoryPointer.new(:int64, shape.size)
         input_node_dims.write_array_of_int64(shape)
 
         if inp[:type] == "tensor(string)"
-          input_tensor_values = ::FFI::MemoryPointer.new(:pointer, input_tensor_size)
-          input_tensor_values.write_array_of_pointer(flat_input.map { |v| ::FFI::MemoryPointer.from_string(v) })
+          if numo_array?(input)
+            input_tensor_size = input.size
+            input_tensor_values = ::FFI::MemoryPointer.new(:pointer, input.size)
+            input_tensor_values.write_array_of_pointer(input_tensor_size.times.map { |i| ::FFI::MemoryPointer.from_string(input[i]) })
+          else
+            flat_input = input.flatten.to_a
+            input_tensor_size = flat_input.size
+            input_tensor_values = ::FFI::MemoryPointer.new(:pointer, input_tensor_size)
+            input_tensor_values.write_array_of_pointer(flat_input.map { |v| ::FFI::MemoryPointer.from_string(v) })
+          end
           type_enum = FFI::TensorElementDataType[:string]
           check_status api[:CreateTensorAsOrtValue].call(@allocator.read_pointer, input_node_dims, shape.size, type_enum, input_tensor[idx])
-          check_status api[:FillStringTensor].call(input_tensor[idx].read_pointer, input_tensor_values, flat_input.size)
+          check_status api[:FillStringTensor].call(input_tensor[idx].read_pointer, input_tensor_values, input_tensor_size)
         else
-          tensor_types = [:float, :uint8, :int8, :uint16, :int16, :int32, :int64, :bool, :double, :uint32, :uint64].map { |v| ["tensor(#{v})", v] }.to_h
           tensor_type = tensor_types[inp[:type]]
 
           if tensor_type
-            input_tensor_values = ::FFI::MemoryPointer.new(tensor_type, input_tensor_size)
-            if tensor_type == :bool
-              tensor_type = :uchar
-              flat_input = flat_input.map { |v| v ? 1 : 0 }
+            if numo_array?(input)
+              input_tensor_values = input.cast_to(numo_types[tensor_type]).to_binary
+            else
+              flat_input = input.flatten.to_a
+              input_tensor_values = ::FFI::MemoryPointer.new(tensor_type, flat_input.size)
+              if tensor_type == :bool
+                tensor_type = :uchar
+                flat_input = flat_input.map { |v| v ? 1 : 0 }
+              end
+              input_tensor_values.send("write_array_of_#{tensor_type}", flat_input)
             end
-            input_tensor_values.send("write_array_of_#{tensor_type}", flat_input)
+
             type_enum = FFI::TensorElementDataType[tensor_type]
           else
             unsupported_type("input", inp[:type])
@@ -214,9 +248,9 @@ module OnnxRuntime
       ptr
     end
 
-    def create_from_onnx_value(out_ptr)
+    def create_from_onnx_value(out_ptr, output_type)
       out_type = ::FFI::MemoryPointer.new(:int)
-      check_status = api[:GetValueType].call(out_ptr, out_type)
+      check_status api[:GetValueType].call(out_ptr, out_type)
       type = FFI::OnnxType[out_type.read_int]
 
       case type
@@ -231,29 +265,50 @@ module OnnxRuntime
 
         out_size = ::FFI::MemoryPointer.new(:size_t)
         output_tensor_size = api[:GetTensorShapeElementCount].call(typeinfo.read_pointer, out_size)
-        output_tensor_size = read_size_t(out_size)
+        output_tensor_size = out_size.read(:size_t)
+
+        release :TensorTypeAndShapeInfo, typeinfo
 
         # TODO support more types
         type = FFI::TensorElementDataType[type]
-        arr =
+
+        case output_type
+        when :numo
           case type
-          when :float, :uint8, :int8, :uint16, :int16, :int32, :int64, :double, :uint32, :uint64
-            tensor_data.read_pointer.send("read_array_of_#{type}", output_tensor_size)
-          when :bool
-            tensor_data.read_pointer.read_array_of_uchar(output_tensor_size).map { |v| v == 1 }
+          when :string
+            result = Numo::RObject.new(shape)
+            result.allocate
+            create_strings_from_onnx_value(out_ptr, output_tensor_size, result)
           else
-            unsupported_type("element", type)
+            numo_type = numo_types[type]
+            unsupported_type("element", type) unless numo_type
+            numo_type.from_binary(tensor_data.read_pointer.read_bytes(output_tensor_size * numo_type::ELEMENT_BYTE_SIZE), shape)
           end
+        when :ruby
+          arr =
+            case type
+            when :float, :uint8, :int8, :uint16, :int16, :int32, :int64, :double, :uint32, :uint64
+              tensor_data.read_pointer.send("read_array_of_#{type}", output_tensor_size)
+            when :bool
+              tensor_data.read_pointer.read_array_of_uchar(output_tensor_size).map { |v| v == 1 }
+            when :string
+              create_strings_from_onnx_value(out_ptr, output_tensor_size, [])
+            else
+              unsupported_type("element", type)
+            end
 
-        Utils.reshape(arr, shape)
+          Utils.reshape(arr, shape)
+        else
+          raise ArgumentError, "Invalid output type: #{output_type}"
+        end
       when :sequence
         out = ::FFI::MemoryPointer.new(:size_t)
         check_status api[:GetValueCount].call(out_ptr, out)
 
-        read_size_t(out).times.map do |i|
+        out.read(:size_t).times.map do |i|
           seq = ::FFI::MemoryPointer.new(:pointer)
           check_status api[:GetValue].call(out_ptr, i, @allocator.read_pointer, seq)
-          create_from_onnx_value(seq.read_pointer)
+          create_from_onnx_value(seq.read_pointer, output_type)
         end
       when :map
         type_shape = ::FFI::MemoryPointer.new(:pointer)
@@ -265,14 +320,15 @@ 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]
         case elem_type
         when :int64
           ret = {}
-          keys = create_from_onnx_value(map_keys.read_pointer)
-          values = create_from_onnx_value(map_values.read_pointer)
+          keys = create_from_onnx_value(map_keys.read_pointer, output_type)
+          values = create_from_onnx_value(map_values.read_pointer, output_type)
           keys.zip(values).each do |k, v|
             ret[k] = v
           end
@@ -285,15 +341,32 @@ module OnnxRuntime
       end
     end
 
+    def create_strings_from_onnx_value(out_ptr, output_tensor_size, result)
+      len = ::FFI::MemoryPointer.new(:size_t)
+      check_status api[:GetStringTensorDataLength].call(out_ptr, len)
+
+      s_len = len.read(:size_t)
+      s = ::FFI::MemoryPointer.new(:uchar, s_len)
+      offsets = ::FFI::MemoryPointer.new(:size_t, output_tensor_size)
+      check_status api[:GetStringTensorContent].call(out_ptr, s, s_len, offsets, output_tensor_size)
+
+      offsets = output_tensor_size.times.map { |i| offsets[i].read(:size_t) }
+      offsets << s_len
+      output_tensor_size.times do |i|
+        result[i] = s.get_bytes(offsets[i], offsets[i + 1] - offsets[i])
+      end
+      result
+    end
+
     def read_pointer
       @session.read_pointer
     end
 
     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
+        raise Error, message
       end
     end
 
@@ -305,6 +378,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)
@@ -345,7 +419,7 @@ module OnnxRuntime
         unsupported_type("ONNX", type)
       end
     ensure
-      api[:ReleaseTypeInfo].call(typeinfo.read_pointer)
+      release :TypeInfo, typeinfo
     end
 
     def tensor_type_and_shape(tensor_info)
@@ -354,7 +428,7 @@ module OnnxRuntime
 
       num_dims_ptr = ::FFI::MemoryPointer.new(:size_t)
       check_status api[:GetDimensionsCount].call(tensor_info.read_pointer, num_dims_ptr)
-      num_dims = read_size_t(num_dims_ptr)
+      num_dims = num_dims_ptr.read(:size_t)
 
       node_dims = ::FFI::MemoryPointer.new(:int64, num_dims)
       check_status api[:GetDimensions].call(tensor_info.read_pointer, node_dims, num_dims)
@@ -363,20 +437,67 @@ module OnnxRuntime
     end
 
     def unsupported_type(name, type)
-      raise "Unsupported #{name} type: #{type}"
+      raise Error, "Unsupported #{name} type: #{type}"
     end
 
-    # read(:size_t) not supported in FFI JRuby
-    def read_size_t(ptr)
-      if RUBY_PLATFORM == "java"
-        ptr.read_long
-      else
-        ptr.read(:size_t)
-      end
+    def tensor_types
+      @tensor_types ||= [:float, :uint8, :int8, :uint16, :int16, :int32, :int64, :bool, :double, :uint32, :uint64].map { |v| ["tensor(#{v})", v] }.to_h
+    end
+
+    def numo_array?(obj)
+      defined?(Numo::NArray) && obj.is_a?(Numo::NArray)
+    end
+
+    def numo_types
+      @numo_types ||= {
+        float: Numo::SFloat,
+        uint8: Numo::UInt8,
+        int8: Numo::Int8,
+        uint16: Numo::UInt16,
+        int16: Numo::Int16,
+        int32: Numo::Int32,
+        int64: Numo::Int64,
+        bool: Numo::UInt8,
+        double: Numo::DFloat,
+        uint32: Numo::UInt32,
+        uint64: Numo::UInt64
+      }
     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(4)
+    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
+
+    # wide string on Windows
+    # char string on Linux
+    # see ORTCHAR_T in onnxruntime_c_api.h
+    def ort_string(str)
+      if Gem.win_platform?
+        max = str.size + 1 # for null byte
+        dest = ::FFI::MemoryPointer.new(:wchar_t, max)
+        ret = FFI::Libc.mbstowcs(dest, str, max)
+        raise Error, "Expected mbstowcs to return #{str.size}, got #{ret}" if ret != str.size
+        dest
+      else
+        str
+      end
     end
 
     def env
@@ -385,7 +506,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)