背景

比如在推荐系统，通过算法计算出数据在返回向量时，就需要比较向量之间的距离，来判断相似度。比如用tfidf计算两个文件之间的相似度。调用机器学习库会返回两个文件对应的关键词向量，需要计算两个向量之间的距离来判断两个文本的相似度。

在实际应用中可能是上千或上万个文档。我们可能需要指定一篇文档与其他文档的相似度，按分数从高到低排序，选出关联最强的文档作为推荐

先给出结论

矩阵计算性能要远远大于向量计算
以下实例均采用pyhon演示

向量表示方法

密集向量与稀疏向量
给定向量 (0.5,0,1)
密集向量表示方法 [0.5,0,1]
稀疏向量表示方法（3，[0,2]，[0.5,1]）第一个数字3 表示向量维度3，[0,2]表示向量在0，和2上有数据，[0.5,1] 表示数据并且与[0,2]对应。也就是说0,5在0号位，2在二号位。未表示出来的位置的数值是0

向量初始化方法

from pyspark.ml.linalg import SparseVector
SparseVector(3, [0,2], [0.5,1])

矩阵表示方法

矩阵有很多种表示方法这里只介绍csr_matrix表示方法
用网上的一个图来说明

image.png

图左边Matrix 是一个常规表示矩阵
图右边csr表示矩阵。
csr矩阵表示法中只表示矩阵的非0数值及位置，在矩阵中0值较多的情况下能节约空间。
values 表示矩阵中的非0数值。
row indices 表示列标：row indices数组的第一个位置的值表示values第一个数值列标，row indices数组的第二个位置的值表示values第二个数值列标依次类推
column indices 表示行标：column indices数组的第一个位置的值表示values第一个数值行标，column indices数组的第二个位置的值表示values第二个数值行标依次类推
对数值1 行标为0，列标也为0 所以矩阵00位置就是1
同理数值7 行标1 列标为0 所以矩阵的01位置就是7

from scipy.sparse import csr_matrix
mat = csr_matrix((data, (row_ind, col_ind)), shape=(M, N))

例如

from scipy.sparse import csr_matrix
mat = csr_matrix(([1,2,3,4], ([0,0,1,1],[0,1,0,1])), shape=(2, 2))
# mat.toarray() 结果：
array([[1, 2],
       [3, 4]], dtype=int64)

shape=(2,2) 表示 2x2的矩阵

SparseVector 向量转csr_matrix 矩阵

当然不会一个向量转成矩阵肯定是一组向量转矩阵

# 假如有一组向量
vertor_list = []
data = []
row_ind = []
col_ind = []
M = len(vertor_list)
N = 0

for i, v in enumerate(vertor_list):
    N = v.size # 向量的维度 也就是矩阵的列数 所有向量的维度应该一致
    row_ind.extend(N * [i]) # 列下表 每一行来说列下标一致 并且都是 偏移量i
    col_ind.extend(v.indices) # 行下标 与向量的行下标一致
    data.extend(v.values)

mat = csr_matrix((data, (row_ind, col_ind)), shape=(M, N))

这组向量中的维度一定要一致，比如都是2维向量。假如一组向量有些是2维向量有些是3维向量，不仅数据转换会出错并且二维向量与三维向量算相似度也没有意义

上述代码是把一组向量转成矩阵的方法比如
（0，1）
（0，2）
（1，2）
转成矩阵后:
[[0,1],
[0,2],
[1,2]]

如何用矩阵来代替向量的点乘呢？

比如有一组向量
（0，1）
（0，2）
（1，2）
现有向量(1,1)分别于这组向量计算点乘
(1,1) * (0,1) = 1 * 0 + 1 * 1
(1,1) * (0,2) = 1 * 0 + 1 * 2
(1,1) * (1,2) = 1 * 1 + 1 * 2
实际上这就是矩阵

[1,1] * [[0,0,1]
           [1,2,2]]

而矩阵

 [[0,0,1]
  [1,2,2]]

正好是矩阵

[[0,1],
[0,2],
[1,2]]

的转置
好了基础知识介绍完毕下面开始完成的测试代码了

测试代码

from pyspark.ml.linalg import SparseVector
import random
from scipy.sparse import csr_matrix
import time
# num 表示生产多少组向量，v表示向量的维度
def build_data(num, v):
  vertor_list = []
  for i in range(num):
    data = [random.random() for i in range(v)]
    verctor = SparseVector(v, [i for i in range(v)], data)
    vertor_list.append(verctor)

  data = []
  row_ind = []
  col_ind = []
  M = len(vertor_list)
  N = 0

  for i, v in enumerate(vertor_list):
    N = v.size
    row_ind.extend(N * [i])
    col_ind.extend(v.indices)
    data.extend(v.values)

  mat = csr_matrix((data, (row_ind, col_ind)), shape=(M, N))

  return vertor_list, mat

# 性能比较
v1_list, mat1 = build_data(100, 200)
v2_list, mat2 = build_data(2, 200)

result = []
start = time.time() * 1000
for v2 in v2_list:
  for v1 in v1_list:
    result.append(v2.dot(v1))
end = time.time() * 1000
print('向量计算耗时:' + str(end - start))

start = time.time() * 1000
a = mat2.dot(mat1.T)
end = time.time() * 1000
print('矩阵计算耗时:' + str(end - start))

一组比较结果

向量计算耗时:10.74658203125
矩阵计算耗时:0.9091796875

另一组比较

v1_list, mat1 = build_data(5000, 200)
v2_list, mat2 = build_data(500, 200)

向量计算耗时:152447.44384765625
矩阵计算耗时:1628.77685546875

5000个数据200维向量在任何公司都不能有这么小的数据量直接向量点成要2.5分钟，而矩阵相乘只需要1.6秒。直接向量点成不仅仅是效率低。而是一个不能接受的超长时间

余弦相似度说明

假如有向量A,B |A|=向量A的摸 |B|=向量B的摸
cos(A,B) = A * B / (|A|*|B|)
当|A| = 1 切 |B| = 1时有 cos(A,B) = A * B
所以在求的向量时先对向量进行正则化正则化后向量的摸为1，向量的点乘即可代表向量的余弦值

余弦相似度-矩阵比向量计算性能比较