com.github.asus4.onnxruntime 0.2.0 → 0.2.2

package/Runtime/OrtFloat16.shared.cs

@@ -60,9 +60,9 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Extracts single precision number bit representation as uint
         /// so its bits can be manipulated.
-        /// 
+        ///
         /// This API is the reverse of UInt32BitsToSingle().
-        /// 
+        ///
         /// </summary>
         /// <param name="single">float value</param>
         /// <returns></returns>
@@ -79,11 +79,11 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Needed because BitConverter impl is not available until
         /// later versions. This API is the reverse of SingleToUInt32Bits().
-        /// 
+        ///
         /// For the exact bit representation of float see IEEE 754 standard for single precision.
-        /// 
+        ///
         /// </summary>
-        /// <param name="singleBits">bit representation of float either obtained from 
+        /// <param name="singleBits">bit representation of float either obtained from
         /// SingleToUInt32Bits or assembled using bitwise operators</param>
         /// <returns></returns>
         internal static float UInt32BitsToSingle(uint singleBits)
@@ -99,7 +99,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Converts single precision bits representation which can be obtained using
         /// SingleToUInt32Bits() or manually constructed according to IEEE 754 standard.
-        /// 
+        ///
         /// </summary>
         /// <param name="singleBits">bits representation of a single precision number (float)</param>
         /// <returns></returns>
@@ -134,11 +134,11 @@ namespace Microsoft.ML.OnnxRuntime
         }
 
         /// <summary>
-        /// Creates float NaN with the given sign and fp16 significand shifted << 54
+        /// Creates float NaN with the given sign and fp16 significand shifted &lt;&lt; 54
         /// </summary>
         /// <param name="sign">true for negative</param>
         /// <param name="significand">should be shifted 54 bits left before calling the function
