• 矩阵相似度的度量方法
万次阅读 多人点赞
2018-04-18 15:35:15

这个问题我也问过一些数学系的同学……这里我写了三种方法来度量。但某种度量的好坏……有点见仁见智了。

def mtx_similar1(arr1:np.ndarray, arr2:np.ndarray) ->float:
'''
计算矩阵相似度的一种方法。将矩阵展平成向量，计算向量的乘积除以模长。
注意有展平操作。
:param arr1:矩阵1
:param arr2:矩阵2
:return:实际是夹角的余弦值，ret = (cos+1)/2
'''
farr1 = arr1.ravel()
farr2 = arr2.ravel()
len1 = len(farr1)
len2 = len(farr2)
if len1 > len2:
farr1 = farr1[:len2]
else:
farr2 = farr2[:len1]

numer = np.sum(farr1 * farr2)
denom = np.sqrt(np.sum(farr1**2) * np.sum(farr2**2))
similar = numer / denom # 这实际是夹角的余弦值
return  (similar+1) / 2     # 姑且把余弦函数当线性

def mtx_similar2(arr1:np.ndarray, arr2:np.ndarray) ->float:
'''
计算对矩阵1的相似度。相减之后对元素取平方再求和。因为如果越相似那么为0的会越多。
如果矩阵大小不一样会在左上角对齐，截取二者最小的相交范围。
:param arr1:矩阵1
:param arr2:矩阵2
:return:相似度（0~1之间）
'''
if arr1.shape != arr2.shape:
minx = min(arr1.shape[0],arr2.shape[0])
miny = min(arr1.shape[1],arr2.shape[1])
differ = arr1[:minx,:miny] - arr2[:minx,:miny]
else:
differ = arr1 - arr2
numera = np.sum(differ**2)
denom = np.sum(arr1**2)
similar = 1 - (numera / denom)
return similar

def mtx_similar3(arr1:np.ndarray, arr2:np.ndarray) ->float:
'''
From CS231n: There are many ways to decide whether
two matrices are similar; one of the simplest is the Frobenius norm. In case
you haven't seen it before, the Frobenius norm of two matrices is the square
root of the squared sum of differences of all elements; in other words, reshape
the matrices into vectors and compute the Euclidean distance between them.
difference = np.linalg.norm(dists - dists_one, ord='fro')
:param arr1:矩阵1
:param arr2:矩阵2
:return:相似度（0~1之间）
'''
if arr1.shape != arr2.shape:
minx = min(arr1.shape[0],arr2.shape[0])
miny = min(arr1.shape[1],arr2.shape[1])
differ = arr1[:minx,:miny] - arr2[:minx,:miny]
else:
differ = arr1 - arr2
dist = np.linalg.norm(differ, ord='fro')
len1 = np.linalg.norm(arr1)
len2 = np.linalg.norm(arr2)     # 普通模长
denom = (len1 + len2) / 2
similar = 1 - (dist / denom)
return similar

def test_similar():
arr1 = np.array([[1,-2,3,7],[-8,2,5,9]])
arr2 = np.array([[1, -2, 3, 7], [-8, 2, 6, 9]])
arr3 = np.array([[-2, 3, 7], [2, 7, 9]])
arr4 = np.array([[4, -2, 3], [-8, 2, 7]])
print('similar arr1&2:', mtx_similar1(arr1, arr2),
mtx_similar2(arr1, arr2), mtx_similar3(arr1, arr2), sep=' ')
print('similar arr2&3:', mtx_similar1(arr2, arr3),
mtx_similar2(arr2, arr3), mtx_similar3(arr2, arr3), sep=' ')
print('similar arr2&4:', mtx_similar1(arr2, arr4),
mtx_similar2(arr2, arr4), mtx_similar3(arr2, arr4), sep=' ')
print('similar arr4&4:', mtx_similar1(arr4, arr4),
mtx_similar2(arr4, arr4), mtx_similar3(arr4, arr4), sep=' ')
更多相关内容
• 提供了3种矩阵相似度的度量方法。python。详见https://mp.csdn.net/mdeditor/79991322
• ## 矩阵相似度

万次阅读 2018-11-18 15:25:46
给出两幅相同大小的黑白图像（用 0-1 矩阵）表示，求它们的相似度。 说明：若两幅图像在相同位置上的像素点颜色相同，则称它们在该位置具有相同的像 素点。两幅图像的相似度定义为相同像素点数占总像素点数的...

D 矩阵相似

描述

给出两幅相同大小的黑白图像（用 0-1 矩阵）表示，求它们的相似度。
说明：若两幅图像在相同位置上的像素点颜色相同，则称它们在该位置具有相同的像
素点。两幅图像的相似度定义为相同像素点数占总像素点数的百分比。

