PyTorch计算局部相关性矩阵

最新推荐文章于 2024-06-30 17:02:51 发布
最新推荐文章于 2024-06-30 17:02:51 发布
阅读量3.5k 收藏 7
点赞数 2
分类专栏： # Pytorch实践 文章标签： pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/P_LarT/article/details/101353899
版权

文章目录

代码文档：https://github.com/lartpang/mypython/blob/master/2019-09-25%E8%AE%A1%E7%AE%97%E5%B1%80%E9%83%A8%E7%9B%B8%E5%85%B3%E6%80%A7%E7%9F%A9%E9%98%B5/%E8%AE%A1%E7%AE%97%E5%B1%80%E9%83%A8%E7%9B%B8%E5%85%B3%E6%80%A7.ipynb

问题说明

对于给定的数据，其尺寸为N,C,H,W，现在想要计算其局部的相关性，也就是说特定尺寸范围内，例如2x2大小的区域内任意两点之间的点积。

试写出相关的代码。

问题分析

计算局部相关性，而且这里也提到是说使用局部的区域的任意两点之间的点积来计算，所以实际上也就是需要就算对应的2*2范围内的任意两个C维矢量的点积，最终得到一个4*4的关系矩阵。若是在矢量点积的时候，除以各自的模，那么实际上计算的就是两个矢量的余弦距离。

余弦相似度用向量空间中两个向量夹角的余弦值作为衡量两个个体间差异的大小。相比距离度量，余弦相似度更加注重两个向量在方向上的差异，而非距离或长度上。
https://blog.csdn.net/weixin_38659482/article/details/85045537

c o s < x ⃗ , y ⃗ > = x ⃗ ⋅ y ⃗ ∣ ∣ x ⃗ ∣ ∣ ⋅ ∣ ∣ y ⃗ ∣ ∣ = x ⃗ ∣ ∣ x ⃗ ∣ ∣ ⋅ y ⃗ ∣ ∣ y ⃗ ∣ ∣ cos<\vec{x}, \vec{y}> = \frac{\vec{x} \cdot \vec{y}}{||\vec{x}|| \cdot ||\vec{y}||} = \frac{\vec{x} }{||\vec{x}||} \cdot \frac{\vec{y}}{||\vec{y}||} cos<x ,y ​>=∣∣x ∣∣⋅∣∣y ​∣∣x ⋅y ​​=∣∣x ∣∣x ​⋅∣∣y ​∣∣y ​​

所以“除以模”这个归一化操作放在点积之前。实际上也就是除以沿着C维度计算的L2范数。

最直接的思路是简单的遍历计算，但是不实际，太耗时。如何能够利用GPU并行计算的优势，那自然是使用矩阵操作。

对于已有的N,C,H,W的数据，我们需要计算点积，对于三维以上的点积，可以使用torch.matmul，这时，乘法发生在最右侧的几个维度上。

可以构想，我们最终得到的结果应该是N * NumOfRegions * 4 * 4大小的一个张量。而这里的NumOfRegions表示总的计算了的区域的数量。对于pytorch，我所知道的可以收集区域数据，而且没有其他多余操作的方法只有torch.nn.Unfold。所以这里使用它来实现这个过程。

实现过程

对于矩阵乘法，思考的最简单的方式就是维度匹配。

import torch
import torch.nn as nn

a = torch.rand(1, 2, 3, 4)
b = torch.rand(1, 2, 3, 4)
print("a=>\n", a)
print("b=>\n", b)

a=>
 tensor([[[[0.4818, 0.9888, 0.8039, 0.7089],
          [0.7667, 0.2273, 0.9956, 0.4739],
          [0.9515, 0.1896, 0.7928, 0.0173]],

         [[0.1723, 0.8767, 0.4832, 0.6515],
          [0.9487, 0.6301, 0.5711, 0.7781],
          [0.2017, 0.9220, 0.2793, 0.2675]]]])
