Python学习笔记（持续更新）

Numpy

shape函数

.shape：返回矩阵维度。

import numpy as np
x=np.array([[1,2,3],[4,5,6]])
y=np.array([[[1,1,1,1],[2,2,2,2],[3,3,3,3]],[[4,4,4,4],[5,5,5,5],[6,6,6,6]]])
print(x.shape)
print(y.shape)

结果：
(2, 3)
(2, 3, 4)

shape[0]：返回矩阵第一维度。二维矩阵返回了行数，而三维矩阵返回了2代表有2个二维矩阵。

print(x.shape[0])
print(y.shape[0])

结果：
2
2

shape[1]:返回矩阵第二维度。二维矩阵返回了列数，而三维矩阵返回的3代表在这2个二维矩阵中的行数。

print(x.shape[1])
print(y.shape[1])

结果：
3
3

同理可得，三维矩阵还有shape[2],上文创造的三维矩阵的y.shape[2] 为4。

对于图像来说：
image.shape[0]——图片高
image.shape[1]——图片长
image.shape[2]——图片通道数
而对于矩阵来说：
shape[0]：表示矩阵的行数
shape[1]：表示矩阵的列数

shape[-1]:返回矩阵最后的维度。

print(x.shape[-1])
print(y.shape[-1])

结果：
3
4

reshape函数

reshape(-1,)

reshape(-1):改成一串，没有行列

z = np.array([[1, 2, 3, 4],
          [5, 6, 7, 8],
          [9, 10, 11, 12]])

print(z.reshape(-1))

结果：
[ 1  2  3  4  5  6  7  8  9 10 11 12]

reshape(-1,1):1表示最里面的维度为1

print(z.reshape(-1,1))

结果：
[[ 1]
 [ 2]
 [ 3]
 [ 4]
 [ 5]
 [ 6]
 [ 7]
 [ 8]
 [ 9]
 [10]
 [11]
 [12]]

reshape(-1,2):最里面的维度为2

print(z.reshape(-1,2))

结果：
[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]

reshape(-1,2,3):最里面的维度为(2,3)。可以理解为把原矩阵转换为一个大矩阵里包含着若干个维度为(2,3)的小矩阵

print(z.reshape(-1,2,3))

结果：
[[[ 1  2  3]
  [ 4  5  6]]

 [[ 7  8  9]
  [10 11 12]]]

reshape(-1,2,2,3):最里面的维度为(2,2,3)

print(z.reshape(-1,2,2,3))

结果：
[[[[ 1  2  3]
   [ 4  5  6]]

  [[ 7  8  9]
   [10 11 12]]]]

Pytorch

dim()函数
用法：返回矩阵维度

c = torch.randn(2,3,4,5)
c.dim()

结果：
4

bmm()函数
函数原型：torch.bmm(mat1, mat2)，用于执行批量矩阵乘法

参数说明：
mat1 和 mat2 是两个三维张量（或者可以被广播为三维张量）。
mat1 的形状为 (batch, n, m)。
mat2 的形状为 (batch, m, p)。

返回值是一个三维张量，其形状为 (batch, n, p)

mat1 = torch.rand(3, 2, 4)
mat2 = torch.rand(3, 4, 3)
result = torch.bmm(mat1, mat2)
print(result.shape)

结果：
torch.Size([3, 2, 3])

torch.repeat_interleave()

函数原型

torch.repeat_interleave(input, repeats, dim=None) → Tensor

函数功能：沿着指定的维度重复张量的元素

输入参数：

• input (类型：torch.Tensor)：输入张量
• repeats（类型：int或torch.Tensor）：每个元素的重复次数
• dim（类型：int）需要重复的维度。默认情况下dim=None，表示将把给定的输入张量展平（flatten）为向量，然后将每个元素重复repeats次，并返回重复后的张量。

注意

• 如果不指定dim，则默认将输入张量扁平化(维数是1，因此这时repeats必须是一个数，不能是数组)，并且返回一个扁平化的输出数组。
• 返回的数组与输入数组维数相同，并且除了给定的维度dim，其他维度大小与输入数组相应维度大小相同
• repeats：如果传入数组，则必须是tensor格式。并且只能是一维数组，数组长度与输入数组input的dim维度大小相同

