计算两个矩阵的行向量之间的欧式距离

已于 2022-07-12 20:35:51 修改
阅读量2.6k 收藏 16
点赞数 1
分类专栏： 基础知识 文章标签： 矩阵 线性代数 python pytorch
于 2022-07-12 18:02:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lvdoujack/article/details/125747887
版权

1 问题描述

矩阵P的大小为[m, d]   用行向量表示为P1, P2,...,Pm

矩阵C的大小为[n, d]    用行向量表示为C1, C2,...,Cn

求矩阵P的每个行向量与矩阵C的每个行向量的欧氏距离

典型的例子是KNN算法应用于二维的点的聚类时，求取点与点之间的欧式距离时的情况。

2 解决办法1——两层循环

使用两层循环， 计算矩阵P的第i个行向量与矩阵C的第j个行向量的欧式距离

def l2distanceForMatrix_2loop(a, b):
    time1 = time.time()
    # 两层循环计算两个矩阵中每个样本之间的距离
    num_a = a.shape[0]
    num_b = b.shape[0]
    print(f"矩阵a数据的条数:{num_a}, 矩阵b数据的条数:{num_b}")
    distance = torch.zeros((num_a, num_b))
    for i in range(num_a):
        for j in range(num_b):
            # 首先做减法, 对应元素相减
            # 然后求平方
            # 再做加法
            # 最后开方
            # (x1, y1) 与 (x2, y2)的欧式距离:
            # sqrt( (x1-x2)^2 + (y1-y2)^2 )
            distance[i][j] = torch.sqrt(
                torch.sum(
                    torch.square(a[i] - b[j])
                )
            )
    time2 = time.time()
    print(f"花费时间:{time2 - time1}")
    print(distance)
    return distance

3 解决办法2——一层循环

计算矩阵P的第i个行向量与矩阵C的欧式距离

def l2distanceForMatrix_1loop(a, b):
    time1 = time.time()
    # 1层循环计算两个矩阵中每个样本之间的距离
    num_a = a.shape[0]
    num_b = b.shape[0]
    distance = torch.zeros((num_a, num_b))
    for i in range(num_a):
        # 矩阵a中第i个样本与矩阵b中的样本的欧式距离
        # temp = torch.square(a[i] - b)
        # print(temp.shape)
        # print(temp)
        # temp = torch.sum(temp, dim=1)
        # print(temp)
        # temp = torch.sqrt(temp)
        # print(temp)
        # distance[i] = temp
        distance[i] = torch.sqrt(
                torch.sum(
                    torch.square(a[i] - b),
                    dim=1
                )
            )
    time2 = time.time()
    print(f"花费时间:{time2 - time1}")
    print(distance)
    return distance

4 解决办法3——没有循环，使用矩阵运算

 

 

,

4.1 写法1

def l2distanceForMatrix(a, b):
    time1 = time.time()
    # 使用矩阵运算的方式求取两个矩阵中各个样本的欧式距离
    m = a.shape[0]
    n = b.shape[0]
    # 对矩阵的每个元素求平方
    aa = torch.pow(a, 2)   # [m, d]
    # 按行求和, 并且保留维度数量不变
    aa = torch.sum(aa, dim=1, keepdim=True)   # [m, 1]
    # 将矩阵aa从[m, 1]的形状扩展为[m, n]
    aa = aa.expand(m, n)   # [m, n]

    # 处理矩阵b
    bb = torch.pow(b, 2).sum(dim=1, keepdim=True).expand(n ,m)   # [n, m]
    bb = torch.transpose(bb, 0, 1)   # [m, n]

    # 计算第三项   [m, d] * [d, n] = [m, n]
    tail = 2 * torch.matmul(a, torch.transpose(b, 0, 1))

    # 计算最后的结果
    distance = torch.sqrt(aa + bb - tail)
    time2 = time.time()
    print(f"花费时间:{time2 - time1}")
    print(distance)
    return distance

4.2 写法2