b=>
 tensor([[[[0.1417, 0.3510, 0.1170, 0.1698],
          [0.4311, 0.1535, 0.6087, 0.6646],
          [0.1880, 0.4103, 0.0289, 0.1094]],

         [[0.3398, 0.8751, 0.8299, 0.3514],
          [0.0333, 0.2831, 0.8086, 0.0514],
          [0.3168, 0.2895, 0.5107, 0.4949]]]])

这里先定义两个tensor，二者实际上没有关系，后面的计算也没有关系，只是为了多展示一点。

unfold_func = nn.Unfold(2, 1, 0, 1)

unfold_a = unfold_func(a)
print("unfold_a=>\n", unfold_a)

unfold_b = unfold_func(b)
print("unfold_b=>\n", unfold_b)

unfold_a=>
 tensor([[[0.4818, 0.9888, 0.8039, 0.7667, 0.2273, 0.9956],
         [0.9888, 0.8039, 0.7089, 0.2273, 0.9956, 0.4739],
         [0.7667, 0.2273, 0.9956, 0.9515, 0.1896, 0.7928],
         [0.2273, 0.9956, 0.4739, 0.1896, 0.7928, 0.0173],
         [0.1723, 0.8767, 0.4832, 0.9487, 0.6301, 0.5711],
         [0.8767, 0.4832, 0.6515, 0.6301, 0.5711, 0.7781],
         [0.9487, 0.6301, 0.5711, 0.2017, 0.9220, 0.2793],
         [0.6301, 0.5711, 0.7781, 0.9220, 0.2793, 0.2675]]])
unfold_b=>
 tensor([[[0.1417, 0.3510, 0.1170, 0.4311, 0.1535, 0.6087],
         [0.3510, 0.1170, 0.1698, 0.1535, 0.6087, 0.6646],
         [0.4311, 0.1535, 0.6087, 0.1880, 0.4103, 0.0289],
         [0.1535, 0.6087, 0.6646, 0.4103, 0.0289, 0.1094],
         [0.3398, 0.8751, 0.8299, 0.0333, 0.2831, 0.8086],
         [0.8751, 0.8299, 0.3514, 0.2831, 0.8086, 0.0514],
         [0.0333, 0.2831, 0.8086, 0.3168, 0.2895, 0.5107],
         [0.2831, 0.8086, 0.0514, 0.2895, 0.5107, 0.4949]]])

这里使用fold和unfold操作之后可以看出来，外侧的括号从原来的四层变为了现在的三层，实际上表示的就是从原来的N,C,H,W变成了现在的N,C*4,H/2*W/2的样子。

而对于H/2*W/2的维度上，在滑窗处理时，也是基于行主序调整成一行的。

unfold_a_reshape = unfold_a.transpose(1, 2).view(1, (3-1)*(4-1), 2, 4)  # N,H'W',C,2*2
print("unfold_a_reshape=>\n", unfold_a_reshape)

unfold_b_reshape = unfold_b.transpose(1, 2).view(1, (3-1)*(4-1), 2, 4)
print("unfold_b_reshape=>\n", unfold_b_reshape)

unfold_a_reshape=>
 tensor([[[[0.4818, 0.9888, 0.7667, 0.2273],
          [0.1723, 0.8767, 0.9487, 0.6301]],

         [[0.9888, 0.8039, 0.2273, 0.9956],
          [0.8767, 0.4832, 0.6301, 0.5711]],

         [[0.8039, 0.7089, 0.9956, 0.4739],
          [0.4832, 0.6515, 0.5711, 0.7781]],

         [[0.7667, 0.2273, 0.9515, 0.1896],
          [0.9487, 0.6301, 0.2017, 0.9220]],

         [[0.2273, 0.9956, 0.1896, 0.7928],
          [0.6301, 0.5711, 0.9220, 0.2793]],

         [[0.9956, 0.4739, 0.7928, 0.0173],
          [0.5711, 0.7781, 0.2793, 0.2675]]]])