例：

import torch
a = torch.randn(3,2)

结果：
tensor([[ 0.0033, -0.3267],
        [-0.8046,  0.5277],
        [-0.1620,  0.8179]])

1、输入二维张量，不指定dim，重复次数为2次，表示将把给定的输入张量展平（flatten）为向量，然后将每个元素重复2次，并返回重复后的张量。

torch.repeat_interleave(a,2)

结果：
tensor([ 0.0033,  0.0033, -0.3267, -0.3267, -0.8046, -0.8046,  0.5277,  0.5277,
        -0.1620, -0.1620,  0.8179,  0.8179])

2、输入二维张量，指定dim=0，重复次数为3次，表示把输入张量每行元素重复3次

torch.repeat_interleave(a,3,dim=0)

结果：
tensor([[ 0.0033, -0.3267],
        [ 0.0033, -0.3267],
        [ 0.0033, -0.3267],
        [-0.8046,  0.5277],
        [-0.8046,  0.5277],
        [-0.8046,  0.5277],
        [-0.1620,  0.8179],
        [-0.1620,  0.8179],
        [-0.1620,  0.8179]])

3、输入二维张量，指定dim=1，重复次数为3次，表示把输入张量每列元素重复3次

torch.repeat_interleave(a,3,dim=1)

结果：
tensor([[ 0.0033,  0.0033,  0.0033, -0.3267, -0.3267, -0.3267],
        [-0.8046, -0.8046, -0.8046,  0.5277,  0.5277,  0.5277],
        [-0.1620, -0.1620, -0.1620,  0.8179,  0.8179,  0.8179]])

4、输入二维张量，指定dim=0，重复次数为一个张量列表b=[n1,n2,n3]，表示在（dim=0）对应行上面重复n1,n2,n3遍，张量列表的长度必须与dim=0的维度的长度一样，否则会报错。因为要对行进行重复，a的行数要和n的数量一致。

torch.repeat_interleave(a,torch.tensor([2,3,4]),dim=0)

结果：
tensor([[ 0.0033, -0.3267],
        [ 0.0033, -0.3267],
        [-0.8046,  0.5277],
        [-0.8046,  0.5277],
        [-0.8046,  0.5277],
        [-0.1620,  0.8179],
        [-0.1620,  0.8179],
        [-0.1620,  0.8179],
        [-0.1620,  0.8179]])

5、输入二维张量，指定dim=1，重复次数为一个张量列表[n1,n2]，表示在（dim=1）对应列上面重复n1,n2遍，张量列表的长度必须与dim=1的维度的长度一样，否则会报错.因为要对列进行重复，a的列数要和n的数量一致。

torch.repeat_interleave(a,torch.tensor([2,6]),dim=1)

结果：
tensor([[ 0.0033,  0.0033, -0.3267, -0.3267, -0.3267, -0.3267, -0.3267, -0.3267],
        [-0.8046, -0.8046,  0.5277,  0.5277,  0.5277,  0.5277,  0.5277,  0.5277],
        [-0.1620, -0.1620,  0.8179,  0.8179,  0.8179,  0.8179,  0.8179,  0.8179]])

6、

b = torch.randn(3,4)
b

结果：
tensor([[ 0.8856,  0.0129, -1.3439, -0.3765],
        [-0.7506,  0.0546,  1.0429, -1.7856],
        [-0.2488, -0.7265,  0.1560,  0.5211]])

print(torch.repeat_interleave(b,torch.tensor([2,3,4]),dim=0))
print(torch.repeat_interleave(b,torch.tensor([2,3,4,5]),dim=1))

结果：
tensor([[ 0.8856,  0.0129, -1.3439, -0.3765],
        [ 0.8856,  0.0129, -1.3439, -0.3765],
        [-0.7506,  0.0546,  1.0429, -1.7856],
        [-0.7506,  0.0546,  1.0429, -1.7856],
        [-0.7506,  0.0546,  1.0429, -1.7856],
        [-0.2488, -0.7265,  0.1560,  0.5211],
        [-0.2488, -0.7265,  0.1560,  0.5211],
        [-0.2488, -0.7265,  0.1560,  0.5211],
        [-0.2488, -0.7265,  0.1560,  0.5211]])
