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

1次阅读

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

在自然语言处理（NLP）应用中，词嵌入相似度查询是一个基础但关键的需求。传统方法如字符串匹配或正则表达式在处理语义相似性时表现不佳，因为它们无法捕捉词语之间的语义关系。例如，” 汽车 ” 和 ” 车辆 ” 在字符串匹配中完全不同，但在语义上非常接近。词嵌入技术通过将词语映射到高维向量空间，使得语义相似的词在向量空间中也相近，从而解决了这一问题。

常见的相似度算法包括余弦相似度、欧式距离和点积。每种算法有其适用场景和优缺点：

余弦相似度：衡量两个向量的夹角，忽略向量长度，适合文本相似度计算。
欧式距离：计算向量间的直线距离，对向量长度敏感。
点积：计算简单，但对向量长度敏感，通常需要归一化。

对于大多数 NLP 任务，余弦相似度是首选，因为它对向量长度不敏感，更适合衡量语义相似性。

预训练的词向量（如 Word2Vec 或 GloVe）通常以文本文件形式存储。我们可以使用 C# 的 StreamReader 逐行读取并解析：

public Dictionary<string, float[]> LoadWordVectors(string filePath)
{var wordVectors = new Dictionary<string, float[]>();
    using (var reader = new StreamReader(filePath))
    {
        string line;
        while ((line = reader.ReadLine()) != null)
        {var parts = line.Split(' ');
            var word = parts[0];
            var vector = parts.Skip(1).Select(float.Parse).ToArray();
            wordVectors[word] = vector;
        }
    }
    return wordVectors;
}

直接使用字典存储向量可能导致内存浪费，尤其是当向量维度固定时。我们可以使用二维数组或内存池来优化存储：

public class VectorStore
{private readonly float[][] _vectors;
    private readonly Dictionary<string, int> _wordIndex;

    public VectorStore(Dictionary<string, float[]> wordVectors)
    {_wordIndex = new Dictionary<string, int>();
        _vectors = new float[wordVectors.Count][];
        int index = 0;
        foreach (var kvp in wordVectors)
        {_wordIndex[kvp.Key] = index;
            _vectors[index] = kvp.Value;
            index++;
        }
    }

    public float[] GetVector(string word)
    {return _wordIndex.TryGetValue(word, out int index) ? _vectors[index] : null;
    }
}

计算余弦相似度时，可以使用 SIMD 指令加速点积和范数计算：

public static float CosineSimilarity(float[] a, float[] b)
{if (a.Length != b.Length)
        throw new ArgumentException("Vectors must be of the same length");

    float dot = 0.0f, normA = 0.0f, normB = 0.0f;
    for (int i = 0; i < a.Length; i++)
    {dot += a[i] * b[i];
        normA += a[i] * a[i];
        normB += b[i] * b[i];
    }
    return dot / (float)(Math.Sqrt(normA) * Math.Sqrt(normB));
}

// SIMD 优化版本
public static unsafe float CosineSimilaritySimd(float[] a, float[] b)
{if (a.Length != b.Length)
        throw new ArgumentException("Vectors must be of the same length");

    int length = a.Length;
    float dot = 0.0f, normA = 0.0f, normB = 0.0f;
    fixed (float* aPtr = a, bPtr = b)
    {for (int i = 0; i < length; i += Vector<float>.Count)
        {var va = new Vector<float>(aPtr + i);
            var vb = new Vector<float>(bPtr + i);
            dot += Vector.Dot(va, vb);
            normA += Vector.Dot(va, va);
            normB += Vector.Dot(vb, vb);
        }
    }
    return dot / (float)(Math.Sqrt(normA) * Math.Sqrt(normB));
}

随着词向量数量的增加，线性扫描的查询延迟会显著上升。以下是不同数据规模下的查询延迟测试结果（单位：毫秒）：

词向量数量	线性扫描	近似最近邻
10,000	1.2	0.8
100,000	12.5	2.1
1,000,000	125.0	5.3

对于大规模词向量库，可以使用近似最近邻算法（如 Annoy 或 FAISS）来加速查询。以下是一个简单的 Annoy 实现示例：

public class AnnoyIndex
{
    private readonly AnnoyIndex<string, float, Euclidean, float> _index;

    public AnnoyIndex(int dimensions, string filePath)
    {_index = new AnnoyIndex<string, float, Euclidean, float>(dimensions);
        _index.Load(filePath);
    }

    public IEnumerable<string> GetNearestNeighbors(string word, int k)
    {var vector = GetVector(word);
        if (vector == null) return Enumerable.Empty<string>();
        return _index.GetNearest(vector, k).Select(item => item.Item1);
    }
}

浮点数计算可能引入精度误差，尤其是在归一化和相似度计算时。建议使用 double 类型进行中间计算，最后再转换为float。

在多线程环境中，确保向量存储和查询操作是线程安全的。可以使用 ConcurrentDictionary 或读写锁：

private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();

public float[] GetVectorThreadSafe(string word)
{_lock.EnterReadLock();
    try
    {return _wordIndex.TryGetValue(word, out int index) ? _vectors[index] : null;
    }
    finally
    {_lock.ExitReadLock();
    }
}

生产环境中，大规模词向量库可能占用大量内存。可以考虑以下优化：