-        /// so only 8 bits of signidicand remains</param>
+        /// so only 8 bits of significand remains</param>
         /// <returns></returns>
         internal static float CreateSingleNaN(bool sign, ulong significand)
         {
@@ -177,8 +177,8 @@ namespace Microsoft.ML.OnnxRuntime
     /// do not have to be copied to be passed to native memory but simply pinned and read by native code. Thus,
     /// one can create a Tensor on top of an array of these structures and feed it directly to Onnxruntime library.
     /// Binary wise, it is the same as ushort[] (uint16_t in C++). However, we would like a separate type for type dispatching.
-    /// 
-    /// The implementation is derived from 
+    ///
+    /// The implementation is derived from
     /// https://source.dot.net/#System.Private.CoreLib/src/libraries/System.Private.CoreLib/src/System/Half.cs,7895d5942d33f974
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
@@ -215,6 +215,7 @@ namespace Microsoft.ML.OnnxRuntime
 
         private const ushort OneBits = 0x3C00;
 
+        // Minimum positive normalized value. It is corresponding to numeric_limits<float16>::min() in C++.
         private const ushort EpsilonBits = 0x0400;
 
         private const ushort PositiveInfinityBits = 0x7C00;
@@ -238,7 +239,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Float16 Epsilon value
         /// </summary>
-        public static Float16 Epsilon => new Float16(EpsilonBits);                        //  5.9604645E-08
+        public static Float16 Epsilon => new Float16(EpsilonBits);                        //  0.00006103515625
 
         /// <summary>
         /// Float16 Pi value
@@ -248,17 +249,17 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Float16 Positive Infinity value
         /// </summary>
-        public static Float16 PositiveInfinity => new Float16(PositiveInfinityBits);      //  1.0 / 0.0;
+        public static Float16 PositiveInfinity => new Float16(PositiveInfinityBits);
 
         /// <summary>
         /// Float16 Negative Infinity value
         /// </summary>
-        public static Float16 NegativeInfinity => new Float16(NegativeInfinityBits);      // -1.0 / 0.0
+        public static Float16 NegativeInfinity => new Float16(NegativeInfinityBits);
 
         /// <summary>
         /// Float16 NaN
         /// </summary>
-        public static Float16 NaN => new Float16(NegativeQNaNBits);                       //  0.0 / 0.0
+        public static Float16 NaN => new Float16(NegativeQNaNBits);                       // Same as System.Half.NaN
 
         /// <summary>
         /// Float16 Zero value
@@ -276,14 +277,14 @@ namespace Microsoft.ML.OnnxRuntime
         public static Float16 NegativeZero => new Float16(NegativeZeroBits);              // -0.0
 
         /// <summary>
-        /// Float16 Min value
+        /// Float16 Lowest value
         /// </summary>
-        public static Float16 MinValue => new Float16(MinValueBits);                      // 64,511
+        public static Float16 MinValue => new Float16(MinValueBits);                      // -65504.0
 
         /// <summary>
         /// Float16 Max value
         /// </summary>
-        public static Float16 MaxValue => new Float16(MaxValueBits);                      //  31,743
+        public static Float16 MaxValue => new Float16(MaxValueBits);                      // 65504.0
 
         /// <summary>
         /// float16 representation bits
@@ -348,7 +349,7 @@ namespace Microsoft.ML.OnnxRuntime
 
         /// <summary>
         /// Compares values of two Float16
-        /// 
+        ///
         /// </summary>
         /// <param name="left">left hand side</param>
         /// <param name="right">right hand side</param>
@@ -376,7 +377,7 @@ namespace Microsoft.ML.OnnxRuntime
 
         /// <summary>
         /// Compares values of two Float16
-        /// 
+        ///
         /// </summary>
         /// <param name="left">left hand side</param>
         /// <param name="right">right hand side</param>
@@ -388,7 +389,7 @@ namespace Microsoft.ML.OnnxRuntime
 
         /// <summary>
         /// Compares values of two Float16
-        /// 
+        ///
         /// </summary>
         /// <param name="left">left hand side</param>
         /// <param name="right">right hand side</param>
@@ -416,12 +417,11 @@ namespace Microsoft.ML.OnnxRuntime
 
         /// <summary>
         /// Compares values of two Float16
-        /// 
         /// </summary>
         /// <param name="left">left hand side</param>
         /// <param name="right">right hand side</param>
         /// <returns>returns true if left is greater or equal than right according to IEEE</returns>
-        /// <inheritdoc cref="IComparisonOperators{TSelf, TOther, TResult}.op_GreaterThanOrEqual(TSelf, TOther)" />
+        /// <inheritdoc />
         public static bool operator >=(Float16 left, Float16 right)
         {
             return right <= left;
@@ -430,7 +430,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Compares values of two Float16 for binary equality.
         /// If either of the values is NaN, this will return false.
-        /// 
+        ///
         /// </summary>
         /// <param name="left">left hand side</param>
         /// <param name="right">right hand side</param>
@@ -480,7 +480,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Determines whether the specified value is NaN.
         /// </summary>
-        /// 
+        ///
         /// <param name="value">Float16 instance</param>
         /// <returns>true if the value is not a number</returns>
         public static bool IsNaN(Float16 value)
@@ -492,7 +492,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// Determines whether the specified value is negative.
         /// </summary>
         /// <param name="value">Float16 instance</param>
-        /// <returns>true if the value is negative</returns></returns>
+        /// <returns>true if the value is negative</returns>
         public static bool IsNegative(Float16 value)
         {
             return (short)(value.value) < 0;
@@ -501,7 +501,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Determines whether the specified value is negative infinity.
         /// </summary>
-        /// 
+        ///
         /// <param name="value">Float16 instance</param>
         /// <returns>true if the value is negative infinity</returns>
         public static bool IsNegativeInfinity(Float16 value)
@@ -550,7 +550,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Compares this object to another object, returning an integer that indicates the relationship.
         /// </summary>
-        /// 
+        ///
         /// <param name="obj">Object to compare to</param>
         /// <returns>A value less than zero if this is less than <paramref name="obj"/>,
         /// zero if this is equal to <paramref name="obj"/>, or a value greater than zero
@@ -571,7 +571,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// </summary>
         /// <param name="other">Object to compare to</param>
         /// <returns>A value less than zero if this is less than <paramref name="other"/>,
-        /// zero if this is equal to <paramref name="other"/>, 
+        /// zero if this is equal to <paramref name="other"/>,
         /// or a value greater than zero if this is greater than <paramref name="other"/>.</returns>
         public int CompareTo(Float16 other)
         {
@@ -865,10 +865,13 @@ namespace Microsoft.ML.OnnxRuntime
         private const ushort PositiveQNaNBits = 0x7FC1;
         private const ushort NegativeQNaNBits = 0xFFC1;
 
+        // Lowest finite value. It is corresponding to numeric_limits<BFloat16>::lowest() in C++.
         private const ushort MinValueBits = 0xFF7F; // 1b0_11111110_1111111
+
         private const ushort MaxValueBits = 0x7F7F; // 0b0_11111110_1111111
 
-        private const ushort EpsilonBits = 0x0080; // the smallest positive normal value
+        // Minimum positive normalized value. It is corresponding to numeric_limits<BFloat16>::min() in C++.
+        private const ushort EpsilonBits = 0x0080;
 
         private const ushort PiBits = 0x4049; // 0b0_10000000_1001001
 
@@ -900,7 +903,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// BFloat16 NaN
         /// </summary>
-        public static BFloat16 NaN => new BFloat16(NegativeQNaNBits);
+        public static BFloat16 NaN => new BFloat16(NegativeQNaNBits); // .Net has no BFloat16. Follow Float16 style.
 
         /// <summary>
         /// BFloat16 Positive Zero
@@ -920,13 +923,13 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// BFloat16 Min value
         /// </summary>
-        public static BFloat16 MinValue => new BFloat16(MinValueBits);  // 65,407
+        public static BFloat16 MinValue => new BFloat16(MinValueBits);  // -3.38953139e38
 
         /// <summary>
         /// BFloat16 Max value
         /// </summary>
 
-        public static BFloat16 MaxValue => new BFloat16(MaxValueBits); // 32,639
+        public static BFloat16 MaxValue => new BFloat16(MaxValueBits); // 3.38953139e38
 
         /// <summary>
         /// bfloat16 representation bits
@@ -1052,7 +1055,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Compares values of two BFloat16 for binary equality.
         /// If either of the values is NaN, this will return false.
-        /// 
+        ///
         /// </summary>
         /// <param name="left">left hand side</param>
         /// <param name="right">right hand side</param>
@@ -1103,7 +1106,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Determines whether the specified value is NaN.
         /// </summary>
-        /// 
+        ///
         /// <param name="value">BFloat16 instance</param>
         /// <returns>true if the value is not a number</returns>
         public static bool IsNaN(BFloat16 value)
@@ -1115,7 +1118,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// Determines whether the specified value is negative.
         /// </summary>
         /// <param name="value">BFloat16 instance</param>
-        /// <returns>true if the value is negative</returns></returns>
+        /// <returns>true if the value is negative</returns>
         public static bool IsNegative(BFloat16 value)
         {
             return (short)(value.value) < 0;
@@ -1124,7 +1127,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Determines whether the specified value is negative infinity.
         /// </summary>
-        /// 
+        ///
         /// <param name="value">BFloat16 instance</param>
         /// <returns>true if the value is negative infinity</returns>
         public static bool IsNegativeInfinity(BFloat16 value)
@@ -1171,7 +1174,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// Compares this object to another object, returning an integer that indicates the relationship.
         /// </summary>
-        /// 
+        ///
         /// <param name="obj">Object to compare to</param>
         /// <returns>A value less than zero if this is less than <paramref name="obj"/>,
         /// zero if this is equal to <paramref name="obj"/>, or a value greater than zero
@@ -1192,7 +1195,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// </summary>
         /// <param name="other">Object to compare to</param>
         /// <returns>A value less than zero if this is less than <paramref name="other"/>,
-        /// zero if this is equal to <paramref name="other"/>, 
+        /// zero if this is equal to <paramref name="other"/>,
         /// or a value greater than zero if this is greater than <paramref name="other"/>.</returns>
         public int CompareTo(BFloat16 other)
         {
@@ -1369,4 +1372,4 @@ namespace Microsoft.ML.OnnxRuntime
 
         #endregion
     }
-}
+}

package/Runtime/OrtIoBinding.shared.cs

@@ -313,7 +313,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <summary>
         /// This fetches bound outputs after running the model with RunWithBinding()
         /// </summary>
-        /// <returns>IDisposableReadOnlyCollection<OrtValue></returns>
+        /// <returns>IDisposableReadOnlyCollection{OrtValue}</returns>
         public IDisposableReadOnlyCollection<OrtValue> GetOutputValues()
         {
             var ortValues = GetOutputOrtValues();

package/Runtime/OrtLoraAdapter.shared.cs

@@ -0,0 +1,81 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.ML.OnnxRuntime
+{
+    /// <summary>
+    /// Represents Lora Adapter in memory
+    /// </summary>
+    public class OrtLoraAdapter : SafeHandle
+    {
+        /// <summary>
+        /// Creates an instance of OrtLoraAdapter from file.
+        /// The adapter file is memory mapped. If allocator parameter
+        /// is provided, then lora parameters are copied to the memory
+        /// allocated by the specified allocator.
+        /// </summary>
+        /// <param name="adapterPath">path to the adapter file</param>
+        /// <param name="ortAllocator">optional allocator, can be null, must be a device allocator</param>
+        /// <returns>New instance of LoraAdapter</returns>
+        public static OrtLoraAdapter Create(string adapterPath, OrtAllocator ortAllocator)
+        {
+            var platformPath = NativeOnnxValueHelper.GetPlatformSerializedString(adapterPath);
+            var allocatorHandle = (ortAllocator != null) ? ortAllocator.Pointer : IntPtr.Zero;
+            NativeApiStatus.VerifySuccess(NativeMethods.CreateLoraAdapter(platformPath, allocatorHandle,
+                out IntPtr adapterHandle));
+            return new OrtLoraAdapter(adapterHandle);
+        }
+
+        /// <summary>
+        /// Creates an instance of OrtLoraAdapter from an array of bytes. The API
+        /// makes a copy of the bytes internally.
+        /// </summary>
+        /// <param name="bytes">array of bytes containing valid LoraAdapter format</param>
+        /// <param name="ortAllocator">optional device allocator or null</param>
+        /// <returns>new instance of LoraAdapter</returns>
+        public static OrtLoraAdapter Create(byte[] bytes, OrtAllocator ortAllocator)
+        {
+            var allocatorHandle = (ortAllocator != null) ? ortAllocator.Pointer : IntPtr.Zero;
+            NativeApiStatus.VerifySuccess(NativeMethods.CreateLoraAdapterFromArray(bytes, 
+                new UIntPtr((uint)bytes.Length), allocatorHandle, out IntPtr adapterHandle));
+            return new OrtLoraAdapter(adapterHandle);
+        }
+
+        internal OrtLoraAdapter(IntPtr adapter)
+            : base(adapter, true)
+        {
+        }
+
+        internal IntPtr Handle
+        {
+            get
+            {
+                return handle;
+            }
+        }
+
+        #region SafeHandle
+
+        /// <summary>
+        /// Overrides SafeHandle.IsInvalid
+        /// </summary>
+        /// <value>returns true if handle is equal to Zero</value>
+        public override bool IsInvalid { get { return handle == IntPtr.Zero; } }
+
+        /// <summary>
+        /// Overrides SafeHandle.ReleaseHandle() to properly dispose of
+        /// the native instance of OrtLoraAdapter
+        /// </summary>
+        /// <returns>always returns true</returns>
+        protected override bool ReleaseHandle()
+        {
+            NativeMethods.ReleaseLoraAdapter(handle);
+            handle = IntPtr.Zero;
+            return true;
+        }
+
+        #endregion
+    }
+}

package/Runtime/OrtLoraAdapter.shared.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 22d82fefbb37f43b492bbff3a67d1ee5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/OrtValue.shared.cs

@@ -236,12 +236,12 @@ namespace Microsoft.ML.OnnxRuntime
 
         /// <summary>
         /// Fetch string tensor element buffer pointer at the specified index,
-        /// convert/copy to UTF-16 char[] and return a ReadOnlyMemory<char> instance.
+        /// convert/copy to UTF-16 char[] and return a ReadOnlyMemory{char} instance.
         ///
         /// Obtain TensorTypeAndShape to get shape and element count.
         /// </summary>
         /// <param name="index">flat string tensor element index</param>
-        /// <returns>ReadOnlyMemory<char> backed by a managed char[]. Its lifespan is not
+        /// <returns>ReadOnlyMemory{char} backed by a managed char[]. Its lifespan is not
         /// tied to the native buffer of OrtValue.</returns>
         public ReadOnlyMemory<char> GetStringElementAsMemory(int index)
         {
@@ -845,7 +845,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// Note, this is different from creating an OrtValue from other primitive data types
         /// where memory is pinned (if necessary) and the OrtValue points to that chunk of memory.
         /// </summary>
-        /// <param name="tensor">Tensor<string></param>
+        /// <param name="tensor">Tensor{string}</param>
         /// <returns>A disposable OrtValue instance</returns>
         /// <exception cref="OnnxRuntimeException"></exception>
         public static OrtValue CreateFromStringTensor(Tensor<string> tensor)

package/Runtime/OrtValueTensor.shared.cs

@@ -85,7 +85,7 @@ namespace Microsoft.ML.OnnxRuntime
     /// This helper class owns the underlying OrtValue that is assumed to be a Tensor,
     /// it does not support any other ortValues and caches Tensor properties.
     /// 
-    /// It is easy to expose as a Tensor<T> as DenseTensor can take Memory Mapping from
+    /// It is easy to expose as a Tensor{T} as DenseTensor can take Memory Mapping from
     /// this.
     /// 
     /// This class is disposable because of the MemoryManager inheritance. Because this class

package/Runtime/ProviderOptions.shared.cs

@@ -318,9 +318,9 @@ namespace Microsoft.ML.OnnxRuntime
     }
 
     /// <summary>
-    /// CoreML flags for use with SessionOptions
+    /// CoreML flags for use with SessionOptions.
+    /// See https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/providers/coreml/coreml_provider_factory.h
     /// </summary>
-    /// <see cref="https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/providers/coreml/coreml_provider_factory.h"/>
     [Flags]
     public enum CoreMLFlags : uint
     {
@@ -328,13 +328,16 @@ namespace Microsoft.ML.OnnxRuntime
         COREML_FLAG_USE_CPU_ONLY = 0x001,
         COREML_FLAG_ENABLE_ON_SUBGRAPH = 0x002,
         COREML_FLAG_ONLY_ENABLE_DEVICE_WITH_ANE = 0x004,
-        COREML_FLAG_LAST = COREML_FLAG_ONLY_ENABLE_DEVICE_WITH_ANE,
+        COREML_FLAG_ONLY_ALLOW_STATIC_INPUT_SHAPES = 0x008,
+        COREML_FLAG_CREATE_MLPROGRAM = 0x010,
+        COREML_FLAG_USE_CPU_AND_GPU = 0x020,
+        COREML_FLAG_LAST = COREML_FLAG_USE_CPU_AND_GPU,
     }
 
     /// <summary>
-    /// NNAPI flags for use with SessionOptions
+    /// NNAPI flags for use with SessionOptions.
+    /// See https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/providers/nnapi/nnapi_provider_factory.h
     /// </summary>
-    /// <see cref="https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/providers/nnapi/nnapi_provider_factory.h"/>
     [Flags]
     public enum NnapiFlags
     {

package/Runtime/RunOptions.shared.cs

@@ -129,6 +129,18 @@ namespace Microsoft.ML.OnnxRuntime
             NativeApiStatus.VerifySuccess(NativeMethods.OrtAddRunConfigEntry(handle, utf8Key, utf8Value));
         }
 
+        /// <summary>
+        /// Appends the specified lora adapter to the list of active lora adapters
+        /// for this RunOptions instance. All run calls with this instant will
+        /// make use of the activated Lora Adapters. An adapter is considered active
+        /// if it is added to RunOptions that are used during Run() calls.
+        /// </summary>
+        /// <param name="loraAdapter">Lora adapter instance</param>
+        public void AddActiveLoraAdapter(OrtLoraAdapter loraAdapter)
+        {
+            NativeApiStatus.VerifySuccess(NativeMethods.OrtRunOptionsAddActiveLoraAdapter(handle, loraAdapter.Handle));
+        }
+
         #region SafeHandle
         /// <summary>
         /// Overrides SafeHandle.ReleaseHandle() to properly dispose of

package/Runtime/SessionOptions.shared.cs

@@ -780,8 +780,8 @@ namespace Microsoft.ML.OnnxRuntime
         private int _logVerbosityLevel = 0;
 
         /// <summary>
-        // Sets the number of threads used to parallelize the execution within nodes
-        // A value of 0 means ORT will pick a default
+        /// Sets the number of threads used to parallelize the execution within nodes
+        /// A value of 0 means ORT will pick a default
         /// </summary>
         /// <value>returns _intraOpNumThreads value</value>
         public int IntraOpNumThreads
@@ -799,9 +799,9 @@ namespace Microsoft.ML.OnnxRuntime
         private int _intraOpNumThreads = 0; // set to what is set in C++ SessionOptions by default;
 
         /// <summary>
-        // Sets the number of threads used to parallelize the execution of the graph (across nodes)
-        // If sequential execution is enabled this value is ignored
-        // A value of 0 means ORT will pick a default
+        /// Sets the number of threads used to parallelize the execution of the graph (across nodes)
+        /// If sequential execution is enabled this value is ignored
+        /// A value of 0 means ORT will pick a default
         /// </summary>
         /// <value>returns _interOpNumThreads value</value>
         public int InterOpNumThreads

package/Runtime/Tensors/ArrayTensorExtensions.shared.cs

@@ -15,7 +15,7 @@ using System;
 namespace Microsoft.ML.OnnxRuntime.Tensors
 {
     /// <summary>
-    /// A static class that houses static DenseTensor<T> extension methods
+    /// A static class that houses static DenseTensor{T} extension methods
     /// </summary>
     public static class ArrayTensorExtensions
     {

package/Runtime/Training/NativeTrainingMethods.shared.cs

@@ -76,7 +76,7 @@ namespace Microsoft.ML.OnnxRuntime
                 DOrtGetApi OrtGetApi = (DOrtGetApi)Marshal.GetDelegateForFunctionPointer(NativeMethods.OrtGetApiBase().GetApi, typeof(DOrtGetApi));
 #endif
 
-                const uint ORT_API_VERSION = 19;
+                const uint ORT_API_VERSION = 20;
 #if NETSTANDARD2_0
                 IntPtr ortApiPtr = OrtGetApi(ORT_API_VERSION);
                 api_ = (OrtApi)Marshal.PtrToStructure(ortApiPtr, typeof(OrtApi));

package/Runtime/Training/TrainingSession.shared.cs

@@ -295,7 +295,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <code>
         /// using OrtValue x = OrtValue.CreateTensorValueFromMemory(...);
         /// using OrtValue label = OrtValue.CreateTensorValueFromMemory(...);
-        /// List<OrtValue> inputValues = new List<OrtValue> { x, label };
+        /// List{OrtValue} inputValues = new List{OrtValue} { x, label };
         /// using (var loss = trainingSession.TrainStep(inputValues))
         /// {
         ///     // process output values
@@ -420,7 +420,7 @@ namespace Microsoft.ML.OnnxRuntime
         /// <code>
         /// using OrtValue x = OrtValue.CreateTensorValueFromMemory(...);
         /// using OrtValue label = OrtValue.CreateTensorValueFromMemory(...);
-        /// List<OrtValue> inputValues = new List<OrtValue> { x, label };
+        /// List{OrtValue} inputValues = new List{OrtValue} { x, label };
         /// using (var loss = trainingSession.EvalSteps(inputValues))
         /// {
         ///     // process output values

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.github.asus4.onnxruntime",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "displayName": "ONNX Runtime",
   "description": "ONNX Runtime Plugin for Unity",
   "keywords": [