onnxruntime 0.9.0-x86_64-linux → 0.9.2-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c38526ce6c2f08a536d1d7aee629317fe132b3f6263f38493fd862fcce39276
-  data.tar.gz: b10ec02a434a1e34cb4da2b0c31e00175fea896080588a871aadcbe38eb34c7e
+  metadata.gz: 0eabd84cc14295ecadfdc705e2b5416a3473635d9b144525f331e7020e1d7bcc
+  data.tar.gz: 49ba06cd93a0600e75ca6eadba9429757961000ab9d17d9a58628359cd73c313
 SHA512:
-  metadata.gz: 0de4e905e729f13c243e4685635eb96b41a93bb6d960ed1b77ad1df6263bd51834477ba433d3886fff033fece9ca796b96b0f264f81e5fe41f49c4bbcad1f697
-  data.tar.gz: 88cfe6f0ff07404b4732eced01a97eca04238c40db2602b1cd38309b6a3badd2e74dcd895943ef6bff2c9b1d068cfb744117eca61eedf8c370f52b9aee7bc709
+  metadata.gz: 1ce4d2d06b4fa8d31766851284a9c7bb77b409a47af8b17c07524c97004a4ebd74ef5f3ab34b1890d60d232c6c9df59ab5327315281f3e50f49a077a90303165
+  data.tar.gz: 47d1eb445aa92b2a1acdc0826d405e89c0affc1eb860c2e642cf13317adf427d95986f2f55718acf7272a1133f2269c58de98bef0e3c32411d4d114c63c6bbaf

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.9.2 (2024-09-04)
+
+- Updated ONNX Runtime to 1.19.2
+- Added support for CoreML
+
+## 0.9.1 (2024-05-22)
+
+- Updated ONNX Runtime to 1.18.0
+
 ## 0.9.0 (2024-02-27)
 
 - Updated ONNX Runtime to 1.17.1

data/README.md