unfold_b_reshape=>
 tensor([[[[0.1417, 0.3510, 0.4311, 0.1535],
          [0.3398, 0.8751, 0.0333, 0.2831]],

         [[0.3510, 0.1170, 0.1535, 0.6087],
          [0.8751, 0.8299, 0.2831, 0.8086]],

         [[0.1170, 0.1698, 0.6087, 0.6646],
          [0.8299, 0.3514, 0.8086, 0.0514]],

         [[0.4311, 0.1535, 0.1880, 0.4103],
          [0.0333, 0.2831, 0.3168, 0.2895]],

         [[0.1535, 0.6087, 0.4103, 0.0289],
          [0.2831, 0.8086, 0.2895, 0.5107]],

         [[0.6087, 0.6646, 0.0289, 0.1094],
          [0.8086, 0.0514, 0.5107, 0.4949]]]])

这里调整一下形状，这里可以根据维度匹配的思想进行连接，这里就是为了方便通过后面的矩阵乘法实现对于区域内任意点关系的描述矩阵的构造。

mm_unfold_a = torch.matmul(unfold_a_reshape.transpose(2, 3), unfold_a_reshape)  # N,H'W',2*2,2*2
print("mm_unfold_a=>\n", mm_unfold_a)

mm_unfold_b = torch.matmul(unfold_b_reshape.transpose(2, 3), unfold_b_reshape)
print("mm_unfold_b=>\n", mm_unfold_b)
mm_unfold_a=>
 tensor([[[[0.2619, 0.6275, 0.5329, 0.2181],
          [0.6275, 1.7462, 1.5898, 0.7771],
          [0.5329, 1.5898, 1.4878, 0.7720],
          [0.2181, 0.7771, 0.7720, 0.4487]],

         [[1.7462, 1.2184, 0.7771, 1.4851],
          [1.2184, 0.8796, 0.4871, 1.0763],
          [0.7771, 0.4871, 0.4487, 0.5862],
          [1.4851, 1.0763, 0.5862, 1.3174]],

         [[0.8796, 0.8847, 1.0763, 0.7569],
          [0.8847, 0.9270, 1.0779, 0.8429],
          [1.0763, 1.0779, 1.3174, 0.9163],
          [0.7569, 0.8429, 0.9163, 0.8301]],

         [[1.4878, 0.7720, 0.9209, 1.0200],
          [0.7720, 0.4487, 0.3433, 0.6240],
          [0.9209, 0.3433, 0.9459, 0.3664],
          [1.0200, 0.6240, 0.3664, 0.8860]],

         [[0.4487, 0.5862, 0.6240, 0.3562],
          [0.5862, 1.3174, 0.7153, 0.9488],
          [0.6240, 0.7153, 0.8860, 0.4078],
          [0.3562, 0.9488, 0.4078, 0.7065]],

         [[1.3174, 0.9163, 0.9488, 0.1700],
          [0.9163, 0.8301, 0.5930, 0.2164],
          [0.9488, 0.5930, 0.7065, 0.0884],
          [0.1700, 0.2164, 0.0884, 0.0719]]]])
mm_unfold_b=>
 tensor([[[[0.1355, 0.3471, 0.0724, 0.1180],
          [0.3471, 0.8891, 0.1805, 0.3017],
          [0.0724, 0.1805, 0.1869, 0.0756],
          [0.1180, 0.3017, 0.0756, 0.1037]],

         [[0.8891, 0.7674, 0.3017, 0.9213],
          [0.7674, 0.7025, 0.2530, 0.7424],
          [0.3017, 0.2530, 0.1037, 0.3224],
          [0.9213, 0.7424, 0.3224, 1.0244]],

         [[0.7025, 0.3115, 0.7424, 0.1204],
          [0.3115, 0.1523, 0.3875, 0.1309],
          [0.7424, 0.3875, 1.0244, 0.4461],
          [0.1204, 0.1309, 0.4461, 0.4443]],

         [[0.1869, 0.0756, 0.0916, 0.1865],
          [0.0756, 0.1037, 0.1186, 0.1450],
          [0.0916, 0.1186, 0.1357, 0.1689],
          [0.1865, 0.1450, 0.1689, 0.2522]],

         [[0.1037, 0.3224, 0.1450, 0.1490],
          [0.3224, 1.0244, 0.4839, 0.4306],
          [0.1450, 0.4839, 0.2522, 0.1597],
          [0.1490, 0.4306, 0.1597, 0.2616]],

         [[1.0244, 0.4461, 0.4306, 0.4668],
          [0.4461, 0.4443, 0.0455, 0.0982],
          [0.4306, 0.0455, 0.2616, 0.2559],
          [0.4668, 0.0982, 0.2559, 0.2569]]]])

