onnxruntime 0.2.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2405ad6cda55897be52cbb6afd3854d2cf2ed5ed01abc09bf78568557af446ff
-  data.tar.gz: 1e04e516b4726f510bf489108c1f684e398f8d63718c9717106ac9659773d3f0
+  metadata.gz: 0b017fa8896c64bbeeda0ba6582ca9bfa626de3f13023ec9f3f91000031e88b8
+  data.tar.gz: 16344db9151ca3f388539e05772a7172129613f949dbff77d89bfb9c307d0de2
 SHA512:
-  metadata.gz: a2a38af03a82eecc60e28b6fb7b012c28188af69af9a7521cb4b1e4c2519c99c6d328045f0f20fe509787942d304a15e92e43ad94483c55f895cf4bbaf21b53e
-  data.tar.gz: c782475317186f24c7e34285584ee7761522cc1f792e092c896abe32a041cf593ef4e7f0736a12688ad3e7539101234123d8948ab8ebe0c7986bfb40f33ff236
+  metadata.gz: 21011ae8d875230858ff148a27ff29caf005210aae6f6e6a347ed9a02dfb85bceac6714957718d3f17872f07f0ace21c3ba7d7ba8884c1dff4b79fd08b43e40b
+  data.tar.gz: 000f4575890f92c2b1de308e052977f159ead243aef3984cd4190a5a873ecbe2868fe586fdbe14f2963f0518a75d8c4600d47ba2fbdd6a77c84cf3da1fc84292

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+## 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
+- Added support for run options
+- Added `Datasets` module
+
 ## 0.2.1 (2019-12-19)
 
 - Updated ONNX Runtime to 1.1.0

data/LICENSE.txt

@@ -1,4 +1,5 @@
-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)
 ```
 
@@ -50,6 +56,35 @@ Get specific outputs
 model.predict({x: [1, 2, 3]}, output_names: ["label"])
 ```
 
+## Session Options
+
+```ruby
+OnnxRuntime::Model.new(path_or_bytes, {
+  enable_cpu_mem_arena: true,
+  enable_mem_pattern: true,
+  enable_profiling: false,
+  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,
+  log_verbosity_level: 0,
+  logid: nil,
+  optimized_model_filepath: nil
+})
+```
+
+## Run Options
+
+```ruby
+model.predict(input_feed, {
+  log_severity_level: 2,
+  log_verbosity_level: 0,
+  logid: nil,
+  terminate: false
+})
+```
+
 ## Inference Session API
 
 You can also use the Inference Session API, which follows the [Python API](https://microsoft.github.io/onnxruntime/python/api_summary.html).
@@ -59,6 +94,20 @@ session = OnnxRuntime::InferenceSession.new("model.onnx")
 session.run(nil, {x: [1, 2, 3]})
 ```
 
+The Python example models are included as well.
+
+```ruby
+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:
+
+```ruby
+OnnxRuntime.ffi_lib = "path/to/lib/libonnxruntime.so" # onnxruntime.dll for Windows
+```
+
 ## History
 
 View the [changelog](https://github.com/ankane/onnxruntime/blob/master/CHANGELOG.md)

data/lib/onnxruntime.rb

@@ -2,6 +2,7 @@
 require "ffi"
 
 # modules
+require "onnxruntime/datasets"
 require "onnxruntime/inference_session"
 require "onnxruntime/model"
 require "onnxruntime/utils"
@@ -18,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/datasets.rb

@@ -0,0 +1,10 @@
+module OnnxRuntime
+  module Datasets
+    def self.example(name)
+      unless %w(logreg_iris.onnx mul_1.onnx sigmoid.onnx).include?(name)
+        raise ArgumentError, "Unable to find example '#{name}'"
+      end
+      File.expand_path("../../datasets/#{name}", __dir__)
+    end
+  end
+end

data/lib/onnxruntime/ffi.rb

@@ -3,7 +3,7 @@ module OnnxRuntime
     extend ::FFI::Library
 
     begin
-      ffi_lib OnnxRuntime.ffi_lib
+      ffi_lib Array(OnnxRuntime.ffi_lib)
     rescue LoadError => e
       raise e if ENV["ONNXRUNTIME_DEBUG"]
       raise LoadError, "Could not find ONNX Runtime"
@@ -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),
@@ -29,21 +29,21 @@ module OnnxRuntime
         :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),