输入

第一行包含一个整数 n，表示图像的行列数。1 <= n <= 100。
之后 n 行，每行 n 个整数 0 或 1，表示第一幅黑白图像上各像素点的颜色。相邻两个
数之间用单个空格隔开。
之后 n 行，每行 n 个整数 0 或 1，表示第二幅黑白图像上各像素点的颜色。相邻两个
数之间用单个空格隔开。

输出

一个实数，表示相似度（以百分比的形式给出），精确到小数点后两位。

（无提示）

代码如下：

#include<stdio.h>
int main()
{
int n,i,j,s,a[100][100],b[100][100];
s=0;
scanf("%d",&n);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&a[i][j]);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&b[i][j]);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
if(a[i][j]==b[i][j])
s++;
}
printf("%.2f",100.00*s/(n*n));
return 0;
}

运行结果如下：

总结：运用了数组循环语句以及if语句的判断；

是一个很有意思的小程序。

# ps:vc6.0

展开全文
• 利用神经网络基于矩阵相似度的图像体态识别.pdf
• 主要介绍了Java实现的计算稀疏矩阵余弦相似度功能,涉及java基于HashMap的数值计算相关操作技巧,需要的朋友可以参考下
• 计算图片相似度 均方误差、SSIM 结构相似性度量、cosine余弦距离、直方图、互信息、指纹 import numpy as np import matplotlib.pyplot as plt from skimage import data, img_as_float from skimage.metrics ...

## 计算图片相似度

均方误差、SSIM 结构相似性度量、cosine余弦距离、直方图、互信息、指纹

import numpy as np
import matplotlib.pyplot as plt

from skimage import data, img_as_float
from skimage.metrics import structural_similarity as ssim
from skimage.metrics import mean_squared_error

img = img_as_float(data.camera())
rows, cols = img.shape

noise = np.ones_like(img) * 0.2 * (img.max() - img.min())
rng = np.random.default_rng()
noise[rng.random(size=noise.shape) > 0.5] *= -1

img_noise = img + noise
img_const = img + abs(noise)

fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(10, 4),
sharex=True, sharey=True)
ax = axes.ravel()

mse_none = mean_squared_error(img, img)
ssim_none = ssim(img, img, data_range=img.max() - img.min())

mse_noise = mean_squared_error(img, img_noise)
ssim_noise = ssim(img, img_noise,
data_range=img_noise.max() - img_noise.min())

mse_const = mean_squared_error(img, img_const)
ssim_const = ssim(img, img_const,
data_range=img_const.max() - img_const.min())

ax[0].imshow(img, cmap=plt.cm.gray, vmin=0, vmax=1)
ax[0].set_xlabel(f'MSE: {mse_none:.2f}, SSIM: {ssim_none:.2f}')
ax[0].set_title('Original image')

ax[1].imshow(img_noise, cmap=plt.cm.gray, vmin=0, vmax=1)
ax[1].set_xlabel(f'MSE: {mse_noise:.2f}, SSIM: {ssim_noise:.2f}')
ax[1].set_title('Image with noise')

ax[2].imshow(img_const, cmap=plt.cm.gray, vmin=0, vmax=1)
ax[2].set_xlabel(f'MSE: {mse_const:.2f}, SSIM: {ssim_const:.2f}')
ax[2].set_title('Image plus constant')

plt.tight_layout()
plt.show()


## 参考资料

[1]. CSDN 计算两幅图像的相似度总结 https://blog.csdn.net/u010977034/article/details/82733137

[2]. scikit-image v0.19.0 官方文档 https://scikit-image.org/docs/stable/api/skimage.metrics.html#skimage.metrics

展开全文
• B.float() A, B (tensor([[7., 2., 5., 6., 3., 8., 7., 3., 6., 6.]]), tensor([[4., 4., 8., 6., 2., 3., 2., 5., 3., 6.]])) 余弦相似度 AA = F.normalize(A, p=2, dim=1) BB = F.normalize(B, p=2, dim=1) AA, ...

### 引入包及生成数据

...
from torch import cosine_similarity
from scipy.stats import pearsonr
from scipy.stats import spearmanr
import pandas as pd

A = torch.randint(10, (1,10))
B = torch.randint(10, (1,10))
A, B = A.float(), B.float()
A, B

(tensor([[7., 2., 5., 6., 3., 8., 7., 3., 6., 6.]]),
tensor([[4., 4., 8., 6., 2., 3., 2., 5., 3., 6.]]))


### 余弦相似度