这里计算了乘法，实际上结果计算出来的就是对应的关系矩阵。这里结果的尺寸为N, NumOfRegion, 2*2, 2*2。（这里没有计算范数，实际上应该除以范数）

a_ = a[0, :2, :2, :2]
b_ = b[0, :2, :2, :2]

print(a_.shape, b_.shape)

a_ = a_.reshape(1, 2, 2*2)  # N,C,2*2
b_ = b_.reshape(1, 2, 2*2)

print("torch.matmul(a_.t, a_)=>\n", torch.matmul(a_.transpose(1, 2), a_))
print("torch.matmul(b_.t, b_)=>\n", torch.matmul(b_.transpose(1, 2), b_))

print(torch.matmul(a_.transpose(1, 2), a_)[0] == mm_unfold_a[0, 0])
print(torch.matmul(b_.transpose(1, 2), b_)[0] == mm_unfold_b[0, 0])
torch.Size([2, 2, 2]) torch.Size([2, 2, 2])
torch.matmul(a_.t, a_)=>
 tensor([[[0.2619, 0.6275, 0.5329, 0.2181],
         [0.6275, 1.7462, 1.5898, 0.7771],
         [0.5329, 1.5898, 1.4878, 0.7720],
         [0.2181, 0.7771, 0.7720, 0.4487]]])
torch.matmul(b_.t, b_)=>
 tensor([[[0.1355, 0.3471, 0.0724, 0.1180],
         [0.3471, 0.8891, 0.1805, 0.3017],
         [0.0724, 0.1805, 0.1869, 0.0756],
         [0.1180, 0.3017, 0.0756, 0.1037]]])
tensor([[True, True, True, True],
        [True, True, True, True],
        [True, True, True, True],
        [True, True, True, True]])
tensor([[True, True, True, True],
        [True, True, True, True],
        [True, True, True, True],
        [True, True, True, True]])

从这里可以看出来，通过fold、reshape（view）、matmul实现了对于N,C,H,W形状的数据的局部（这里对应为滑窗操作的kernel_size）关联矩阵的计算，而且速度又快（相较于最原始朴素的“滑窗式”计算方法）。

对于运算过程代码的书写，这里验证了一个想法，简单的按照矩阵的维度匹配的原则，是可以直接写出来这个局部关系矩阵的：

N,C,H,W --(Ws*Ws)--> 
N,C*Ws*Ws,H/Ws*W/Ws --> 
N,H/Ws*W/Ws,C*Ws*Ws --> 
N,H/Ws*W/Ws,C*Ws*Ws --> 
N,H/Ws*W/Ws,C,Ws*Ws --> 
N,H/Ws*W/Ws,Ws*Ws,Ws*Ws

这里的H/Ws*W/Ws实际上反映出来的是分块的数量，这里直接使用除法对应的是滑窗大小正好可以被数据长宽整除，同时步长等于滑窗大小，没有padding的情况。

前面给出的代码中可以看出来，这里的值对于步长为1的时候，是需要进行调整的。

