动手学深度学习2025.1.23

一、预备知识

1.数据操作

（1）数据访问：

一个元素：[1,2] //行下标为1，列下标为2的元素

一行元素：[1,:] //行下标为1的所有元素

一列元素：[:,1] //列下标为1的所有元素

子区域：[1:3,1:] //行下标为[1,3),列下标为[1,+无穷）的所有元素

子区域：[::3,::2] //行下标跨度为3，列下标跨度为2的元素

（2）张量(tensor)：

理解Tensorflow中的张量：从零维到四维-CSDN博客

一种多维数组，可以用来表示各种物理量和几何量。

张量连结：是一种将多个张量沿着某一维度合并的操作。

torch.cat()

torch.cat() 是 PyTorch 中用于张量拼接的主要函数，其语法如下：

torch.cat(tensors, dim=0)

• tensors：一个包含多个张量的序列，这些张量需要在指定维度上具有相同的形状。

• dim：指定拼接的维度。

1. 一维张量拼接

   tensor_a = torch.tensor([1, 2, 3])
   tensor_b = torch.tensor([4, 5, 6])
   concatenated = torch.cat((tensor_a, tensor_b), dim=0)  # 结果为 [1, 2, 3, 4, 5, 6]

   输出形状为 (6,)。

2. 二维张量拼接

   tensor_1 = torch.tensor([[1, 2], [3, 4]])
   tensor_2 = torch.tensor([[5, 6], [7, 8]])
   concatenated_dim0 = torch.cat((tensor_1, tensor_2), dim=0)  # 沿第0维拼接
   concatenated_dim1 = torch.cat((tensor_1, tensor_2), dim=1)  # 沿第1维拼接

   输出形状分别为 (4, 2) 和 (2, 4)。

3. 高维张量拼接

   tensor_3d_1 = torch.randn(2, 3, 4)
   tensor_3d_2 = torch.randn(2, 3, 4)
   concatenated_dim2 = torch.cat((tensor_3d_1, tensor_3d_2), dim=2)  # 沿第2维拼接

   输出形状为 (2, 3, 8)。

   =>张量的初始形状和内容

   tensor_5 = torch.tensor([[[2, 3, 5]], [[9, 0, 2]]])
   tensor_6 = torch.tensor([[[4, 5, 9]], [[3, 6, 4]]])

   • 形状：tensor_5 和 tensor_6 的形状都是 (2, 1, 3)。

   • 内容：

     • tensor_5 包含两个矩阵：

       [[[2, 3, 5]],[[9, 0, 2]]]

     • tensor_6 包含两个矩阵：

       [[[4, 5, 9]],[[3, 6, 4]]]

   =>在不同维度上拼接的结果

   1. 沿 dim=2 拼接

   dim2 = torch.cat((tensor_5, tensor_6), dim=2)

   • 拼接维度：dim=2 是每个矩阵的列方向（最内层的维度）。

   • 拼接过程：

     • 第一个矩阵的第0行：

       • tensor_5 的 [2, 3, 5] 和 tensor_6 的 [4, 5, 9] 拼接为 [2, 3, 5, 4, 5, 9]。

     • 第二个矩阵的第0行：

       • tensor_5 的 [9, 0, 2] 和 tensor_6 的 [3, 6, 4] 拼接为 [9, 0, 2, 3, 6, 4]。

   • 结果：

     tensor([[[2, 3, 5, 4, 5, 9]],
     ​[[9, 0, 2, 3, 6, 4]]])

   • 形状：(2, 1, 6)。

     • 第0维（矩阵数量）：2。

     • 第1维（行数）：1。

     • 第2维（列数）：6（拼接后的列数）。

   1. 沿 dim=0 拼接

   dim0 = torch.cat((tensor_5, tensor_6), dim=0)

   • 拼接维度：dim=0 是最外层的维度，表示矩阵的数量。

   • 拼接过程：

     • 将 tensor_5 的两个矩阵和 tensor_6 的两个矩阵依次排列。

   • 结果：

     tensor([[[2, 3, 5]],
     ​[[9, 0, 2]],
     ​[[4, 5, 9]],
     ​[[3, 6, 4]]])

   • 形状：(4, 1, 3)。

     • 第0维（矩阵数量）：4（拼接后的矩阵数量）。

     • 第1维（行数）：1。

     • 第2维（列数）：3。

   1. 沿 dim=1 拼接

   dim1 = torch.cat((tensor_5, tensor_6), dim=1)

   • 拼接维度：dim=1 是每个矩阵的行方向。

   • 拼接过程：

     • 第一个矩阵：

       • tensor_5 的第0行 [2, 3, 5] 和 tensor_6 的第0行 [4, 5, 9] 拼接为：

         [[2, 3, 5],[4, 5, 9]]

     • 第二个矩阵：

       • tensor_5 的第0行 [9, 0, 2] 和 tensor_6 的第0行 [3, 6, 4] 拼接为：

         [[9, 0, 2],[3, 6, 4]]

   • 结果：

     tensor([[[2, 3, 5],[4, 5, 9]],
     ​[[9, 0, 2],[3, 6, 4]]])

   • 形状：(2, 2, 3)。

     • 第0维（矩阵数量）：2。

     • 第1维（行数）：2（拼接后的行数）。

     • 第2维（列数）：3。

   =>多维拼接总结

   1. 拼接维度：dim 参数决定了拼接的方向。

   2. 张量的形状：拼接时，除了拼接维度外，其他维度的大小必须一致。

   • dim=0：沿着最外层维度拼接，增加矩阵的数量。

   • dim=1：沿着行方向拼接，增加行数。

   • dim=2：沿着列方向拼接，增加列数。

   (3)节省内存

   尽量进行原地操作，节省内存开销

   before = id(X)
   X += Y
   id(X) == before

   1. id(X) 的含义

   id(X) 返回变量 X 所指向的对象的内存地址。如果 X 的内容被修改，但变量 X 仍然指向同一个对象，那么 id(X) 的值不会改变。

   2. 原地操作（In-place Operations）

   在 Python 中，某些操作会直接修改对象的内容，而不是创建一个新的对象。例如：

   • X += Y 是一个原地操作，它会直接修改 X 的内容，而不是创建一个新的对象。

   1. 原地操作：X += Y 是原地操作，它直接修改了 X 的内容，而不是创建新的对象。

   2. id() 的稳定性：由于 X 的内存地址没有改变，id(X) 的值在操作前后保持一致。

   3. Python 的内存管理：Python 的内存管理机制允许某些操作直接修改对象的内容，而不是创建新的对象，这有助于节省内存和提高效率。

   如果使用非原地操作（例如 X = X + y），结果会有所不同：

   Python复制

   before = id(X)
   X = X + Y
   id(X) == before  # 这将返回 False

   在这种情况下， X = X + Y 会创建新的对象，并将 X 指向这个新对象。因此，id(X) 的值会发生变化。

   （3）Numpy数组

   NumPy（Numerical Python）数组是 Python 中用于高效数值计算的核心数据结构。它是 NumPy 库的基础，提供了多维数组对象（ndarray）和一系列操作这些数组的工具。

   A = X.numpy()
   B = torch.tensor(A)
   type(A), type(B)

2.数据预处理

将工作目录改为D盘的目录

os.getcwd()

'C:\Users\aospr'

target_dir = r"D:\深度学习\数据demo"

os.chdir(target_dir)

os.getcwd()

'D:\深度学习\数据demo'

解决将NaN填充成平均值的bug:

inputs = inputs.fillna(inputs.mean(numeric_only=True)) # 计算均值，只对数值列生效