+        :SetOptimizedModelFilePath, callback(%i[pointer string], :pointer),
         :CloneSessionOptions, callback(%i[], :pointer),
         :SetSessionExecutionMode, callback(%i[], :pointer),
-        :EnableProfiling, callback(%i[], :pointer),
-        :DisableProfiling, callback(%i[], :pointer),
-        :EnableMemPattern, callback(%i[], :pointer),
-        :DisableMemPattern, callback(%i[], :pointer),
-        :EnableCpuMemArena, callback(%i[], :pointer),
-        :DisableCpuMemArena, callback(%i[], :pointer),
-        :SetSessionLogId, callback(%i[], :pointer),
-        :SetSessionLogVerbosityLevel, callback(%i[], :pointer),
-        :SetSessionLogSeverityLevel, callback(%i[], :pointer),
-        :SetSessionGraphOptimizationLevel, callback(%i[], :pointer),
-        :SetIntraOpNumThreads, callback(%i[], :pointer),
-        :SetInterOpNumThreads, callback(%i[], :pointer),
+        :EnableProfiling, callback(%i[pointer string], :pointer),
+        :DisableProfiling, callback(%i[pointer], :pointer),
+        :EnableMemPattern, callback(%i[pointer], :pointer),
+        :DisableMemPattern, callback(%i[pointer], :pointer),
+        :EnableCpuMemArena, callback(%i[pointer], :pointer),
+        :DisableCpuMemArena, callback(%i[pointer], :pointer),
+        :SetSessionLogId, callback(%i[pointer string], :pointer),
+        :SetSessionLogVerbosityLevel, callback(%i[pointer int], :pointer),
+        :SetSessionLogSeverityLevel, callback(%i[pointer int], :pointer),
+        :SetSessionGraphOptimizationLevel, callback(%i[pointer int], :pointer),
+        :SetIntraOpNumThreads, callback(%i[pointer int], :pointer),
+        :SetInterOpNumThreads, callback(%i[pointer int], :pointer),
         :CreateCustomOpDomain, callback(%i[], :pointer),
         :CustomOpDomain_Add, callback(%i[], :pointer),
         :AddCustomOpDomain, callback(%i[], :pointer),
@@ -57,15 +57,15 @@ module OnnxRuntime
         :SessionGetInputName, callback(%i[pointer size_t pointer pointer], :pointer),
         :SessionGetOutputName, callback(%i[pointer size_t pointer pointer], :pointer),
         :SessionGetOverridableInitializerName, callback(%i[], :pointer),
-        :CreateRunOptions, callback(%i[], :pointer),
-        :RunOptionsSetRunLogVerbosityLevel, callback(%i[], :pointer),
-        :RunOptionsSetRunLogSeverityLevel, callback(%i[], :pointer),
-        :RunOptionsSetRunTag, callback(%i[], :pointer),
+        :CreateRunOptions, callback(%i[pointer], :pointer),
+        :RunOptionsSetRunLogVerbosityLevel, callback(%i[pointer int], :pointer),
+        :RunOptionsSetRunLogSeverityLevel, callback(%i[pointer int], :pointer),
+        :RunOptionsSetRunTag, callback(%i[pointer string], :pointer),
         :RunOptionsGetRunLogVerbosityLevel, callback(%i[], :pointer),
         :RunOptionsGetRunLogSeverityLevel, callback(%i[], :pointer),
         :RunOptionsGetRunTag, callback(%i[], :pointer),