AA = F.normalize(A, p=2, dim=1)
BB = F.normalize(B, p=2, dim=1)
AA, BB

(tensor([[0.3932, 0.1123, 0.2808, 0.3370, 0.1685, 0.4493, 0.3932, 0.1685, 0.3370,
0.3370]]),
tensor([[0.2703, 0.2703, 0.5406, 0.4054, 0.1351, 0.2027, 0.1351, 0.3379, 0.2027,
0.4054]]))

torch.mm(AA, BB.t())

tensor([[0.8539]])

cosine_similarity(A, B)

tensor([0.8539])


### Pearson相似度

AAA = F.normalize(A-A.mean(dim=1, keepdim=True), p=2, dim=1)
BBB = F.normalize(B-B.mean(dim=1, keepdim=True), p=2, dim=1)
AAA, BBB

(tensor([[ 0.2829, -0.5492, -0.0499,  0.1165, -0.3828,  0.4494,  0.2829, -0.3828,
0.1165,  0.1165]]),
tensor([[-0.0514, -0.0514,  0.6336,  0.2911, -0.3939, -0.2226, -0.3939,  0.1199,
-0.2226,  0.2911]]))

torch.mm(AAA, BBB.t())

tensor([[-0.0827]])

pearsonr(A.squeeze().numpy(), B.squeeze().numpy())

(-0.08265463405864518, 0.8204231681840923)


### Spearman相似度

这里需要注意一下，自己实现的版本和官方实现的版本有一个细微的不同，就是比如有两个值并列第二，官方的版本会将它们的排名统一设为2.5，而不是一个2一个3

A = torch.randint(5,100, (1,4))
B = torch.randint(5, 100, (1,4))
A, B = A.float(), B.float()
A, B

(tensor([[69., 68., 85., 44.]]), tensor([[29., 50., 17., 50.]]))


可以看到B里面有两个50，所以要去掉重复值，来让自己算的和官方算的输出结果一致

#### 方案一

B[0,1] = 55
AAAA = (torch.argsort(torch.argsort(A))).float()
BBBB = (torch.argsort(torch.argsort(B))).float()
AAAA, BBBB

(tensor([[2., 1., 3., 0.]]), tensor([[1., 3., 0., 2.]]))

n = A.shape[1]
1-(6*torch.sum((AAAA-BBBB)**2)/(n*(n**2-1)))

tensor(-0.8000)


#### 方案二

AAAA = F.normalize(AAAA-AAAA.mean(dim=1, keepdim=True), p=2, dim=1)
BBBB = F.normalize(BBBB-BBBB.mean(dim=1, keepdim=True), p=2, dim=1)

torch.mm(AAAA, BBBB.t())

tensor([[-0.8000]])


#### 方案三

spearmanr(A.numpy(), B.numpy(), axis=1)

SpearmanrResult(correlation=-0.7999999999999999, pvalue=0.20000000000000007)


#### 方案四

P = pd.DataFrame({'A':list(A.squeeze().numpy()), 'B':list(B.squeeze().numpy())})

P.corr('spearman', )

AB
A1.0-0.8
B-0.81.0
展开全文
• ## C语言 矩阵相似度