def l2distanceForMatrix2(a, b):
    print("方法l2distanceForMatrix2")
    time1 = time.time()
    m = a.shape[0]
    n = b.shape[0]
    # 计算a*a^T
    matrix_a = torch.matmul(a, torch.transpose(a, 0, 1))
    matrix_b = torch.matmul(b, torch.transpose(b, 0, 1))
    # 取出matrix_a矩阵中的主对角线元素, 取出来的结果就是行向量的2范数
    diag_a = torch.diag(matrix_a)   # [m]
    # print(diag_a.shape)
    # 扩展维度
    aa = diag_a.unsqueeze(1)   # [m, 1]
    aa = aa.expand(m, n)   # [m, n]
    # print(aa.shape)
    # print(aa)

    # 同样的方法处理矩阵b
    diag_b = torch.diag(matrix_b)   # [n]
    diag_b = diag_b.unsqueeze(1)   # [n, 1]
    # 扩展维度
    bb = diag_b.expand(n, m)   # [n, m]
    # 转置
    bb = torch.transpose(bb, 0, 1)   # [m, n]
    # print(bb.shape)
    # print(bb)

    # 计算第三项   [m, d] * [d, n] = [m, n]
    tail = 2 * torch.matmul(a, torch.transpose(b, 0, 1))

    # 计算最后的结果
    distance = torch.sqrt(aa + bb - tail)
    time2 = time.time()
    print(f"花费时间:{time2 - time1}")
    print(distance)
    return distance

5 测试代码

import os
import torch
import torch.nn as nn
import time

def l2distanceForMatrix_2loop(a, b):
    time1 = time.time()
    # 两层循环计算两个矩阵中每个样本之间的距离
    num_a = a.shape[0]
    num_b = b.shape[0]
    print(f"矩阵a数据的条数:{num_a}, 矩阵b数据的条数:{num_b}")
    distance = torch.zeros((num_a, num_b))
    for i in range(num_a):
        for j in range(num_b):
            # 首先做减法, 对应元素相减
            # 然后求平方
            # 再做加法
            # 最后开方
            # (x1, y1) 与 (x2, y2)的欧式距离:
            # sqrt( (x1-x2)^2 + (y1-y2)^2 )
            distance[i][j] = torch.sqrt(
                torch.sum(
                    torch.square(a[i] - b[j])
                )
            )
    time2 = time.time()
    print(f"花费时间:{time2 - time1}")
    print(distance)
    return distance

def l2distanceForMatrix_1loop(a, b):
    time1 = time.time()
    # 1层循环计算两个矩阵中每个样本之间的距离
    num_a = a.shape[0]
    num_b = b.shape[0]
    distance = torch.zeros((num_a, num_b))
    for i in range(num_a):
        # 矩阵a中第i个样本与矩阵b中的样本的欧式距离
        # temp = torch.square(a[i] - b)
        # print(temp.shape)
        # print(temp)
        # temp = torch.sum(temp, dim=1)
        # print(temp)
        # temp = torch.sqrt(temp)
        # print(temp)
        # distance[i] = temp
        distance[i] = torch.sqrt(
                torch.sum(
                    torch.square(a[i] - b),
                    dim=1
                )
            )
    time2 = time.time()
    print(f"花费时间:{time2 - time1}")
    print(distance)
    return distance


def l2distanceForMatrix(a, b):
    print("方法l2distanceForMatrix")
    time1 = time.time()
    # 使用矩阵运算的方式求取两个矩阵中各个样本的欧式距离
    m = a.shape[0]
    n = b.shape[0]
    # 对矩阵的每个元素求平方
    aa = torch.pow(a, 2)   # [m, d]
    # 按行求和, 并且保留维度数量不变
    aa = torch.sum(aa, dim=1, keepdim=True)   # [m, 1]
    # 将矩阵aa从[m, 1]的形状扩展为[m, n]
    aa = aa.expand(m, n)   # [m, n]
    # print(aa.shape)
    # print(aa)

    # 处理矩阵b
    bb = torch.pow(b, 2).sum(dim=1, keepdim=True).expand(n ,m)   # [n, m]
    bb = torch.transpose(bb, 0, 1)   # [m, n]
    # print(bb.shape)
    # print(bb)

    # 计算第三项   [m, d] * [d, n] = [m, n]
    tail = 2 * torch.matmul(a, torch.transpose(b, 0, 1))

    # 计算最后的结果
    distance = torch.sqrt(aa + bb - tail)
    time2 = time.time()
    print(f"花费时间:{time2 - time1}")
    print(distance)
    return distance


