update to inference-engine

MiniLMv6.sentis

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c9a2597ce9edce4c09b32e993b7f906cce91fceb2f461a597b974f71ee70453d
-size 90898400

README.md

@@ -2,36 +2,24 @@
 license: apache-2.0
 library_name: unity-sentis
 pipeline_tag: sentence-similarity
+tags:
+  - unity-inference-engine
 ---
 
-# Mini LM Sentis Similarity validated for Unity Sentis (Version 1.4.0-pre.2*)
-*Version 1.3.0 Sentis files are not compatible with Sentis 1.4.0 and need to be recreated/downloaded
+# Mini LM in Unity 6 with Inference Engine
 
-This is the [Mini LM v6 model](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) in the Sentis format to run on Unity 2023. It is a sentence similarity model that compares different sentences and gives a score depending on how similar they are.
+This is the [Mini LM v6 model](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) model running in Unity 6 with Inference Engine. Mini LM is a sentence similarity model that compares different sentences and gives a score depending on how similar they are.
 
 ## How to Use
 
-* Create a new scene in Unity 2023
-* Install com.unity.sentis from the package manager
-* Add the MiniLMv6.cs file to the Main Camera
-* Add vocab.txt and MiniLMv6.sentis to the Assets/StreamingAssets folder
-* Change the string1 and string2 variables to the desired strings
-* Press play, the results will show in the Console
+* Create a new scene in Unity 6;
+* Install `com.unity.ai.inference` from the package manager;
+* Add the `RunMiniLM.cs` script to the Main Camera;
+* Drag the `MiniLMv6.onnx` asset from the `models` folder into the `Model Asset` field;
+* Drag the `vocab.txt` asset from the `data` folder into the `Vocab Asset` field;
 