@@ -4,7 +4,7 @@
 
 Check out [an example](https://ankane.org/tensorflow-ruby)
 
-[![Build Status](https://github.com/ankane/onnxruntime-ruby/workflows/build/badge.svg?branch=master)](https://github.com/ankane/onnxruntime-ruby/actions)
+[![Build Status](https://github.com/ankane/onnxruntime-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/ankane/onnxruntime-ruby/actions)
 
 ## Installation
 
@@ -108,7 +108,9 @@ 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:
+### 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
@@ -120,6 +122,14 @@ and use:
 model = OnnxRuntime::Model.new("model.onnx", providers: ["CUDAExecutionProvider"])
 ```
 
+### Mac
+
+Use:
+
+```ruby
+model = OnnxRuntime::Model.new("model.onnx", providers: ["CoreMLExecutionProvider"])
+```
+
 ## History
 
 View the [changelog](https://github.com/ankane/onnxruntime-ruby/blob/master/CHANGELOG.md)

data/lib/onnxruntime/ffi.rb

@@ -144,7 +144,7 @@ module OnnxRuntime
         :ReleaseAvailableProviders, callback(%i[pointer int], :pointer),
         :GetStringTensorElementLength, callback(%i[], :pointer),
         :GetStringTensorElement, callback(%i[], :pointer),
-        :FillStringTensorElement, callback(%i[], :pointer),
+        :FillStringTensorElement, callback(%i[pointer string size_t], :pointer),
         :AddSessionConfigEntry, callback(%i[pointer string string], :pointer),
         :CreateAllocator, callback(%i[], :pointer),
         :ReleaseAllocator, callback(%i[], :pointer),
@@ -224,7 +224,16 @@ module OnnxRuntime
         :UpdateCUDAProviderOptions, callback(%i[pointer pointer pointer size_t], :pointer),
         :GetCUDAProviderOptionsAsString, callback(%i[pointer pointer pointer], :pointer),
         :ReleaseCUDAProviderOptions, callback(%i[pointer], :void),
-        :SessionOptionsAppendExecutionProvider_MIGraphX, callback(%i[], :pointer)
+        :SessionOptionsAppendExecutionProvider_MIGraphX, callback(%i[], :pointer),
+        :AddExternalInitializers, callback(%i[], :pointer),
+        :CreateOpAttr, callback(%i[], :pointer),
+        :ReleaseOpAddr, callback(%i[pointer], :void),
+        :CreateOp, callback(%i[], :pointer),
+        :InvokeOp, callback(%i[], :pointer),
+        :ReleaseOp, callback(%i[pointer], :void),
+        :SessionOptionsAppendExecutionProvider, callback(%i[pointer pointer pointer pointer size_t], :pointer),
+        :CopyKernelInfo, callback(%i[], :pointer),
+        :ReleaseKernelInfo, callback(%i[pointer], :void)
     end
 
     class ApiBase < ::FFI::Struct
@@ -237,6 +246,10 @@ module OnnxRuntime
 
     attach_function :OrtGetApiBase, %i[], ApiBase.by_ref
 
+    def self.api
+      @api ||= self.OrtGetApiBase[:GetApi].call(ORT_API_VERSION)
+    end
+
     if Gem.win_platform?
       class Libc
         extend ::FFI::Library
@@ -244,5 +257,11 @@ module OnnxRuntime
         attach_function :mbstowcs, %i[pointer string size_t], :size_t
       end
     end
+
+    # https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/providers/coreml/coreml_provider_factory.h
+    begin
+      attach_function :OrtSessionOptionsAppendExecutionProvider_CoreML, %i[pointer uint32], :pointer
+    rescue ::FFI::NotFoundError
+    end
   end
 end

data/lib/onnxruntime/inference_session.rb

@@ -66,6 +66,13 @@ module OnnxRuntime
           check_status api[:CreateCUDAProviderOptions].call(cuda_options)
           check_status api[:SessionOptionsAppendExecutionProvider_CUDA_V2].call(session_options.read_pointer, cuda_options.read_pointer)
           release :CUDAProviderOptions, cuda_options
+        when "CoreMLExecutionProvider"
+          unless FFI.respond_to?(:OrtSessionOptionsAppendExecutionProvider_CoreML)
+            raise ArgumentError, "Provider not available: #{provider}"
+          end
+
+          coreml_flags = 0
+          check_status FFI.OrtSessionOptionsAppendExecutionProvider_CoreML(session_options.read_pointer, coreml_flags)
         when "CPUExecutionProvider"
           break
         else
@@ -258,77 +265,81 @@ module OnnxRuntime
       input_tensor = ::FFI::MemoryPointer.new(:pointer, input_feed.size)
 
       input_feed.each_with_index do |(input_name, input), idx|
-        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
-          end
-        end
-
         # TODO support more types
         inp = @inputs.find { |i| i[:name] == input_name.to_s }
         raise Error, "Unknown input: #{input_name}" unless inp
 
+        input = input.to_a unless input.is_a?(Array) || numo_array?(input)
+        shape = input_shape(input)
+
         input_node_dims = ::FFI::MemoryPointer.new(:int64, shape.size)
         input_node_dims.write_array_of_int64(shape)
 
         if inp[:type] == "tensor(string)"
-          str_ptrs =
-            if numo_array?(input)
-              input.size.times.map { |i| ::FFI::MemoryPointer.from_string(input[i]) }
-            else
-              input.flatten.map { |v| ::FFI::MemoryPointer.from_string(v) }
-            end
-
-          input_tensor_values = ::FFI::MemoryPointer.new(:pointer, str_ptrs.size)
-          input_tensor_values.write_array_of_pointer(str_ptrs)
-
           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, str_ptrs.size)
-
-          refs << str_ptrs
-        else
-          tensor_type = tensor_types[inp[:type]]
-
-          if tensor_type
-            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
-
-            type_enum = FFI::TensorElementDataType[tensor_type]
-          else
-            unsupported_type("input", inp[:type])
-          end
 
+          # keep reference to _str_ptrs until FillStringTensor call
+          input_tensor_values, _str_ptrs = create_input_strings(input)
+          check_status api[:FillStringTensor].call(input_tensor[idx].read_pointer, input_tensor_values, input_tensor_values.size / input_tensor_values.type_size)
+        elsif (tensor_type = tensor_types[inp[:type]])
+          input_tensor_values = create_input_data(input, tensor_type)
+          type_enum = FFI::TensorElementDataType[tensor_type]
           check_status api[:CreateTensorWithDataAsOrtValue].call(allocator_info.read_pointer, input_tensor_values, input_tensor_values.size, input_node_dims, shape.size, type_enum, input_tensor[idx])
 
-          refs << input_node_dims
           refs << input_tensor_values
+        else
+          unsupported_type("input", inp[:type])
         end
       end
 
-      refs << allocator_info
-
       input_tensor
     ensure
       release :MemoryInfo, allocator_info
     end
 
+    def input_shape(input)
+      if numo_array?(input)
+        input.shape
+      else
+        shape = []
+        s = input
+        while s.is_a?(Array)
+          shape << s.size
+          s = s.first
+        end
+        shape
+      end
+    end
+
+    def create_input_strings(input)
+      str_ptrs =
+        if numo_array?(input)
+          input.size.times.map { |i| ::FFI::MemoryPointer.from_string(input[i]) }
+        else
+          input.flatten.map { |v| ::FFI::MemoryPointer.from_string(v) }
+        end
+
+      input_tensor_values = ::FFI::MemoryPointer.new(:pointer, str_ptrs.size)
+      input_tensor_values.write_array_of_pointer(str_ptrs)
+      [input_tensor_values, str_ptrs]
+    end
+
+    def create_input_data(input, tensor_type)
+      if numo_array?(input)
+        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
+        input_tensor_values
+      end
+    end
+
     def create_node_names(names, refs)
       str_ptrs = names.map { |v| ::FFI::MemoryPointer.from_string(v) }
       refs << str_ptrs
@@ -575,7 +586,7 @@ module OnnxRuntime
     end
 
     def self.api
-      @api ||= FFI.OrtGetApiBase[:GetApi].call(FFI::ORT_API_VERSION)
+      FFI.api
     end
 
     def self.release(type, pointer)

data/lib/onnxruntime/version.rb

@@ -1,3 +1,3 @@
 module OnnxRuntime
-  VERSION = "0.9.0"
+  VERSION = "0.9.2"
 end

data/vendor/ThirdPartyNotices.txt

@@ -1829,7 +1829,7 @@ Zbigniew Skowron <zbychs@gmail.com>
 
 _____
 
-HalidelR
+HalideIR
 
 Copyright (c) 2016 HalideIR contributors
 Copyright (c) 2012-2014 MIT CSAIL, Google Inc., and other contributors
@@ -4820,7 +4820,7 @@ SOFTWARE.
 
 ----------------------------------------------------------------------------
 
-This is the MIT/Expat Licence. For more information see:
+This is the MIT/Expat License. For more information see:
 
 1. http://www.opensource.org/licenses/mit-license.php
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: onnxruntime
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.2
 platform: x86_64-linux
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-27 00:00:00.000000000 Z
+date: 2024-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -62,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: High performance scoring engine for ML models