unfold_func = nn.Unfold(2, 1, 0, 1)
...
unfold_a_reshape = unfold_a.transpose(1, 2).view(1, (3-1)*(4-1), 2, 4)
有为少年
关注
专栏目录
pytorch用矩阵运算方法得到向量/矩阵间的相似度
羊城迷鹿的博客
07-27 4288
引入包及生成数据 ... from torch import cosine_similarity from scipy.stats import pearsonr 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.,
PyTorch深度学习实战（31）——神经风格迁移
盼小辉丶的博客
12-29 3497
神经风格迁移 (Neural Style Transfer) 是一种基于深度学习的技术，用于将两个不同图像的风格进行合成，生成新的图像。它通过将一个参考图像的风格应用于另一个内容图像，以创造出独特而富有艺术感的合成图像。在本节中，首先介绍了神经风格迁移的核心思想与风格迁移图像的生成流程，然后利用 PyTorch 从零开始实现了神经风格迁移算法，可以通过修改模型中的超参数来生成不同观感的图像。
使用pytorch计算图像的Affinity Matrix
haohulala的博客
11-10 3021
什么是Affinity Matrix affinity matrix翻译过来是相关性矩阵，实际上就是计算图像中每个点与其他所有点的相关性 假设我们有一个三通道的图像，长为H，宽为W，那么每个像素点都是由3个分量构成的向量，我们可以计算任意两个点之间的向量的余弦值 cos<a⃗,b⃗>=a⃗∗b⃗∣a⃗∣∗∣b⃗∣ cos<\vec{a}, \vec{b}>=\frac {\vec{a}*\vec{b}} {\mid \vec{a} \mid * \mid \vec{b} \mid}
Pytorch相关函数详解
Wenrui Xie的博客
02-15 1447
一、backward() pytorch中的自动求导函数。一个神经网络有N个样本，经过这个网络把N个样本分为M类，那么此时backward参数的维度应该是【N *M】。正常来说backward（）函数是不需要传入函数的，有时候也需要传入参数，现在来了解backward()需要传入的参数具体含义。 不需要传入参数的例子 如果out.backward()中的out是一个标量的话（相当于一个神经...
Pytorch—tensor相关运算
weixin_54627824的博客
11-08 963
torch.cat((x,x),dim=1) #1是横轴。#0表示横向切一刀，1表示纵向切一刀。# dim为1表示行，0表示列。
pytorch相关
weixin_41169280的博客
03-23 1171
1、nn.Sequential（） nn.Sequential( nn.Conv1d(6, self.base_plane, kernel_size=7, stride=2, padding=3, bias=False),nn.BatchNorm1d(self.base_plane), nn.ReLU(inplace=True), ) 一个有序的容器，神经网络模块将按照在传入构造器的顺序依次被添加到计算图中执行，同时以神经网络模块为元素的有序字典也可以作为传入参数 nn.Sequential里面的模块按照
二）PyTorch入门基础串讲（二）
Engineering_的博客
04-10 308
这里的Q虽然是n×n的，但是当把Q的特征值从大到小排列会发现里边有些数是非常小的，这些维度的能量小，很可能是造成，这些特征就可以。matplotlib里，用户绘图可以通过plt这个对象来绘图，在visdom中，同样需要一个绘图对象，我们通过。使用序列的方法完成对网络的定义，串联起来或者采用字典的结构，类似sklearn中的pipline。完成对模型的保存和加载，比如网络要迭代10万次，我们要每1万次保存参数，用以上的方法。dropout在训练和推理时的参数是不一样的，因此训练和推理时要指定不同的参数。
PyTorch笔记 - Attention Is All You Need (4)
Mystra
08-05 694
PyTorch中，CrossEntropy的输入，期望Class放在第2维，Batch放在第1维，可以是类别索引(Class indices)，也可以是类别的概率(Probabilities for each class)。reduction默认是mean，例如6个单词的平均交叉熵。reduction是none，默认交叉熵：先做softmax，再做-ln(prob)，每个rand之前，都需要添加。......
pytorch 矩阵计算
廷益_飞鸟的博客
09-30 1090
矩阵基础计算 A = torch.arange(12).reshape(4,3) print(A) # 转置 print(A.T)
【论文整理】风格迁移中格拉姆矩阵（Gram Matrix）的使用
weixin_47319327的博客
02-17 7093
Gram矩阵在风格迁移中的使用1、格拉姆矩阵的定义2、风格迁移的任务描述3、格拉姆矩阵的使用方法4、以一些论文举例格拉姆矩阵可以起到什么作用5、总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导
用pytorch及numpy计算成对余弦相似性矩阵，并用numpy实现kmeans聚类
Brikie的博客
07-28 1262
  sklearn和scipy里面都提供了kmeans聚类的库，但是它们都是根据向量直接进行计算欧氏距离、闵氏距离或余弦相似度，如果使用其他的度量函数或者向量维度非常高需要先计算好度量距离然后再聚类时，似乎这些库函数都不能直接实现，于是我用numpy自己写了一个，运行也非常快。这里记录下来以后备用： import numpy as np import matplotlib.pyplot as plt import time t0 = time.time() Num = 512 corr = np.load