-        :RunOptionsSetTerminate, callback(%i[], :pointer),
-        :RunOptionsUnsetTerminate, callback(%i[], :pointer),
+        :RunOptionsSetTerminate, callback(%i[pointer], :pointer),
+        :RunOptionsUnsetTerminate, callback(%i[pointer], :pointer),
         :CreateTensorAsOrtValue, callback(%i[pointer pointer size_t int pointer], :pointer),
         :CreateTensorWithDataAsOrtValue, callback(%i[pointer pointer size_t pointer size_t int pointer], :pointer),
         :IsTensor, callback(%i[], :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

@@ -2,21 +2,50 @@ module OnnxRuntime
   class InferenceSession
     attr_reader :inputs, :outputs
 
-    def initialize(path_or_bytes)
+    def initialize(path_or_bytes, enable_cpu_mem_arena: true, enable_mem_pattern: true, enable_profiling: false, execution_mode: nil, graph_optimization_level: nil, inter_op_num_threads: nil, intra_op_num_threads: nil, log_severity_level: nil, log_verbosity_level: nil, logid: nil, optimized_model_filepath: nil)
       # session options
       session_options = ::FFI::MemoryPointer.new(:pointer)
       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
+      if execution_mode
+        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
+      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
+      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
 
       # 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)
@@ -53,7 +82,8 @@ module OnnxRuntime
       end
     end
 
-    def run(output_names, input_feed)
+    # TODO support logid
+    def run(output_names, input_feed, log_severity_level: nil, log_verbosity_level: nil, logid: nil, terminate: nil)
       input_tensor = create_input_tensor(input_feed)
 
       output_names ||= @outputs.map { |v| v[:name] }
@@ -61,14 +91,66 @@ module OnnxRuntime
       output_tensor = ::FFI::MemoryPointer.new(:pointer, outputs.size)
       input_node_names = create_node_names(input_feed.keys.map(&:to_s))
       output_node_names = create_node_names(output_names.map(&:to_s))
-      # TODO support run options
-      check_status api[:Run].call(read_pointer, nil, input_node_names, input_tensor, input_feed.size, output_node_names, output_names.size, output_tensor)
+
+      # run options
+      run_options = ::FFI::MemoryPointer.new(:pointer)
+      check_status api[:CreateRunOptions].call(run_options)
+      check_status api[:RunOptionsSetRunLogSeverityLevel].call(run_options.read_pointer, log_severity_level) if log_severity_level
+      check_status api[:RunOptionsSetRunLogVerbosityLevel].call(run_options.read_pointer, log_verbosity_level) if log_verbosity_level
+      check_status api[:RunOptionsSetRunTag].call(run_options.read_pointer, logid) if logid
+      check_status api[:RunOptionsSetTerminate].call(run_options.read_pointer) if terminate
+
+      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)
       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)
+      api[:ReleaseModelMetadata].call(metadata.read_pointer)
+
+      {
+        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)
+      }
+    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
 
     def create_input_tensor(input_feed)
@@ -208,7 +290,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
@@ -230,15 +312,32 @@ 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

data/lib/onnxruntime/model.rb

@@ -1,11 +1,11 @@
 module OnnxRuntime
   class Model
-    def initialize(path_or_bytes)
-      @session = InferenceSession.new(path_or_bytes)
+    def initialize(path_or_bytes, **session_options)
+      @session = InferenceSession.new(path_or_bytes, **session_options)
     end
 
-    def predict(input_feed, output_names: nil)
-      predictions = @session.run(output_names, input_feed)
+    def predict(input_feed, output_names: nil, **run_options)
+      predictions = @session.run(output_names, input_feed, **run_options)
       output_names ||= outputs.map { |o| o[:name] }
 
       result = {}
@@ -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.1"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: onnxruntime
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-20 00:00:00.000000000 Z
+date: 2020-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -76,6 +76,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/onnxruntime.rb
+- lib/onnxruntime/datasets.rb
 - lib/onnxruntime/ffi.rb
 - lib/onnxruntime/inference_session.rb
 - lib/onnxruntime/model.rb
@@ -105,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