def l2distanceForMatrix2(a, b):
    print("方法l2distanceForMatrix2")
    time1 = time.time()
    m = a.shape[0]
    n = b.shape[0]
    # 计算a*a^T
    matrix_a = torch.matmul(a, torch.transpose(a, 0, 1))
    matrix_b = torch.matmul(b, torch.transpose(b, 0, 1))
    # 取出matrix_a矩阵中的主对角线元素, 取出来的结果就是行向量的2范数
    diag_a = torch.diag(matrix_a)   # [m]
    # print(diag_a.shape)
    # 扩展维度
    aa = diag_a.unsqueeze(1)   # [m, 1]
    aa = aa.expand(m, n)   # [m, n]
    # print(aa.shape)
    # print(aa)

    # 同样的方法处理矩阵b
    diag_b = torch.diag(matrix_b)   # [n]
    diag_b = diag_b.unsqueeze(1)   # [n, 1]
    # 扩展维度
    bb = diag_b.expand(n, m)   # [n, m]
    # 转置
    bb = torch.transpose(bb, 0, 1)   # [m, n]
    # print(bb.shape)
    # print(bb)

    # 计算第三项   [m, d] * [d, n] = [m, n]
    tail = 2 * torch.matmul(a, torch.transpose(b, 0, 1))

    # 计算最后的结果
    distance = torch.sqrt(aa + bb - tail)
    time2 = time.time()
    print(f"花费时间:{time2 - time1}")
    print(distance)
    return distance


def main():
    # a = torch.randn((600, 2))
    # b = torch.randn((600, 2))
    a = torch.tensor(
            [
                [1, 2],
                [3, 4],
                [5, 6],
                [7, 8],
                [9, 10]
            ]
        ).float()
    b = torch.tensor(
            [
                [3, 4],
                [5, 6],
                [7, 8],
                [9, 10]
            ]
        ).float()
    l2distanceForMatrix_2loop(a, b)
    l2distanceForMatrix_1loop(a, b)
    l2distanceForMatrix(a, b)
    l2distanceForMatrix2(a, b)


if __name__ == "__main__":
    main()

6 参考

计算两个矩阵之间的欧式距离_frankzd的博客-CSDN博客_两个矩阵的欧式距离

快速计算矩阵之间的欧式距离_SP FA的博客-CSDN博客_计算两个矩阵的欧式距离