千次阅读 2018-11-14 16:26:29
矩阵相似度 给出两幅相同大小的黑白图像（用 0-1 矩阵）表示，求它们的相似度。 说明：若两幅图像在相同位置上的像素点颜色相同，则称它们在该位置具有相同的像 素点。两幅图像的相似度定义为相同像素点数占总像素...
• 方法用于度量两图像复数矩阵的结构相似度，采用包含 779 张失真图像的 LIVE 数据库以及相应的拟合函数验证了复数结构相 似度方法。交叉失真和分类失真图像测试实验表明，所提出的复数矩阵结构相似度方法的整体性能与...
• Let X be a Bxn numpy matrix, i.e.,import numpy as npB = 10n = 2X = np.random.random((B, n))Now, I'm interested in computing the so-called kernel (or even similarity) matrix K, which is of shape BxB, a...
• 余弦相似度用向量空间中两个向量夹角的余弦值作为衡量两个个体间差异的大小。余弦值越接近1，就表明夹角越接近0度，也就是两个向量越相似，这就叫"余弦相似性" 我们都学过向量的内积公式： 其中 aaa 和 bbb 可以...
• https://www.docin.com/p-1699190456.html 基于精确的点模式识别和TurningFunction的几何形状相似性判定问题 http://www.doc88.com/p-0952897045830.html 一种基于Fr_chet距离的复杂线状要素匹配方法_邵世维 ...
• 任务：现有特征矩阵X∈RN×FX\in R^{N\times F}X∈RN×F，N为样本个数，F为特征大小，需要计算相似度矩阵AAA，Aij=AjiA_{ij}=A_{ji}Aij​=Aji​为第i个样本和第j个样本的相似度，利用欧式距离求解两个样本间的距离：...
• 现有矩阵A∈RN×C,B∈RM×CA\in R^{N\times C}, B\in R^{M\times C}A∈RN×C,B∈RM×C，需要计算矩阵AAA和BBB的相似度（欧式距离）矩阵S∈RN×MS\in R^{N\times M}S∈RN×M，NNN和MMM很大。可以使用pytorch提供的...
• 每行是一个向量，计算之后对角线为1，其余为与其他向量的相似度： def csr_cosine_similarity(input_csr_matrix): similarity = input_csr_matrix * input_csr_matrix.T square_mag = similarity.diagonal() ...
• 计算物品之间的相似度矩阵 例如现在有A、B、C、D四个用户，分别对a、b、c、d、e五个物品表达了自己喜好程度（通过评分高低来表现自己的偏好程度高低），计算物品之间的相似度矩阵 算法 1、建立用户物品倒排表 A a b...
• 但我认为你最好使用方差 – 协方差矩阵.或相关矩阵,如果值的比例非常不同,比如说,而不是：>>> xarray([[5, 3, 0],[3, 0, 5],[5, 5, 0],[1, 1, 7]])你有：>>> xarray([[5, 300, 0],[3, 0, 5],[5, ...
• 如果两张图像的直方图一样，或者有极高的相似度，那么在一定程度上，可以认为这两幅图是一样的，这就是直方图比较的应用之一。通过默认的欧氏距离来比较直方图的相似性大小，值越小，两个图像的直方图越相似。 i1...
• 计算物品的相似度矩阵 例如现在有A、B、C、D四个用户，分别对a、b、c、d、e五个物品表达了自己喜好程度（通过评分高低来表现自己的偏好程度高低），计算物品之间的相似度矩阵 算法 1、建立用户物品倒排表 A a b d B...
• 注意：计算相似度时必须保证两个矩阵维度相同，否则报错 import torch from transformers import BertConfig, BertModel, BertTokenizer def bert_output(texts, name): tokens, segments, input_masks =[], [],...
• 本文是用Excel表格内的学科引用矩阵计算得到学科相似度，分为以下几个步骤： 第一步，读取Excel数据,返回行标签和列标签和内部的数值（n维数组）。 第二步，对数据按行进行计算相似度。 其中这里写了2个计算相似度的...
• 基于二维动态时间规整算法的矩阵相似性研究，李俊杰，高翠芳，在模式识别中距离作为一种常用的度量工具，被广泛应用于聚类、分类等算法中。随着矩阵样本的大量出现，以及样本内容的不断复杂化
• 使用pytorch直接计算矩阵各行向量间的相似度
• #导入 tensorflow 模块，因部分用到1.x版本的Tensorflow，因此用如下方式导入 import tensorflow.compat.v1 as tf ...# 定义余弦相似度函数，便于后续检验结果 def cos_sim(a, b): a_norm = np.linalg.
• 我有一个代码来计算两个矩阵之间的余弦相似性：def cos_cdist_1(matrix, vector):v = vector.reshape(1, -1)return sp.distance.cdist(matrix, v, 'cosine').reshape(-1)def cos_cdist_2(matrix1, matrix2):return ...
• import java.util.HashMap; import com.aliyun.odps.udf.UDF; /***  * BASE UDF  */ public final class MyUDF extends UDF {  /**  * UDF Evaluate接口 ... * UDF在记录层面上是一对一，字段上是一对
•  关于相似度的计算，现有的几种方法都是基于向量(Vector)的，其实也就是计算两个向量的距离，距离越近相似度越大。 在推荐场景中，在用户-物品偏好的二维矩阵中，我们可以将一个用户对所有物品的偏好...
• 如果有2个矩阵Y∈Rn×qY \in R^{n \times q}Y∈Rn×q 和 Z∈Rn×cZ \in R^{n \times c}Z∈Rn×c ,如何度量两个矩阵的相似性？ 回答 采用The Hilbert-Schmidt Independence Criterion (HSIC)进行度量。 HSIC(Z,Y)=(n...
• 向量与矩阵矩阵矩阵的余弦相似度 很简单，将公式套上就行了。 python 代码 import numpy as np a = np.array([[1, 2, 1, 2, 3, 5, 6, 2]]) b = np.array([ [1, 2, 1, 2, 3, 5, 6, 2], [1, 2, 1, 2, 3, 5,...

...