.NET如何实现向量语义分析

一、概述

     这段时间一直在做插件平台，组件插件化，还有AI Agent组件插件，还扩展支持ai 知识库，向量语义分析，还研究了语言大模型、向量大模型，还有什么归一化，点积，余弦相似度等语义算法分析匹配，之前一直用llamasharp，然后用LLamaEmbedder 做向量语义分析，但是发现匹配不准确。后面查资料LLamaEmbedder 做中文短文本语义向量，本来就不准，尤其是：现在几点 / 当前时间 / 几点了 / 查时间生成模块代码 / 数据库表结构
它不准是天生缺陷。

二、LLamaEmbedder 为什么不准？（核心原因）   

它是 LLM 大语言模型，不是向量模型，不是专门为语义向量训练的，向量质量远不如 Sentence-BERT、BGE、m3e 这类专业模型。
    中文支持极差LlamaEmbedder 原生对中文短文本、口语化问句几乎不优化。
    输出的向量没有归一化、没有对齐语义导致余弦相似度乱跳：
        同义句分数低
        无关句分数高
    速度慢、占用高对比专业向量模型，完全不适合做匹配。

二、.net 真正准的语义向量方案（中文最强）

有两种向量模型方案：
方案 1：BGE 向量模型（国内最准）
方案 2：m3e 向量模型（轻量、超快、中文专门训练）

三、如何使用BGE 向量模型做向量语义分析

 下载这个：bge-small-zh 中文向量模型

https://hf-mirror.com/Xenova/bge-small-zh-v1.5

或单独下载vocab.txt，model.onnx

https://hf-mirror.com/Xenova/bge-small-zh-v1.5/resolve/main/vocab.txt

https://hf-mirror.com/Xenova/bge-small-zh-v1.5/resolve/main/onnx/model.onnx

然后可以封装成以下代码：需要通过nuget引用下载Microsoft.ML.OnnxRuntime和Microsoft.ML.Tokenizers

 

  public class OnnxBgeEmbeddingService : IDisposable
  {
      private readonly InferenceSession _session;
      private readonly BertTokenizer _tokenizer; // 使用 BertTokenizer

      // 模型输入名称（动态获取或硬编码）
      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 改为 DenseTensor
          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.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;
      }

      /// 

      /// 编码并预处理：截断、填充、生成 Mask 和 Token Type IDs
      /// 
      private (long[] InputIds, long[] AttentionMask, long[] TokenTypeIds) EncodeAndPreprocess(string text)
      {
          // 使用 BertTokenizer 编码
          // EncodeToIds 返回 ReadOnlyMemory
          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(); 
      }
  }

以下是调用：

 var onnxBgeEmbeddingService = new OnnxBgeEmbeddingService("Models/model.onnx", "Models/vocab.txt")
 onnxBgeEmbeddingService .GenerateEmbedding("微服务是什么")

以下就是用向量语义分析检索出来的AI对话结果