-## Project Demonstration
-Thomas, a member of the Hugging Face team, also a good [tutorial](https://thomassimonini.substack.com/p/create-an-ai-robot-npc-using-hugging) of using this model in a mini-game made.
+## Preview
+Enter play mode. If working correctly the sentence similarity score will be logged to the console.
 
-# Example Inputs
-```
-string1 = "That is a happy person"
-
-string2 = "That is a happy dog"
-```
-
-# Example Outputs
-```
-Similarity Score: 0.6945773
-```
-
-## Unity Sentis
-Sentis is the inference engine for Unity. More can be found about it [here](https://unity.com/products/sentis)
+## Inference Engine
+Inference Engine is a neural network inference library for Unity. Find out more [here](https://docs.unity3d.com/Packages/com.unity.ai.inference@latest).

MiniLMv6.cs → RunMiniLM.cs

@@ -1,51 +1,35 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using Unity.InferenceEngine;
 using UnityEngine;
-using Unity.Sentis;
-using System.IO;
-using System.Text;
-using FF = Unity.Sentis.Functional;
-
-/*
- *              Tiny Stories Inference Code
- *              ===========================
- *  
- *  Put this script on the Main Camera
- *  
- *  In Assets/StreamingAssets put:
- *  
- *  MiniLMv6.sentis
- *  vocab.txt
- * 
- *  Install package com.unity.sentis
- * 
- */
-
-
-public class MiniLM : MonoBehaviour
+
+public class RunMiniLM : MonoBehaviour
 {
+    public ModelAsset modelAsset;
+    public TextAsset vocabAsset;
     const BackendType backend = BackendType.GPUCompute;
 
-    string string1 = "That is a happy person";          // similarity = 1
+    string string1 = "That is a happy person"; // similarity = 1
 
-    //Choose a string to comapre string1  to:
-    string string2 = "That is a happy dog";             // similarity = 0.695
-    //string string2 = "That is a very happy person";   // similarity = 0.943
-    //string string2 = "Today is a sunny day";          // similarity = 0.257
+    //Choose a string to compare with string1:
+    string string2 = "That is a happy dog"; // similarity = 0.695
+    //string string2 = "That is a very happy person"; // similarity = 0.943
+    //string string2 = "Today is a sunny day"; // similarity = 0.257
 
     //Special tokens
-    const int START_TOKEN = 101; 
-    const int END_TOKEN = 102; 
+    const int START_TOKEN = 101;
+    const int END_TOKEN = 102;
 
     //Store the vocabulary
     string[] tokens;
 
     const int FEATURES = 384; //size of feature space
 
-    IWorker engine, dotScore;
+    Worker engine, dotScore;
 
     void Start()
     {
-        tokens = File.ReadAllLines(Application.streamingAssetsPath + "/vocab.txt");
+        tokens = vocabAsset.text.Split("\r\n");
 
         engine = CreateMLModel();
 
@@ -54,87 +38,70 @@ public class MiniLM : MonoBehaviour
         var tokens1 = GetTokens(string1);
         var tokens2 = GetTokens(string2);
 
-        using TensorFloat embedding1 = GetEmbedding(tokens1);
-        using TensorFloat embedding2 = GetEmbedding(tokens2);
+        using Tensor<float> embedding1 = GetEmbedding(tokens1);
+        using Tensor<float> embedding2 = GetEmbedding(tokens2);
 
         float score = GetDotScore(embedding1, embedding2);
 
         Debug.Log("Similarity Score: " + score);
     }
 
-    float GetDotScore(TensorFloat A, TensorFloat B)
+    float GetDotScore(Tensor<float> A, Tensor<float> B)
     {
-        var inputs = new Dictionary<string, Tensor>()
-        {
-            { "input_0", A },
-            { "input_1", B }
-        };
-        dotScore.Execute(inputs);
-        var output = dotScore.PeekOutput() as TensorFloat;
-        output.CompleteOperationsAndDownload();
+        dotScore.Schedule(A, B);
+        var output = (dotScore.PeekOutput() as Tensor<float>).DownloadToNativeArray();
         return output[0];
     }
 
-    TensorFloat GetEmbedding(List<int> tokens)
+    Tensor<float> GetEmbedding(List<int> tokenList)
     {
-        int N = tokens.Count;
-        using var input_ids = new TensorInt(new TensorShape(1, N), tokens.ToArray());
-        using var token_type_ids = new TensorInt(new TensorShape(1, N), new int[N]);
+        int N = tokenList.Count;
+        using var input_ids = new Tensor<int>(new TensorShape(1, N), tokenList.ToArray());
+        using var token_type_ids = new Tensor<int>(new TensorShape(1, N), new int[N]);
         int[] mask = new int[N];
         for (int i = 0; i < mask.Length; i++)
         {
             mask[i] = 1;
         }
-        using var attention_mask = new TensorInt(new TensorShape(1, N), mask);
+        using var attention_mask = new Tensor<int>(new TensorShape(1, N), mask);
 
-        var inputs = new Dictionary<string, Tensor>
-        {
-            {"input_0", input_ids },
-            {"input_1", attention_mask },
-            {"input_2", token_type_ids}
-        };
+        engine.Schedule(input_ids, attention_mask, token_type_ids);
 
-        engine.Execute(inputs);
-
-        var output = engine.TakeOutputOwnership("output_0") as TensorFloat;
+        var output = engine.PeekOutput().ReadbackAndClone() as Tensor<float>;
         return output;
     }
 
-    IWorker CreateMLModel()
+    Worker CreateMLModel()
     {
-        Model model = ModelLoader.Load(Application.streamingAssetsPath + "/MiniLMv6.sentis");
-
-        Model modelWithMeanPooling = Functional.Compile(
-          (input_ids, attention_mask, token_type_ids) =>
-          {
-              var tokenEmbeddings = model.Forward(input_ids, attention_mask, token_type_ids)[0];
-              return MeanPooling(tokenEmbeddings, attention_mask);
-          },
-          (model.inputs[0], model.inputs[1], model.inputs[2])
-        );
-
-        return WorkerFactory.CreateWorker(backend, modelWithMeanPooling);
+        var model = ModelLoader.Load(modelAsset);
+        var graph = new FunctionalGraph();
+        var inputs = graph.AddInputs(model);
+        var tokenEmbeddings = Functional.Forward(model, inputs)[0];
+        var attention_mask = inputs[1];
+        var output = MeanPooling(tokenEmbeddings, attention_mask);
+        var modelWithMeanPooling = graph.Compile(output);
+
+        return new Worker(modelWithMeanPooling, backend);
     }
 
     //Get average of token embeddings taking into account the attention mask
     FunctionalTensor MeanPooling(FunctionalTensor tokenEmbeddings, FunctionalTensor attentionMask)
     {
-        var mask = attentionMask.Unsqueeze(-1).BroadcastTo(new[] { FEATURES });     //shape=(1,N,FEATURES)
-        var A = FF.ReduceSum(tokenEmbeddings * mask, 1, false);                     //shape=(1,FEATURES)       
-        var B = A / (FF.ReduceSum(mask, 1, false) + 1e-9f);                         //shape=(1,FEATURES)
-        var C = FF.Sqrt(FF.ReduceSum(FF.Square(B), 1, true));                       //shape=(1,FEATURES)
-        return B / C;                                                               //shape=(1,FEATURES)
+        var mask = attentionMask.Unsqueeze(-1).BroadcastTo(new[] { FEATURES }); //shape=(1,N,FEATURES)
+        var A = Functional.ReduceSum(tokenEmbeddings * mask, 1); //shape=(1,FEATURES)
+        var B = A / (Functional.ReduceSum(mask, 1) + 1e-9f); //shape=(1,FEATURES)
+        var C = Functional.Sqrt(Functional.ReduceSum(Functional.Square(B), 1, true)); //shape=(1,FEATURES)
+        return B / C; //shape=(1,FEATURES)
     }
 
-    IWorker CreateDotScoreModel()
+    Worker CreateDotScoreModel()
     {
-        Model dotScoreModel = Functional.Compile(
-            (input1, input2) => Functional.ReduceSum(input1 * input2, 1),
-            (InputDef.Float(new TensorShape(1, FEATURES)),
-            InputDef.Float(new TensorShape(1, FEATURES)))
-        );
-
-        return WorkerFactory.CreateWorker(backend, dotScoreModel);
+        var graph = new FunctionalGraph();
+        var input1 = graph.AddInput<float>(new TensorShape(1, FEATURES));
+        var input2 = graph.AddInput<float>(new TensorShape(1, FEATURES));
+        var output = Functional.ReduceSum(input1 * input2, 1);
+        var dotScoreModel = graph.Compile(output);
+        return new Worker(dotScoreModel, backend);
     }
 
     List<int> GetTokens(string text)
@@ -152,10 +119,10 @@ public class MiniLM : MonoBehaviour
         foreach (var word in words)
         {
             int start = 0;
-            for(int i = word.Length; i >= 0;i--)
+            for (int i = word.Length; i >= 0; i--)
             {
-                string subword = start == 0 ? word.Substring(start, i) : "##" + word.Substring(start, i-start);
-                int index = System.Array.IndexOf(tokens, subword);
+                string subword = start == 0 ? word.Substring(start, i) : "##" + word.Substring(start, i - start);
+                int index = Array.IndexOf(tokens, subword);
                 if (index >= 0)
                 {
                     ids.Add(index);
@@ -169,15 +136,14 @@ public class MiniLM : MonoBehaviour
 
         ids.Add(END_TOKEN);
 
-        Debug.Log("Tokenized sentece = " + s);
+        Debug.Log("Tokenized sentence = " + s);
 
         return ids;
     }
 
-    private void OnDestroy()
-    { 
+    void OnDestroy()
+    {
         dotScore?.Dispose();
         engine?.Dispose();
     }
-
 }

info.json

@@ -1,14 +1,14 @@
 {
     "code": [
-      "MiniLMv6.cs"
+      "RunMiniLM.cs"
     ],
     "models": [
-        "MiniLMv6.sentis"
+        "models/MiniLMv6.onnx"
     ],
     "data": [
-        "vocab.txt"
+        "data/vocab.txt"
     ],
     "version": [
-        "1.4.0"
+        "2.2.0"
     ]
 }