onnxruntime 0.3.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7d22851572b35128d1e2bbcc041b4989851e02354cace5389afc25855674b11
-  data.tar.gz: f1eee285e5dbff1fbf6de4e350560e3e386e1f4d26d53810f154cd16117e38e6
+  metadata.gz: 4b0bef4682d8d44fb3cfd3fa619c1e7e620943014a22f259e14bfa1692dbe2ef
+  data.tar.gz: bfe59759c177613806ab0ddd97c4d8a68a7e3915299d81aab3e9d369ce672918
 SHA512:
-  metadata.gz: f89ba13181bfcc8cdf35356efae175d0e2c7a0787a13af8d46788645046f057bce466e28566c0f2982f52893dbb7cc1553a741b1ca4923066e90c0a5fb230edf
-  data.tar.gz: 3843b9c1e5a9432d3b72ebb33498aaef0fb6edf8942a9f0b6794bed36fb95df67290e6c4385e19927e5404510d89ad8965b15de0a96246b7f1770c4fb01216f6
+  metadata.gz: f0dfc6c0a91621b5637e56061b40ba26648a7e538d84cb2c135a06c1832c9f71aba2e7fb7ab849750756540d02632726b3f45732a8c50649ca4ace03befbe086
+  data.tar.gz: 59a01f8d955f9d31f35864a9217fcf79eb35876229e749c5c50b4572903d9dc3e312a4a7a55612e9c36e3095a797da58637442ac0bb191adcb743b62fefb0905

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## 0.6.0 (2021-03-14)
+
+- Updated ONNX Runtime to 1.7.0
+- OpenMP is no longer required
+
+## 0.5.2 (2020-12-27)
+
+- Updated ONNX Runtime to 1.6.0
+- Fixed error with `execution_mode` option
+- Fixed error with `bool` input
+
+## 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

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) Microsoft Corporation
+Copyright (c) 2019-2021 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

@@ -4,7 +4,7 @@
 
 Check out [an example](https://ankane.org/tensorflow-ruby)
 
-[![Build Status](https://travis-ci.org/ankane/onnxruntime.svg?branch=master)](https://travis-ci.org/ankane/onnxruntime) [![Build status](https://ci.appveyor.com/api/projects/status/f2bq6ruqjf4jx671/branch/master?svg=true)](https://ci.appveyor.com/project/ankane/onnxruntime/branch/master)
+[![Build Status](https://github.com/ankane/onnxruntime/workflows/build/badge.svg?branch=master)](https://github.com/ankane/onnxruntime/actions)
 
 ## Installation
 
@@ -81,7 +81,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/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
@@ -25,14 +28,14 @@ module OnnxRuntime
         :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),
+        :SetSessionExecutionMode, callback(%i[pointer int], :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
@@ -154,5 +159,13 @@ module OnnxRuntime
     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,7 +8,7 @@ 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
         execution_modes = {sequential: 0, parallel: 1}
         mode = execution_modes[execution_mode]
@@ -17,8 +17,8 @@ module OnnxRuntime
       end
       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
+        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
@@ -26,7 +26,7 @@ module OnnxRuntime
       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)
@@ -39,16 +39,10 @@ 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))
 
@@ -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,7 +68,7 @@ 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)
@@ -86,7 +80,7 @@ module OnnxRuntime
     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] }
@@ -106,7 +100,7 @@ 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
@@ -130,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)
@@ -156,56 +150,86 @@ module OnnxRuntime
       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
+                input_tensor_values.write_array_of_uint8(flat_input.map { |v| v ? 1 : 0 })
+              else
+                input_tensor_values.send("write_array_of_#{tensor_type}", flat_input)
+              end
             end
-            input_tensor_values.send("write_array_of_#{tensor_type}", flat_input)
+
             type_enum = FFI::TensorElementDataType[tensor_type]
           else
             unsupported_type("input", inp[:type])
@@ -224,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
@@ -241,31 +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_uint8(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)
@@ -284,8 +327,8 @@ module OnnxRuntime
         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
@@ -298,6 +341,23 @@ 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
@@ -306,7 +366,7 @@ module OnnxRuntime
       unless status.null?
         message = api[:GetErrorMessage].call(status).read_string
         api[:ReleaseStatus].call(status)
-        raise OnnxRuntime::Error, message
+        raise Error, message
       end
     end
 
@@ -368,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)
@@ -377,16 +437,31 @@ 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
@@ -398,7 +473,7 @@ module OnnxRuntime
     end
 
     def self.api
-      @api ||= FFI.OrtGetApiBase[:GetApi].call(3)
+      @api ||= FFI.OrtGetApiBase[:GetApi].call(4)
     end
 
     def self.release(type, pointer)
@@ -410,6 +485,21 @@ module OnnxRuntime
       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
       # use mutex for thread-safety
       Utils.mutex.synchronize do