RSMung
关注
  • 1
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
28、欧几里得距离计算和余弦距离计算
sxj731533730
01-16 1959
基本思想:求一组样本点到一组向量的最短距离，并且输出其距离信息 样本向量点 已知的样本：A={x1 y1x2 y2}已知的向量：B={x3 y3x4 y4}已知的样本： A=\left\{ \begin{matrix} x_1\ y_1 \\ x_2\ y_2 \\ \end{matrix} \right\} \\ 已知的向量：B= \left\{ \begin{matrix} x_3\ y_3 \\ x_4\
通过CUDA实现计算向量到矩阵每一行的欧式距离
12-06
本文通过cuda实现计算向量a（n维）到矩阵b（n*n）的欧式距离，将结果输出到向量c（n维）中。本文主要采用cuda+c语言实现，代码经过调试。
PtTorch | torch.square
W1995S的博客
04-11 6812
torch.square（input，*，out = None）→张量 返回带有输入元素平方的新张量。 参数 输入（张量）–输入张量。 关键字参数 out（张量，可选）–输出张量。 例子： >>> a = torch.randn(4) >>> a tensor([-2.0755, 1.0226, 0.0831, 0.4806]) >>> torch.square(a) tensor([ 4.3077, 1.0457,
《数据挖掘基础》习题五
lazyn的博客
07-13 6543
2.简单地描述下列英文缩写的含义。 （1）PAM（2）STING（3）DBSCAN （1）PAM（Partitioning Around Medoid），围绕中心点的划分）是最早提出的k-中心点算法之一，是聚类分析算法中划分法的一个聚类方法，它选用簇中位置最中心的对象作为代表对象，试图对n个对象给出k个划分。 （2）STING（Statistical Information Grid_based Method）是一种基于网格的多分辨率聚类技术，他将空间区域划分为矩形单元。针对不同级别的分辨率，通常存在多个级
剑指Offer——网易笔试之不要二——欧式距离的典型应用
热门推荐
IT全栈 华强工作室
08-10 4万+
剑指Offer——网易笔试之不要二——欧式距离的典型应用前言 欧几里得度量（euclidean metric）（也称欧氏距离）是一个通常采用的距离定义，指在m维空间中两个点之间的真实距离，或者向量的自然长度（即该点到原点的距离）。在二维和三维空间中的欧氏距离就是两点之间的实际距离。 二维空间的公式 0ρ = sqrt( (x1-x2)^2+(y1-y2)^2 )　|x
矩阵之间欧式距离的快捷计算方法（无循环）
IT_forlearn的博客
08-22 1万+
最近工作中需要用到矩阵中各个样本之间欧氏距离，因此记录一下，如何简便快捷地进行tensor间欧氏距离的计算（使用Pytorch框架）。 按照我之前的想法，会进行两轮或者一轮循环一个个地求出样本间的欧氏距离，但是看过了michuanhaohao/reid-strong-baseline中Euclidean_dist()方法的运算之后才发现了新大陆---------通过矩阵的方式快速的进行计算。 ...
计算欧式距离的matlab程序
10-26
在计算机科学和数学中，欧式距离是衡量两个向量之间差异的一种常见方法，特别是在机器学习、数据挖掘和统计分析等领域。在MATLAB这种强大的数值计算环境中，实现欧式距离的计算非常直观且高效。本篇文章将深入探讨...
三点解算两个坐标系之间的旋转矩阵和平移向量
05-23
根据 三点在两个坐标系下的坐标，建立两个坐标系之间的旋转矩阵R和平移向量T，适用场景：求 世界坐标系到 相机坐标系的转换关系。以其中一点建立 世界坐标系，该点在相机坐标系中的坐标是 世界坐标系到坐标系的平移...
计算Python Numpy向量之间的欧氏距离实例
09-16
主要介绍了计算Python Numpy向量之间的欧氏距离实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
C++后端面试|笔试基础(2)：欧式距离 曼哈顿距离等
CoomCon的博客
07-22 775
本文整理不全，整理了面试中问到的问题，没问到的留存以后整理； 其他请参考 文章目录1.欧式距离2.曼哈顿距离 1.欧式距离 2.曼哈顿距离 在曼哈顿街区要从一个十字路口开车到另一个十字路口，驾驶距离显然不是两点之前的直线距离。这个实际的驾驶距离就是"曼哈顿距离"。曼哈顿距离也称“城市街区距离”。 ...
pytorch中常用的损失函数
最新发布
十年以上架构设计经验，专注于软件架构和人工智能领域，对机器视觉、NLP、音视频等领域都有涉猎
11-09 704
损失函数在人工智能领域中起着至关重要的作用，它不仅是模型训练和优化的基础，也是评估模型性能、解决过拟合问题以及指导模型选择的重要工具。不同的损失函数适用于不同的问题和算法，选择合适的损失函数对于取得良好的模型性能至关重要。
《数字图像处理（第三版）》 第二章 数字图像基础 笔记4（像素间的一些基本关系）
Mr. Stone's Blog
03-28 2071
2.5 像素间的一些基本关系 2.5.1 相邻像素 对于坐标 (x, y) 的一个像素 p 有 4 个水平和垂直的相邻像素， 分别为：(x+1, y), (x-1, y), (x, y+1), (x, y-1)，这个像素集称为 p 的 4 邻域，记为 N4( p )。 p 的 4 个对角邻像素 分别为：(x+1, y+1), (x-1, y-1), (x-1, y+1), (x+1, y-1)，...
【三种计算样本欧氏距离的方法——样本数据表示为矩阵】
YS_jw的博客
09-17 1974
利用python中矩阵性质提升计算效率
距离矩阵的计算
vcc12v的博客
06-11 668
给定数据矩阵 X(N×D)\boldsymbol{X}\left(N\times D\right)X(N×D), 经常需要求解每两个样本间的距离Dijx=∥xi−xj∥22D^x_{ij}=\left\|\boldsymbol{x}_i-\boldsymbol{x}_j\right\|_2^2Dijx​=∥xi​−xj​∥22​.Remark: 这个距离矩阵的用处有很多，如核函数，对比学习, etc.目前我所知有3种编程方法可以求解DijxD^x_{ij}Dijx​. Elementary calcula
练习题记录：求解距离矩阵，首先生成一百个二维坐标点，计算任意两个坐标点的距离
qq_44788797的博客
04-12 1万+
碰到一道练习题：求解距离矩阵，首先生成一百个二维坐标点，计算任意两个坐标点的距离。我一开始看到这题目是一脸懵逼，然后上网找了一下，更是二脸懵逼。生成一百个二维坐标点，我首先就是想去生成一个1010的二维数组，然后网上的解决方法觉得非常复杂，还定义一个函数，可能是我还在入门学习numpy很多地方还看不懂，然后只好直接看练习题的答案了。下面是分析：首先，这个距离被称作欧式距离，简单来说就是两个坐标之间...
Pytorch计算距离（例如欧式距离）torch.nn.PairwiseDistance
qq_43391414的博客
03-12 1万+
通常，我们计算欧式距离，例如[0,0]到[1,1]的距离为2\sqrt22​。 pdist = nn.PairwiseDistance(p=2)#p=2就是计算欧氏距离，p=1就是曼哈顿距离，例如上面的例子，距离是1. input1 = torch.randn(100, 128) input2 = torch.randn(100, 128)#上面两个形状要一样。 output = pdist(input1,input2)#计算各自每一行之间的欧式距离。 output.shape torch.Size([
【深度学习】1.张量tensor（下）
qq_49183286的博客
10-04 663
张量的广播与科学运算，线性代数相关模块很重要。
聚类分析之距离计算(二)
遥望......
09-22 1万+
聚类分析中如何度量两个对象之间的相似性呢？一般有两种方法，一种是对所有对象作特征投影，另一种则是距离计算。前者主要从直观的图像上反应对象之间的相似度关系，而后者则是通过衡量对象之间的差异度来反应对象之间的相似度关系。           如图（1）所示：假设X坐标轴为时间，
近邻的距离度量表示法
Havenoidea 的专栏
10-11 4460
K近邻算法的核心在于找到实例点的邻居，这个时候，问题就接踵而至了，如何找到邻居，邻居的判定标准是什么，用什么来度量。这一系列问题便是下面要讲的距离度量表示法。但有的读者可能就有疑问了，我是要找邻居，找相似性，怎么又跟距离扯上关系了？     这是因为特征空间中两个实例点的距离和反应出两个实例点之间的相似性程度。K近邻模型的特征空间一般是n维实数向量空间，使用的距离可以使欧式距离，也是可以是其
怎么用matlab实现两个矩阵的两两向量求欧式距离
04-26
你可以使用MATLAB自带的pdist2函数来计算两个矩阵的两两向量的欧式距离。具体实现代码如下： ```matlab % 创建两个矩阵A和B A = rand(3,3); B = rand(2,3); % 计算A和B中所有向量的欧式距离 dist = pdist2(A,B,'euclidean'); ``` 其中，pdist2函数会返回一个距离矩阵dist，其中dist(i,j)表示A的第i行向量和B的第j行向量的欧式距离。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值