onnxruntime 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc2115e3b32ec7d1d0ab2da64edfb5bf2ebf24ecc6ad705d4a53ae4793e60412
-  data.tar.gz: 5e53efd5de12ed5ac06a7e4472c8ee043ffbbba9c82b5f49e340f6a70a4dfcdf
+  metadata.gz: 316527780be2781a474d0813aff47d840654423823ad83b8b52b13752caf6814
+  data.tar.gz: 5954ba2dc4223b8330fb52e8474be78542360c2f4c1cb5946529d062c0b1b864
 SHA512:
-  metadata.gz: 93f83646d23298213b971ea7462ce4e5cc970c49d7572b646a6f8003b05689a5a232a3acc05b9cacfbabf65534c046d687eecc80fbf5583b2691391d30b54872
-  data.tar.gz: fc0349312d70944a2169302e8b9f1f70f255e29b60c523f0ba1a688ac162cc230636f9ef333d6ac032d855d9387d88234181a69edade6407bde027050972a2da
+  metadata.gz: c127874dd75a10b8cb9d9d033e607f9d73069bb5709d7b9ecee04c1d59f969f61db6ec88fd569188b0a35c8276f7611619f81662f3735fbd53e61938f15c6822
+  data.tar.gz: 77a7c9f8c98b25fd82ee8818c63176d2005f846db489b5973330220344be8fd47d8e5279517a716f8c1222f729a248fc8ac80cb610633dbdc35c49418a42ea1c

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 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

data/README.md

@@ -87,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/ffi.rb

@@ -74,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),

data/lib/onnxruntime/inference_session.rb

@@ -80,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] }
@@ -100,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
@@ -180,18 +180,19 @@ module OnnxRuntime
       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 Error, "Unknown input: #{input_name}" unless inp
@@ -200,22 +201,35 @@ module OnnxRuntime
         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])
@@ -234,7 +248,7 @@ 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)
       type = FFI::OnnxType[out_type.read_int]
@@ -257,17 +271,36 @@ module OnnxRuntime
 
         # 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)
@@ -275,7 +308,7 @@ module OnnxRuntime
         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)
@@ -294,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
@@ -308,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
@@ -390,6 +440,30 @@ module OnnxRuntime
       raise Error, "Unsupported #{name} type: #{type}"
     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
       self.class.api
     end

data/lib/onnxruntime/version.rb

@@ -1,3 +1,3 @@
 module OnnxRuntime
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: onnxruntime
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Andrew Kane
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-02 00:00:00.000000000 Z
+date: 2020-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -66,7 +66,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
-description: 
+description:
 email: andrew@chartkick.com
 executables: []
 extensions: []
@@ -91,7 +91,7 @@ homepage: https://github.com/ankane/onnxruntime
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -106,8 +106,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: High performance scoring engine for ML models
 test_files: []