C#实现词嵌入相似度查询：从向量计算到生产环境优化

1次阅读

没有评论

共计 3602 个字符，预计需要花费 10 分钟才能阅读完成。

在自然语言处理（NLP）任务中，词嵌入（Word Embedding）技术将词语映射为高维空间中的向量，使得语义相近的词在向量空间中距离更近。传统字符串匹配方法（如 Levenshtein 距离）只能处理字形相似度，无法捕捉以下场景：

“ 手机 ” 和 ” 智能手机 ” 的语义关联
“ 银行 ” 在不同上下文中的多义性（金融机构 vs 河流岸边）

词嵌入相似度查询通过向量距离计算，能有效解决这些问题。但在实际应用中，开发者常遇到：

大规模词表导致内存爆炸
实时查询的延迟问题
多线程环境下的并发控制

常见向量相似度算法特性对比：

算法	计算方式	适用场景	复杂度
余弦相似度	cosθ = (A·B)/(		A
欧式距离	√Σ(Ai-Bi)²	绝对距离敏感	O(n)
点积	Σ(Ai*Bi)	需要归一化后使用	O(n)

建议选择逻辑：
– 当只关注向量方向时（如语义相似度）→ 余弦相似度
– 需要同时考虑方向和大小 → 欧式距离
– 对性能要求极致且已归一化 → 点积

以加载 GloVe 词向量为例（需提前下载模型文件）：

public Dictionary<string, float[]> LoadEmbeddings(string filePath)
{var embeddings = new Dictionary<string, float[]>();

    foreach (var line in File.ReadLines(filePath))
    {var segments = line.Split(' ');
        var word = segments[0];
        var vector = segments[1..].Select(float.Parse).ToArray();

        // 建议立即归一化以提升后续计算效率
        NormalizeVector(vector);
        embeddings[word] = vector;
    }

    return embeddings;
}

private void NormalizeVector(float[] vector)
{var norm = Math.Sqrt(vector.Sum(x => x * x));
    for (int i = 0; i < vector.Length; i++)
    {vector[i] /= (float)norm;
    }
}

避免使用 Dictionary<string, float[]> 的原始存储方式，改为：

public class EmbeddingStore
{private readonly float[] _vectors; // 连续内存存储
    private readonly int _dimension;
    private readonly Dictionary<string, int> _wordIndex;

    public EmbeddingStore(IEnumerable<(string Word, float[] Vector)> embeddings)
    {_dimension = embeddings.First().Vector.Length;
        _vectors = new float[embeddings.Count() * _dimension];
        _wordIndex = new Dictionary<string, int>();

        int offset = 0;
        foreach (var (word, vector) in embeddings)
        {Array.Copy(vector, 0, _vectors, offset, _dimension);
            _wordIndex[word] = offset;
            offset += _dimension;
        }
    }

    public ReadOnlySpan<float> GetVector(string word)
    {if (_wordIndex.TryGetValue(word, out var offset))
        {return new ReadOnlySpan<float>(_vectors, offset, _dimension);
        }
        return ReadOnlySpan<float>.Empty;
    }
}

using System.Numerics;

public float CosineSimilaritySIMD(ReadOnlySpan<float> vec1, ReadOnlySpan<float> vec2)
{if (vec1.Length != vec2.Length) 
        throw new ArgumentException("Vector dimensions mismatch");

    int vectorSize = Vector<float>.Count;
    int i = 0;

    // SIMD 加速部分
    var dotSum = Vector<float>.Zero;
    var norm1Sum = Vector<float>.Zero;
    var norm2Sum = Vector<float>.Zero;

    for (; i <= vec1.Length - vectorSize; i += vectorSize)
    {var v1 = new Vector<float>(vec1.Slice(i, vectorSize));
        var v2 = new Vector<float>(vec2.Slice(i, vectorSize));

        dotSum += v1 * v2;
        norm1Sum += v1 * v1;
        norm2Sum += v2 * v2;
    }

    // 处理剩余元素
    float dot = 0, norm1 = 0, norm2 = 0;
    for (; i < vec1.Length; i++)
    {dot += vec1[i] * vec2[i];
        norm1 += vec1[i] * vec1[i];
        norm2 += vec2[i] * vec2[i];
    }

    // 合并结果
    dot += Vector.Dot(dotSum, Vector<float>.One);
    norm1 += Vector.Dot(norm1Sum, Vector<float>.One);
    norm2 += Vector.Dot(norm2Sum, Vector<float>.One);

    return dot / (MathF.Sqrt(norm1) * MathF.Sqrt(norm2));
}

当词表超过 100 万时，精确查询变得不现实。推荐使用开源库 Microsoft.TorchSharp 实现 HNSW 算法：

// 安装 NuGet 包：Microsoft.TorchSharp
var graph = new HNSWGraph(dimensions: 300, maxEdges: 16);

// 添加所有向量
foreach (var (word, vector) in embeddings)
{graph.AddNode(vector);
}

// 构建索引
graph.Build();

// 近似查询
var (neighbors, distances) = graph.Search(queryVector, k: 5);

测试环境：i7-11800H, 32GB RAM

词表规模	精确查询(ms)	ANN 查询(ms)	内存占用(MB)
10,000	1.2	0.8	45
100,000	12.7	2.1	420
1,000,000	128.3	5.9	3800

浮点数精度问题：
使用 MathF 替代 Math 提升计算速度
比较相似度时设置合理阈值（如if(cosSim > 0.85f)）

线程安全方案：

public class ConcurrentEmbeddingStore
{private readonly ReaderWriterLockSlim _lock = new();
    private EmbeddingStore _store;

    public void UpdateEmbeddings(EmbeddingStore newStore)
    {_lock.EnterWriteLock();
        try {_store = newStore;} finally {_lock.ExitWriteLock();
        }
    }

    public float GetSimilarity(string word1, string word2)
    {_lock.EnterReadLock();
        try {var vec1 = _store.GetVector(word1);
            var vec2 = _store.GetVector(word2);
            return CosineSimilaritySIMD(vec1, vec2);
        } finally {_lock.ExitReadLock();
        }
    }
}