张量

张量是矩阵向任意维度的推广(张量的维度通常叫轴）
仅含一个数字的张量叫标量（0D张量）

查看Numpy张量轴

# 0D
x = np.array(12)
print(x)
print(x.ndim)

# 1D
x = np.array([12, 3, 6, 14, 7])
print(x)
print(x.ndim)

# 2D
x = np.array([[1, 2, 3, 4, 5],
              [4, 5, 6, 7, 8]])
print(x)
print(x.ndim)

# 3D
x = np.array([[[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]],
             [[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]],
             [[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]]])
print(x)
print(x.ndim)

张量形状与数据类型

形状是一个整数元组
例如：

# 2D
x = np.array([[1, 2, 3, 4, 5],
              [4, 5, 6, 7, 8]])
print(x)
print(x.shape)

输出是（2， 5）

数据类型可以是float32， unit8， float64

逐元素相乘（与.dot点乘不同）

例如B维度：(3,3),C维度（3,1）
B*C维度（3，3）运用到了广播机制（将C复制两列然后逐元素相乘）
例：

import numpy as np
B = np.array([[1, 1, 1],
              [2, 2, 2],
              [3, 3, 3]])

C = np.array([[1],
              [2],
              [3]])

# 逐元素相乘
D = B*C
print(D)

相关函数

np.random.randn(n)

生成五个随机高斯变量

np.exp(z)

表示e的z次方

np.insert()函数

np.insert(x, 0, values=1,axis=1)
axis = 0: 表示竖直
axis = 1：表示水平
0：表示插入的索引值
value：插入的值

最终在每一行第一个位置插入1

import numpy as np

x = np.array([[2, 3, 4, 5],
              [5, 6, 7, 8]])

x = np.insert(x, 0, values=1,axis=1)
print(x)

np. argmax()

axis = 1 （行）
np.argmax(a, axis=1)：
返回行最大值的索引

例如：

import numpy as np
a = np.array([[1, 5, 5, 2],
              [9, 6, 2, 8],
              [3, 7, 9, 1]])
print(np.argmax(a, axis=1))

np.mean()

1.可以用来预测准确率：
可计算预测值与实际值相等所占比例
例如;

import numpy as np
y  = np.array([1, 0, 0, 1, 1])
y1 = np.array([1, 0, 1, 0, 0])
acc = np.mean(y==y1)
print(acc)

np.linalg.norm()

可用于计算m个点分别到k个点距离
例：（1,1）（3,4）(5,12)分别到（0,0）（1，1）（2,2）距离

import numpy as np

li= np.array([[1, 1],
              [3, 4],
              [5, 12]])

centro = np.array([[0, 0],
                   [1, 1],
                   [2, 2]])

for i in range(len(li)):
    distance = np.linalg.norm((li[i]-centro), axis=1)
    print(distance)

np.squeeze()

可以将矩阵转化为列表
例：

import numpy as np

X = np.array([[1],
              [2],
              [3],
              [4]])
print(X)
x = np.squeeze(X)
print(x)

两个张量之间的欧氏距离

即m*e和n*e张量之间的欧式距离

理论分析

算法实现

import torch

def euclidean_dist(x, y):
    """
    Args:
      x: pytorch Variable, with shape [m, d]
      y: pytorch Variable, with shape [n, d]
    Returns:
      dist: pytorch Variable, with shape [m, n]
    """
    m = x.size(0)
    n = y.size(0)
    e = x.size(1)

    # 方式1
    a1 = torch.sum((x ** 2), 1, keepdim=True).expand(m, n)
    b2 = (y ** 2).sum(1).expand(m, n)
    dist = (a1 + b2 - 2 * (x @ y.T)).float().sqrt()
    print(dist)

    # 方式2
    x1 = x.unsqueeze(1).expand(m, n, e)
    y1 = y.expand(m, n, e)
    dist = (x1 - y1).pow(2).sum(2).float().sqrt()
    print(dist)

    # 方式3
    dist = torch.zeros((m, n))
    for i, xi in enumerate(x):
        for j, yi in enumerate(y):
            # 方式2.1
            # dist[i][j] = ((xi - yi) ** 2).sum().float().sqrt()
            # 方式2.2
            dist[i][j] = torch.pairwise_distance(torch.unsqueeze(xi, 0), torch.unsqueeze(yi, 0), p=2)
    print(dist)

    # 方式4
    dist = torch.zeros((m, n))
    for i, xi in enumerate(x):
        dist[i] = torch.pairwise_distance(xi, y, p=2)
    print(dist)
    return dist

a = torch.tensor([[1, 2], [3, 4], [5, 6]])
b = torch.tensor([[2, 3], [4, 5], [5, 6], [8, 9]])
dist = euclidean_dist(a, b)

tensor([[1.4142, 4.2426, 5.6569, 9.8995],
        [1.4142, 1.4142, 2.8284, 7.0711],
        [4.2426, 1.4142, 0.0000, 4.2426]])

[矩阵之间欧式距离的快捷计算方法（无循环）]

m*e和m*e张量之间的欧式距离pairwise_distance

import torch.nn.functional as F
distance = F.pairwise_distance(rep_a, rep_b, p=2)

其中rep_a和rep_b为[batch_size,hidden_dim]，两个维度必须相同，或者第一个维度为[hidden_dim]会自动进行广播操作（且最多只能有两个维度？）

[torch.nn.PairwiseDistance(p=2.0, eps=1e-06, keepdim=False)]

使用numpy完成相同操作

import numpy as np
def euclidean_dist(a, b):
    '''
    计算a中向量和b中向量 两两间的欧式距离
    '''
    import numpy as np
    a = np.asarray(a)
    b = np.asarray(b)
    dist = np.sqrt(np.sum(a ** 2, 1, keepdims=True).repeat(b.shape[0], axis=1) +
                   np.sum(b ** 2, 1, keepdims=True).repeat(a.shape[0], axis=1).transpose() - a.dot(b.transpose()) * 2)
    return dist

a = np.array([[1, 2], [3, 4], [5, 6]])
b = np.array([[2, 3], [4, 5], [5, 6], [8, 9]])
dist = euclidean_dist(a, b)
print(dist)

[[1.41421356 4.24264069 5.65685425 9.89949494]
 [1.41421356 1.41421356 2.82842712 7.07106781]
 [4.24264069 1.41421356 0.         4.24264069]]

-柚子皮-

单个张量内部向量两两之间的欧氏距离

def self_euclidean_dist(embeddings):
    # 方式1（类似euclidean_dist(x, y)方式2）
    m, m, e = len(embeddings), len(embeddings), embeddings.shape[1]
    t1 = embeddings.unsqueeze(1).expand(m, m, e)
    t2 = embeddings.unsqueeze(0).expand(m, m, e)
    dist = (t1 - t2).pow(2).sum(2).float().sqrt()
    print(dist)
    return dist

a = torch.tensor([[1, 2], [3, 4], [5, 6]])
self_euclidean_dist(a)
from: -柚子皮-

ref: