Running in .NET within Unity crashes about blingfire HOT 6 CLOSED

using System;
using System.IO;
using System.Linq;
using BlingFire;
using UnityEngine;
public class BlingTokenizer : Singleton<BlingTokenizer> {
    ulong tokenizerHandle = 0;
    ulong tokenizerI2WHandle = 0;
    bool isLoaded = false;
    public static ulong GetTokenizerHandle() {
        return Instance.tokenizerHandle;
    }
    public static ulong GetTokenizerI2Handle() {
        return Instance.tokenizerI2WHandle;
    }

    public static void Load() {
        if (Instance.isLoaded)return;
        string tokenizerModelPath = Instance.GetPath("gpt2.bin");
        string tokenizerI2WPath = Instance.GetPath("gpt2.i2w");

        if (File.Exists(tokenizerModelPath)) {
            try {
                Instance.tokenizerHandle = BlingFireUtils.LoadModel(tokenizerModelPath);
                Debug.Log("Path Found and loaded: " + tokenizerModelPath);
            } catch (Exception e) {
                Console.WriteLine("{0} Exception caught.", e);
                Debug.Log("Exception: " + tokenizerModelPath);
            }
        }
        if (File.Exists(tokenizerI2WPath)) {
            //This Crashes the Editor
            try {
                Instance.tokenizerI2WHandle = BlingFireUtils.LoadModel(tokenizerI2WPath);
                Debug.Log("Path Found and loaded: " + tokenizerI2WPath);
            } catch (Exception e) {
                Console.WriteLine("{0} Exception caught.", e);
                Debug.Log("Exception: " + tokenizerI2WPath);
            }
        }
        //BlingFireUtils.SetNoDummyPrefix(GetTokenizerHandle(), true);
        //BlingFireUtils.SetNoDummyPrefix(GetTokenizerI2Handle(), true);
        Instance.isLoaded = true;
    }
    private void OnDestroy() {
        BlingFireUtils.FreeModel(tokenizerHandle);
    }
    public static int[] Tokenize(string input_str) {
        byte[] inBytes = System.Text.Encoding.UTF8.GetBytes(input_str);
        int[] ids = new int[128];
        int outputCount = BlingFireUtils.TextToIds(GetTokenizerHandle(), inBytes, inBytes.Length, ids, 8, -100);
        ids = ids.Take(outputCount).ToArray();
        return ids;
    }

    String GetPath(string fileName) {
        return Path.GetFullPath(Path.Combine(new string[] { Application.dataPath, "Models", fileName }));
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using BlingFire;
using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;
using UnityEngine;

public class LanguageModel : MonoBehaviour {
  public const int VOCAB_SIZE = 50257;
  String modelFilePath = "Models/gpt-neo-125M.onnx";

  OrtEnv ortEnv = OrtEnv.Instance();
  InferenceSession ortSession;
  private void Awake() {
      ortEnv.DisableTelemetryEvents();
      LoadModel();
  }
  void Start() {
      //LoadTokenizer();
  }

  void Update() {
      if (Input.GetKeyDown(KeyCode.A)) {
          LoadTokenizer();
      }
      if (Input.GetKeyDown(KeyCode.B)) {
          //LoadModel();
      }
      if (Input.GetKeyDown(KeyCode.LeftControl)) {
          LoadTokenizer();
          var startTime = System.DateTime.Now;
          string testText = "I am a man and I";
          int[] inputIds = BlingTokenizer.Tokenize(testText);
          var preProcTime = System.DateTime.Now;
          Tensor<float> output_ids = Predict(inputIds);
          var gptNeoRunTime = System.DateTime.Now;
          List<List<LMPrediction>> preds = PostProcess(output_ids, 4, inputIds.Length);
          var endTime = System.DateTime.Now;
          Debug.Log("Gpt Neo Runtime: " + (gptNeoRunTime - startTime).TotalMilliseconds);
          Debug.Log("LM PreProc Time: " + (preProcTime - startTime).TotalMilliseconds + "ms;   " + "PostProcess runtime: " + (endTime - gptNeoRunTime).TotalMilliseconds + "ms");
          PrintPreds(preds);
          Debug.Log(NaivePredsToText(preds));
      }
  }
  void LoadTokenizer() {
      BlingTokenizer.Load();
  }
  void LoadModel() {
      String modelPath = GetPath();
      ortSession = new InferenceSession(modelPath);
  }
  Tensor<float> Predict(int[] input_ids) {
      Debug.Log(input_ids.Length);
      Tensor<Int64> input_tensor = new DenseTensor<Int64>(new [] { 1, 1, 8 });
      for (int i = 0; i < 8; i++) {
          input_tensor[0, 0, i] = i < input_ids.Length?input_ids[i]: -100;
      }

      var model_inputs = new List<NamedOnnxValue>() {
          NamedOnnxValue.CreateFromTensor("input_ids", input_tensor)
      };
      var model_outputs = ortSession.Run(model_inputs);

      var token_activation_output = model_outputs.First((v) => v.Name == "output_0").AsTensor<float>();
      //var token_activation_output12 = model_outputs.First((v) => v.Name == "output_12").AsTensor<float>();
      Debug.Log($"Got an output tensor [{String.Join(",", token_activation_output.Dimensions.ToArray())}]");
      return token_activation_output;
  }
  List<LMPrediction> CreatePredictions(Tensor<float> token_activation_output, int top_k = -1, int skip = 0) {
      var logits = token_activation_output.AsEnumerable<float>().Skip(skip * VOCAB_SIZE).Take(VOCAB_SIZE);
      float sum = logits.Sum(x => (float)Math.Exp(x));
      IEnumerable<float> softmax = logits.Select(x => (float)Math.Exp(x) / sum);
      var test_sorted_predictions = softmax.Select((x, i) => new LMPrediction() { token = i, confidence = x }).OrderByDescending(x => x.confidence).Take(top_k > 0 ? top_k : VOCAB_SIZE);
      return test_sorted_predictions.ToList();
  }
  public List<List<LMPrediction>> PostProcess(Tensor<float> token_activation_output, int top_k = -1, int inputSize = 1, int genLength = 8) {
      List<List<LMPrediction>> output_predictions = new List<List<LMPrediction>>();
      for (int i = 0; i < genLength - inputSize; i++) {
          output_predictions.Add(CreatePredictions(token_activation_output, top_k, inputSize + i));
      }
      return output_predictions;
  }

  string NaivePredsToText(List<List<LMPrediction>> preds) {
      string output = "";
      foreach (List<LMPrediction> predList in preds) {
          output += predList.FirstOrDefault().ToWord() + " ";
      }
      return output;
  }

  void PrintPreds(List<List<LMPrediction>> preds) {
      string printVal = "";
      foreach (List<LMPrediction> predList in preds) {
          printVal += " \n---------------\n" + String.Join("\n", predList.Select(x => x.ToConfidenceStr()));
      }
      Debug.Log(printVal);
  }

  String GetPath() {
      return Path.Combine(new string[] { Application.dataPath, modelFilePath });
  }
}