tensor([[ 0.8856,  0.8856,  0.0129,  0.0129,  0.0129, -1.3439, -1.3439, -1.3439,
         -1.3439, -0.3765, -0.3765, -0.3765, -0.3765, -0.3765],
        [-0.7506, -0.7506,  0.0546,  0.0546,  0.0546,  1.0429,  1.0429,  1.0429,
          1.0429, -1.7856, -1.7856, -1.7856, -1.7856, -1.7856],
        [-0.2488, -0.2488, -0.7265, -0.7265, -0.7265,  0.1560,  0.1560,  0.1560,
          0.1560,  0.5211,  0.5211,  0.5211,  0.5211,  0.5211]])

torch.unsqueeze()& torch.squeeze()

torch.unsqueeze()

unsqueeze() 函数是 PyTorch 中的一个张量操作函数，用于在指定位置添加一个新的维度。该函数的作用是在张量的指定位置插入一个新的维度，从而改变张量的形状。

unsqueeze(dim) 函数接受一个参数 dim，用于指定在哪个位置插入新的维度。dim 参数的取值范围为 -len(input) - 1 到 len(input)。其中，负数表示从最后一个维度开始计数。如果 dim 是负数，则表示从最后一个维度开始计数插入新的维度，如果 dim 是正数，则表示从第一个维度开始计数插入新的维度。

例如，如果一个张量的形状为 (3, 4, 5)，则可以通过 unsqueeze(0) 在第一个维度前插入一个新的维度，结果形状为 (1, 3, 4, 5)；通过 unsqueeze(-1) 在最后一个维度后插入一个新的维度，结果形状为 (3, 4, 5, 1)。

x = torch.tensor([[1, 2, 3, 4],
                  [5, 6, 7, 8],
                  [9, 10, 11, 12]])

在第一个维度前插入一个新的维度

y = x.unsqueeze(0)
print(y.shape) 
y

结果：
torch.Size([1, 3, 4])
tensor([[[ 1,  2,  3,  4],
         [ 5,  6,  7,  8],
         [ 9, 10, 11, 12]]])

在最后一个维度后插入一个新的维度

z = x.unsqueeze(-1)
print(z.shape)  # 输出：torch.Size([3, 4, 1])
z

结果：
torch.Size([3, 4, 1])
tensor([[[ 1],
         [ 2],
         [ 3],
         [ 4]],

        [[ 5],
         [ 6],
         [ 7],
         [ 8]],

        [[ 9],
         [10],
         [11],
         [12]]])

在第一个维度后插入一个新的维度

z1 = x.unsqueeze(1)
print(z1.shape)
z1

torch.Size([3, 1, 4])
tensor([[[ 1,  2,  3,  4]],

        [[ 5,  6,  7,  8]],

        [[ 9, 10, 11, 12]]])

torch.squeeze()

squeeze() 函数是 PyTorch 中的一个张量操作函数，用于去除张量中的尺寸为 1 的维度。该函数的作用是压缩张量中尺寸为 1 的维度，从而改变张量的形状。

squeeze(dim=None) 函数接受一个参数 dim，用于指定要去除的维度。如果不提供 dim 参数，则会去除所有尺寸为 1 的维度。如果提供了 dim 参数，则只会去除指定位置的尺寸为 1 的维度。

dim 参数的取值范围与 unsqueeze() 函数相同，负数表示从最后一个维度开始计数。

x = torch.randn(1, 3, 1, 4)

去除所有尺寸为 1 的维度

y = x.squeeze()
print(y.shape)  # 输出：torch.Size([3, 4])

结果：
torch.Size([3, 4])

去除指定位置的尺寸为 1 的维度

z = x.squeeze(0)
print(z.shape)

此时第一个维度的维度不是1，删除失败

结果：
torch.Size([1, 3, 1, 4])

删除第三个维度

w = x.squeeze(2)
print(w.shape)    # 输出：torch.Size([1, 3, 1])

删除成功

torch.Size([1, 3, 4])