// 模型输入名称（动态获取或硬编码）
  private readonly string \_inputNameIds;
  private readonly string \_inputNameMask;
  private readonly string \_inputNameTokenType; // 新增：token\_type\_ids 名称
  private readonly string \_outputName;

  // BGE 模型配置
  private const int MaxLength = 512;
  private const int PadTokenId = 0;
  private const int TokenTypeId = 0; // BGE/BERT 单句输入通常全为 0

  public OnnxBgeEmbeddingService(string modelPath, string vocabPath)
  {
      // 1. 初始化 ONNX 会话
      var sessionOptions = new SessionOptions();
      sessionOptions.InterOpNumThreads \= 4;
      sessionOptions.IntraOpNumThreads \= 4;

      \_session \= new InferenceSession(modelPath, sessionOptions);

      // 2. 初始化分词器
      \_tokenizer = BertTokenizer.Create(vocabPath);

      // 3. 获取模型输入输出名称
      var inputKeys = \_session.InputMetadata.Keys.ToList();
      \_inputNameIds \= inputKeys.FirstOrDefault(k => k.Contains("input\_ids")) ?? "input\_ids";
      \_inputNameMask \= inputKeys.FirstOrDefault(k => k.Contains("attention\_mask")) ?? "attention\_mask";
      // 关键修复：查找 token\_type\_ids 或 token\_type\_ids 类似的键
      \_inputNameTokenType = inputKeys.FirstOrDefault(k => k.Contains("token\_type")) ?? "token\_type\_ids";

      if (\_session.OutputMetadata.Count == 0)
          throw new InvalidOperationException("Model has no outputs.");
      \_outputName \= \_session.OutputMetadata.Keys.First();
  }

  public float\[\] GenerateEmbedding(string text)
  {
      if (string.IsNullOrWhiteSpace(text))
          throw new ArgumentException("Text cannot be null or empty");

      // 1. 分词并预处理 (截断 + 填充)
      var (inputIds, attentionMask, tokenTypeIds) = EncodeAndPreprocess(text);

      // 2. 构建输入张量
      // 注意：大多数 BGE ONNX 模型接受 int64 (long)，部分优化模型接受 int32 (int)
      // 如果报错 Type Mismatch，请将 DenseTensor<long> 改为 DenseTensor<int>
      var inputIdsTensor = new DenseTensor<long\>(inputIds, new\[\] { 1, inputIds.Length });
      var attentionMaskTensor = new DenseTensor<long\>(attentionMask, new\[\] { 1, attentionMask.Length });
      var tokenTypeIdsTensor = new DenseTensor<long\>(tokenTypeIds, new\[\] { 1, tokenTypeIds.Length });

      var inputs = new List<NamedOnnxValue>
  {
      NamedOnnxValue.CreateFromTensor(\_inputNameIds, inputIdsTensor),
      NamedOnnxValue.CreateFromTensor(\_inputNameMask, attentionMaskTensor),
      NamedOnnxValue.CreateFromTensor(\_inputNameTokenType, tokenTypeIdsTensor) // 关键修复：添加此输入
  };

      // 3. 执行推理
      using var results = \_session.Run(inputs);

      // 4. 提取结果
      var rawOutput = results.First().AsTensor<float\>();

      // 关键修复：正确获取维度
      // rawOutput 形状通常为 \[1, seq\_len, hidden\_size\]
      // Dimensions 是一个 int\[\] 数组，例如 \[1, 512, 384\]
      if (rawOutput.Rank != 3)
          throw new InvalidOperationException($"Expected 3D output, got {rawOutput.Rank}D");

      int seqLen = rawOutput.Dimensions.Length; // 序列长度
      int hiddenSize = rawOutput.Dimensions.Length; // 向量维度

      float\[\] embedding = new float\[hiddenSize\];

      // 5. 平均池化 (Mean Pooling)
      int validTokenCount = 0;
      for (int i = 0; i < seqLen; i++)
      {
          // 只有当 attention mask 为 1 时才参与计算
          if (attentionMask\[i\] == 1)
          {
              for (int j = 0; j < hiddenSize; j++)
              {
                  // 累加每个维度的值
                  embedding\[j\] += rawOutput\[0, i, j\];
              }
              validTokenCount++;
          }
      }

      // 求平均
      if (validTokenCount > 0)
      {
          for (int i = 0; i < hiddenSize; i++)
          {
              embedding\[i\] /= validTokenCount;
          }
      }

      // 6. L2 归一化
      Normalize(embedding);

      return embedding;
  }

  /// <summary>
  /// 编码并预处理：截断、填充、生成 Mask 和 Token Type IDs
  /// </summary>
  private (long\[\] InputIds, long\[\] AttentionMask, long\[\] TokenTypeIds) EncodeAndPreprocess(string text)
  {
      // 使用 BertTokenizer 编码
      // EncodeToIds 返回 ReadOnlyMemory<int>
      int\[\] originalIds = \_tokenizer.EncodeToIds(text).ToArray();

      int currentLen = originalIds.Length;

      // 1. 截断 (Truncation)
      if (currentLen > MaxLength)
      {
          Array.Resize(ref originalIds, MaxLength);
          currentLen \= MaxLength;
      }

      // 2. 填充 (Padding)
      if (currentLen < MaxLength)
      {
          int oldLen = originalIds.Length;
          Array.Resize(ref originalIds, MaxLength);
          // 将新增部分填充为 PadTokenId (0)
          for (int i = oldLen; i < MaxLength; i++)
          {
              originalIds\[i\] \= PadTokenId;
          }
      }

      // 3. 生成 Attention Mask 和 Token Type IDs
      long\[\] attentionMask = new long\[MaxLength\];
      long\[\] tokenTypeIds = new long\[MaxLength\];

      for (int i = 0; i < MaxLength; i++)
      {
          // Mask: 非 Padding 位为 1，Padding 位为 0
          attentionMask\[i\] = (originalIds\[i\] != PadTokenId) ? 1 : 0;

          // Token Type IDs: BGE 单句任务通常全为 0
          tokenTypeIds\[i\] = TokenTypeId;
      }

      // 将 int\[\] 转换为 long\[\] 以匹配 ONNX 输入要求
      long\[\] finalInputIds = Array.ConvertAll(originalIds, x => (long)x);

      return (finalInputIds, attentionMask, tokenTypeIds);
  }

  private void Normalize(float\[\] vector)
  {
      float sum = 0;
      foreach (var v in vector)
      {
          sum += v \* v;
      }
      float norm = (float)Math.Sqrt(sum);
      if (norm > 0)
      {
          for (int i = 0; i < vector.Length; i++)
          {
              vector\[i\] /= norm;
          }
      }
  }

  public void Dispose()
  {
      \_session?.Dispose(); 
  }