onnxruntime 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c7a7fd8412c39749689e27196bbb472e006a7686225dacf5f6946dbaa9af0496
+  data.tar.gz: '019cec927488c9ab07a76d19913c99f70cab1df81a0bd62bbb3233d383b1c427'
+SHA512:
+  metadata.gz: 730bf9550ddbd2e8a6cc1d0b58d02464ae59f18c5f2eaf2709f34d701838ff44ab42b478c3c014e97fc2f578a0ec937d204b91ab6ec596f0a1324c119d64863e
+  data.tar.gz: 16972280e527e11588f478be8e2ddb850b3a090432c39868f969d9cd9627890b4de721fa66a58a9b226430708aa20316da62456176bb24b1e4fe984b245658d3

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2019 Andrew Kane
+
+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:
+
+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.

data/README.md

@@ -0,0 +1,95 @@
+# ONNX Runtime
+
+:fire: [ONNX Runtime](https://github.com/Microsoft/onnxruntime) - the high performance scoring engine for ML models - for Ruby
+
+## Installation
+
+First, [install ONNX Runtime](#onnx-runtime-installation).
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'onnxruntime'
+```
+
+## Getting Started
+
+Load a model and make predictions
+
+```ruby
+model = OnnxRuntime::Model.new("model.onnx")
+model.predict(x: [1, 2, 3])
+```
+
+Get inputs
+
+```ruby
+model.inputs
+```
+
+Get outputs
+
+```ruby
+model.outputs
+```
+
+Load a model from a string
+
+```ruby
+byte_str = File.binread("model.onnx")
+model = OnnxRuntime::Model.new(byte_str)
+```
+
+Get specific outputs
+
+```ruby
+model.predict({x: [1, 2, 3]}, output_names: ["label"])
+```
+
+## Inference Session API
+
+You can also use the Inference Session API, which follows the [Python API](https://microsoft.github.io/onnxruntime/api_summary.html).
+
+```ruby
+session = OnnxRuntime::InferenceSession.new("model.onnx")
+session.run(nil, {x: [1, 2, 3]})
+```
+
+## ONNX Runtime Installation
+
+ONNX Runtime provides [prebuilt libraries](https://github.com/microsoft/onnxruntime/releases).
+
+### Mac
+
+```sh
+wget https://github.com/microsoft/onnxruntime/releases/download/v0.5.0/onnxruntime-osx-x64-0.5.0.tgz
+tar xf onnxruntime-osx-x64-0.5.0.tgz
+cd onnxruntime-osx-x64-0.5.0
+cp lib/libonnxruntime.0.5.0.dylib /usr/local/lib/libonnxruntime.dylib
+```
+
+### Linux
+
+```sh
+wget https://github.com/microsoft/onnxruntime/releases/download/v0.5.0/onnxruntime-linux-x64-0.5.0.tgz
+tar xf onnxruntime-linux-x64-0.5.0.tgz
+cd onnxruntime-linux-x64-0.5.0.tgz
+cp lib/libonnxruntime.0.5.0.so /usr/local/lib/libonnxruntime.so
+```
+
+### Windows
+
+Download [ONNX Runtime](https://github.com/microsoft/onnxruntime/releases/download/v0.5.0/onnxruntime-win-x64-0.5.0.zip). Unzip and move `lib/onnxruntime.dll` to `C:\Windows\System32\onnxruntime.dll`.
+
+## History
+
+View the [changelog](https://github.com/ankane/onnxruntime/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/onnxruntime/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/onnxruntime/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features

data/lib/onnxruntime/ffi.rb

@@ -0,0 +1,71 @@
+module OnnxRuntime
+  module FFI
+    extend ::FFI::Library
+
+    begin
+      ffi_lib OnnxRuntime.ffi_lib
+    rescue LoadError => e
+      raise e if ENV["ONNXRUNTIME_DEBUG"]
+      raise LoadError, "Could not find ONNX Runtime"
+    end
+
+    # https://github.com/microsoft/onnxruntime/blob/master/include/onnxruntime/core/session/onnxruntime_c_api.h
+    # keep same order
+
+    # enums
+    TensorElementDataType = enum(:undefined, :float, :uint8, :int8, :uint16, :int16, :int32, :int64, :string, :bool, :float16, :double, :uint32, :uint64, :complex64, :complex128, :bfloat16)
+    OnnxType = enum(:unknown, :tensor, :sequence, :map, :opaque, :sparsetensor)
+
+    # session
+    attach_function :OrtCreateEnv, %i[int string pointer], :pointer
+    attach_function :OrtCreateSession, %i[pointer string pointer pointer], :pointer
+    attach_function :OrtCreateSessionFromArray, %i[pointer pointer size_t pointer pointer], :pointer
+    attach_function :OrtRun, %i[pointer pointer pointer pointer size_t pointer size_t pointer], :pointer
+    attach_function :OrtCreateSessionOptions, %i[pointer], :pointer
+    attach_function :OrtSetSessionGraphOptimizationLevel, %i[pointer int], :pointer
+    attach_function :OrtSetSessionThreadPoolSize, %i[pointer int], :pointer
+
+    # input and output
+    attach_function :OrtSessionGetInputCount, %i[pointer pointer], :pointer
+    attach_function :OrtSessionGetOutputCount, %i[pointer pointer], :pointer
+    attach_function :OrtSessionGetInputTypeInfo, %i[pointer size_t pointer], :pointer
+    attach_function :OrtSessionGetOutputTypeInfo, %i[pointer size_t pointer], :pointer
+    attach_function :OrtSessionGetInputName, %i[pointer size_t pointer pointer], :pointer
+    attach_function :OrtSessionGetOutputName, %i[pointer size_t pointer pointer], :pointer
+
+    # tensor
+    attach_function :OrtCreateTensorWithDataAsOrtValue, %i[pointer pointer size_t pointer size_t int pointer], :pointer
+    attach_function :OrtGetTensorMutableData, %i[pointer pointer], :pointer
+    attach_function :OrtIsTensor, %i[pointer pointer], :pointer
+    attach_function :OrtCastTypeInfoToTensorInfo, %i[pointer pointer], :pointer
+    attach_function :OrtOnnxTypeFromTypeInfo, %i[pointer pointer], :pointer
+    attach_function :OrtGetTensorElementType, %i[pointer pointer], :pointer
+    attach_function :OrtGetDimensionsCount, %i[pointer pointer], :pointer
+    attach_function :OrtGetDimensions, %i[pointer pointer size_t], :pointer
+    attach_function :OrtGetTensorShapeElementCount, %i[pointer pointer], :pointer
+    attach_function :OrtGetTensorTypeAndShape, %i[pointer pointer], :pointer
+
+    # value
+    attach_function :OrtGetTypeInfo, %i[pointer pointer], :pointer
+    attach_function :OrtGetValueType, %i[pointer pointer], :pointer
+
+    # maps and sequences
+    attach_function :OrtGetValue, %i[pointer int pointer pointer], :pointer
+    attach_function :OrtGetValueCount, %i[pointer pointer], :pointer
+
+    # version
+    attach_function :OrtGetVersionString, %i[], :string
+
+    # error
+    attach_function :OrtGetErrorMessage, %i[pointer], :string
+
+    # allocator
+    attach_function :OrtCreateCpuAllocatorInfo, %i[int int pointer], :pointer
+    attach_function :OrtCreateDefaultAllocator, %i[pointer], :pointer
+
+    # release
+    attach_function :OrtReleaseEnv, %i[pointer], :pointer
+    attach_function :OrtReleaseTypeInfo, %i[pointer], :pointer
+    attach_function :OrtReleaseStatus, %i[pointer], :pointer
+  end
+end

data/lib/onnxruntime/inference_session.rb

@@ -0,0 +1,259 @@
+module OnnxRuntime
+  class InferenceSession
+    attr_reader :inputs, :outputs
+
+    def initialize(path_or_bytes)
+      # session options
+      session_options = ::FFI::MemoryPointer.new(:pointer)
+      check_status FFI.OrtCreateSessionOptions(session_options)
+
+      # session
+      @session = ::FFI::MemoryPointer.new(:pointer)
+      path_or_bytes = path_or_bytes.to_str
+      if path_or_bytes.encoding == Encoding::BINARY
+        check_status FFI.OrtCreateSessionFromArray(env.read_pointer, path_or_bytes, path_or_bytes.bytesize, session_options.read_pointer, @session)
+      else
+        check_status FFI.OrtCreateSession(env.read_pointer, path_or_bytes, session_options.read_pointer, @session)
+      end
+
+      # input info
+      allocator = ::FFI::MemoryPointer.new(:pointer)
+      check_status FFI.OrtCreateDefaultAllocator(allocator)
+      @allocator = allocator
+
+      @inputs = []
+      @outputs = []
+
+      # input
+      num_input_nodes = ::FFI::MemoryPointer.new(:size_t)
+      check_status FFI.OrtSessionGetInputCount(read_pointer, num_input_nodes)
+      num_input_nodes.read(:size_t).times do |i|
+        name_ptr = ::FFI::MemoryPointer.new(:string)
+        check_status FFI.OrtSessionGetInputName(read_pointer, i, @allocator.read_pointer, name_ptr)
+        typeinfo = ::FFI::MemoryPointer.new(:pointer)
+        check_status FFI.OrtSessionGetInputTypeInfo(read_pointer, i, typeinfo)
+        @inputs << {name: name_ptr.read_pointer.read_string}.merge(node_info(typeinfo))
+      end
+
+      # output
+      num_output_nodes = ::FFI::MemoryPointer.new(:size_t)
+      check_status FFI.OrtSessionGetOutputCount(read_pointer, num_output_nodes)
+      num_output_nodes.read(:size_t).times do |i|
+        name_ptr = ::FFI::MemoryPointer.new(:string)
+        check_status FFI.OrtSessionGetOutputName(read_pointer, i, allocator.read_pointer, name_ptr)
+        typeinfo = ::FFI::MemoryPointer.new(:pointer)
+        check_status FFI.OrtSessionGetOutputTypeInfo(read_pointer, i, typeinfo)
+        @outputs << {name: name_ptr.read_pointer.read_string}.merge(node_info(typeinfo))
+      end
+    end
+
+    def run(output_names, input_feed)
+      input_tensor = create_input_tensor(input_feed)
+
+      outputs = @outputs
+      if output_names
+        output_names = output_names.map(&:to_s)
+        outputs = outputs.select { |o| output_names.include?(o[:name]) }
+      end
+
+      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(outputs.map { |v| v[:name] })
+      # TODO support run options
+      check_status FFI.OrtRun(read_pointer, nil, input_node_names, input_tensor, input_feed.size, output_node_names, outputs.size, output_tensor)
+
+      outputs.size.times.map do |i|
+        create_from_onnx_value(output_tensor[i].read_pointer)
+      end
+    end
+
+    private
+
+    def create_input_tensor(input_feed)
+      allocator_info = ::FFI::MemoryPointer.new(:pointer)
+      check_status = FFI.OrtCreateCpuAllocatorInfo(1, 0, allocator_info)
+      input_tensor = ::FFI::MemoryPointer.new(:pointer, input_feed.size)
+
+      input_feed.each_with_index do |(input_name, input), idx|
+        shape = []
+        s = input
+        while s.is_a?(Array)
+          shape << s.size
+          s = s.first
+        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 } || {}
+        case inp[:type]
+        when "tensor(bool)"
+          input_tensor_values = ::FFI::MemoryPointer.new(:uchar, input_tensor_size)
+          input_tensor_values.write_array_of_uchar(flat_input.map { |v| v ? 1 : 0 })
+          type_enum = FFI::TensorElementDataType[:bool]
+        else
+          input_tensor_values = ::FFI::MemoryPointer.new(:float, input_tensor_size)
+          input_tensor_values.write_array_of_float(flat_input)
+          type_enum = FFI::TensorElementDataType[:float]
+        end
+
+        input_node_dims = ::FFI::MemoryPointer.new(:int64, shape.size)
+        input_node_dims.write_array_of_int64(shape)
+        check_status FFI.OrtCreateTensorWithDataAsOrtValue(allocator_info.read_pointer, input_tensor_values, input_tensor_values.size, input_node_dims, shape.size, type_enum, input_tensor[idx])
+      end
+
+      input_tensor
+    end
+
+    def create_node_names(names)
+      ptr = ::FFI::MemoryPointer.new(:pointer, names.size)
+      ptr.write_array_of_pointer(names.map { |v| ::FFI::MemoryPointer.from_string(v) })
+      ptr
+    end
+
+    def create_from_onnx_value(out_ptr)
+      out_type = ::FFI::MemoryPointer.new(:int)
+      check_status = FFI.OrtGetValueType(out_ptr, out_type)
+      type = FFI::OnnxType[out_type.read_int]
+
+      case type
+      when :tensor
+        typeinfo = ::FFI::MemoryPointer.new(:pointer)
+        check_status FFI.OrtGetTensorTypeAndShape(out_ptr, typeinfo)
+
+        type, shape = tensor_type_and_shape(typeinfo)
+
+        tensor_data = ::FFI::MemoryPointer.new(:pointer)
+        check_status FFI.OrtGetTensorMutableData(out_ptr, tensor_data)
+
+        out_size = ::FFI::MemoryPointer.new(:size_t)
+        output_tensor_size = FFI.OrtGetTensorShapeElementCount(typeinfo.read_pointer, out_size)
+        output_tensor_size = out_size.read(:size_t)
+
+        # TODO support more types
+        type = FFI::TensorElementDataType[type]
+        arr =
+          case type
+          when :float
+            tensor_data.read_pointer.read_array_of_float(output_tensor_size)
+          when :int64
+            tensor_data.read_pointer.read_array_of_int64(output_tensor_size)
+          when :bool
+            tensor_data.read_pointer.read_array_of_uchar(output_tensor_size).map { |v| v == 1 }
+          else
+            raise "Unsupported element type: #{type}"
+          end
+
+        Utils.reshape(arr, shape)
+      when :sequence
+        out = ::FFI::MemoryPointer.new(:size_t)
+        check_status FFI.OrtGetValueCount(out_ptr, out)
+
+        out.read(:size_t).times.map do |i|
+          seq = ::FFI::MemoryPointer.new(:pointer)
+          check_status FFI.OrtGetValue(out_ptr, i, @allocator.read_pointer, seq)
+          create_from_onnx_value(seq.read_pointer)
+        end
+      when :map
+        type_shape = ::FFI::MemoryPointer.new(:pointer)
+        map_keys = ::FFI::MemoryPointer.new(:pointer)
+        map_values = ::FFI::MemoryPointer.new(:pointer)
+        elem_type = ::FFI::MemoryPointer.new(:int)
+
+        check_status FFI.OrtGetValue(out_ptr, 0, @allocator.read_pointer, map_keys)
+        check_status FFI.OrtGetValue(out_ptr, 1, @allocator.read_pointer, map_values)
+        check_status FFI.OrtGetTensorTypeAndShape(map_keys.read_pointer, type_shape)
+        check_status FFI.OrtGetTensorElementType(type_shape.read_pointer, elem_type)
+
+        # 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.zip(values).each do |k, v|
+            ret[k] = v
+          end
+          ret
+        else
+          raise "Unsupported element type: #{elem_type}"
+        end
+      else
+        raise "Unsupported ONNX type: #{type}"
+      end
+    end
+
+    def read_pointer
+      @session.read_pointer
+    end
+
+    def check_status(status)
+      unless status.null?
+        message = FFI.OrtGetErrorMessage(status)
+        FFI.OrtReleaseStatus(status)
+        raise OnnxRuntime::Error, message
+      end
+    end
+
+    def node_info(typeinfo)
+      onnx_type = ::FFI::MemoryPointer.new(:int)
+      check_status FFI.OrtOnnxTypeFromTypeInfo(typeinfo.read_pointer, onnx_type)
+
+      type = FFI::OnnxType[onnx_type.read_int]
+      case type
+      when :tensor
+        tensor_info = ::FFI::MemoryPointer.new(:pointer)
+        check_status FFI.OrtCastTypeInfoToTensorInfo(typeinfo.read_pointer, tensor_info)
+
+        type, shape = tensor_type_and_shape(tensor_info)
+        {
+          type: "tensor(#{FFI::TensorElementDataType[type]})",
+          shape: shape
+        }
+      when :sequence
+        # TODO show nested
+        {
+          type: "seq",
+          shape: []
+        }
+      when :map
+        # TODO show nested
+        {
+          type: "map",
+          shape: []
+        }
+      else
+        raise "Unsupported ONNX type: #{type}"
+      end
+    ensure
+      FFI.OrtReleaseTypeInfo(typeinfo.read_pointer)
+    end
+
+    def tensor_type_and_shape(tensor_info)
+      type = ::FFI::MemoryPointer.new(:int)
+      check_status FFI.OrtGetTensorElementType(tensor_info.read_pointer, type)
+
+      num_dims_ptr = ::FFI::MemoryPointer.new(:size_t)
+      check_status FFI.OrtGetDimensionsCount(tensor_info.read_pointer, num_dims_ptr)
+      num_dims = num_dims_ptr.read(:size_t)
+
+      node_dims = ::FFI::MemoryPointer.new(:int64, num_dims)
+      check_status FFI.OrtGetDimensions(tensor_info.read_pointer, node_dims, num_dims)
+
+      [type.read_int, node_dims.read_array_of_int64(num_dims)]
+    end
+
+    # share env
+    # TODO mutex around creation?
+    def env
+      @@env ||= begin
+        env = ::FFI::MemoryPointer.new(:pointer)
+        check_status FFI.OrtCreateEnv(3, "Default", env)
+        at_exit { FFI.OrtReleaseEnv(env.read_pointer) }
+        env
+      end
+    end
+  end
+end

data/lib/onnxruntime/model.rb

@@ -0,0 +1,26 @@
+module OnnxRuntime
+  class Model
+    def initialize(path_or_bytes)
+      @session = InferenceSession.new(path_or_bytes)
+    end
+
+    def predict(input_feed, output_names: nil)
+      predictions = @session.run(output_names, input_feed)
+      output_names ||= outputs.map { |o| o[:name] }
+
+      result = {}
+      output_names.zip(predictions).each do |k, v|
+        result[k.to_s] = v
+      end
+      result
+    end
+
+    def inputs
+      @session.inputs
+    end
+
+    def outputs
+      @session.outputs
+    end
+  end
+end

data/lib/onnxruntime/utils.rb

@@ -0,0 +1,10 @@
+module OnnxRuntime
+  module Utils
+    def self.reshape(arr, dims)
+      dims[1..-1].reverse.each do |dim|
+        arr = arr.each_slice(dim)
+      end
+      arr.to_a
+    end
+  end
+end

data/lib/onnxruntime/version.rb

@@ -0,0 +1,3 @@
+module OnnxRuntime
+  VERSION = "0.1.0"
+end

data/lib/onnxruntime.rb

@@ -0,0 +1,24 @@
+# dependencies
+require "ffi"
+
+# modules
+require "onnxruntime/inference_session"
+require "onnxruntime/model"
+require "onnxruntime/utils"
+require "onnxruntime/version"
+
+module OnnxRuntime
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :ffi_lib
+  end
+  self.ffi_lib = ["onnxruntime"]
+
+  def self.lib_version
+    FFI.OrtGetVersionString
+  end
+
+  # friendlier error message
+  autoload :FFI, "onnxruntime/ffi"
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: onnxruntime
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+description: 
+email: andrew@chartkick.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/onnxruntime.rb
+- lib/onnxruntime/ffi.rb
+- lib/onnxruntime/inference_session.rb
+- lib/onnxruntime/model.rb
+- lib/onnxruntime/utils.rb
+- lib/onnxruntime/version.rb
+homepage: https://github.com/ankane/onnxruntime
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: High performance scoring engine for ML models
+test_files: []