Python--如何计算皮尔逊相关系数（Pearson correlation coefficient）
查数菇乐园
10-24 9896
皮尔逊系数 在统计学中，皮尔逊相关系数( Pearson correlation coefficient），又称皮尔逊积矩相关系数（Pearson product-moment correlation coefficient，简称 PPMCC或PCCs）。用于衡量两个变量X和Y之间的线性相关相关关系，值域在-1与1之间。 python计算方法 有三种方式 根据公式手写 def cal_pccs(x, y, n): """ warning: data format must be narra
推荐开源项目：PyTorch中的层级相关性传播实现
gitblog_00094的博客
06-25 421
推荐开源项目：PyTorch中的层级相关性传播实现 TorchLRPA PyTorch 1.6 implementation of Layer-Wise Relevance Propagation (LRP). 项目地址:https://gitcode.com/gh_mirrors/to/TorchLRP 在深度学习领域中，模型的可解释性一直是一个研究热点，尤其是在复杂网络结构下的决策过程解析上...
相似度矩阵遍历 python
jacke121的专栏
09-30 2073
相似度矩阵结果遍历 向量： tensor([[0.4284, 0.7538, 0.4982], [0.8600, 0.0694, 0.5055]], dtype=torch.float64) 相似度矩阵： 因为是笛卡尔积，结果有一半多是重复的： tensor([[1.0000, 0.6726], [0.6726, 1.0000]], dtype=torch.float64) 0 1 tensor(0.6726, dtype=torch.float64) 相似度归一...
【Pytorch】三大相关系数及在pytorch中的计算
qq_42203652的博客
10-22 4876
三大相关系数及在pytorch中的计算
pytorch学习6-矩阵计算
tyutwuxuan的博客
07-04 74
梯度指向值变化的最大的方向。
『NLP学习笔记』TextCNN文本分类原理及Pytorch实现
AI新视界
12-04 1251
卷积神经网络的核心思想是捕捉局部特征，对于文本来说，局部特征就是由若干单词组成的滑动窗口，类似于N-gram。卷积神经网络的优势在于能够自动地对N-gram特征进行组合和筛选，获得不同抽象层次的语义信息。
基于深度学习的短时交通流预测与优化
热门推荐
CSDNXUXIAOYAO的博客
02-13 1万+
基于深度学习的短时交通流预测与优化摘要第一章 背景介绍第二章 数据预处理与短时交通流量特性分析2.1 数据来源2.3 短时交通流特性分析2.3.1 基于K-means的差异性分析2.3.2 基于变化率趋势的时间邻近性分析2.3.3 基于相关系数的空间关联性分析2.3.4 基于天气因素的随机性分析2.4 短时交通流量预测结果评估指标第三章 基于时空关联的短时交通流预测3.1 基于时空关联LSTM的交通流预测模型框架3.2 实验设计与结果分析3.2.1 相关系数权重计算结果第四章 引入天气因素的短时交通流预测4
多视图完整空间与局部相关性分析
最新发布
...
06-30 680
多视图完整空间与局部相关性分析（MISLC）是一种无监督的多视图学习方法，旨在为多视图数据，并且揭示这些特征表示间的局部相关性信息。该方法通过考虑每个原始样本的多视图特征集合，构建基于集合的近邻图，并最大化这些潜在特征表示间的相关性，从而提高了模型的分类性能。以下是MISLC方法的详细介绍，包括计算步骤和涉及的公式。
python计算相关系数
jacke121的专栏
10-06 1万+
python计算相关系数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值