维度/标量/张量/一维/二维/三维/shape/size/索引/view理解

维度是对不类型的描述,有几个不同的类型就有几个不同的维度.

张量是用来描述维度更宽泛的概念

标量是一个数.

一维是一组数据.

二维是两个不同特征组合的数据.

三维是三个不同的特征组合的数据.[] 只是用来表示区间范围套更多的[]是为了表示不同的维度,要理解维度 含义而不是只看[].

生活例子
假设我们有一个书架，书架有很多层，每层放着书：

索引 (Index)：就像书架上书的位置，比如书架的第3层的第2本书。
形状 (Shape)：就像书架的结构，比如书架有5层，每层有10本书，形状就是 (5, 10)。
尺寸 (Size)：总的书的数量，比如整个书架上有50本书。
三维数据怎么看每一个维度的形状? 每个维度索引又该怎么用?  1 -1什么意思?  view怎么重塑形状的?

要查看一个三维数据的形状，你可以通过访问该数据的 shape 属性来看到它在每个维度上的大小。三维数据的形状通常用一个三元组 (D1, D2, D3) 表示，其中：

• D1 是第一维度的大小。
• D2 是第二维度的大小。
• D3 是第三维度的大小。

举个例子

假设我们有一个三维张量 tensor3d，我们可以通过以下代码来查看它的形状：

import torch

# 创建一个三维张量
tensor3d = torch.tensor([
    [[1, 2, 3], [4, 5, 6]],
    [[7, 8, 9], [10, 11, 12]],
    [[13, 14, 15], [16, 17, 18]]
])

# 查看三维张量的形状
print(tensor3d.shape)  # 输出: torch.Size([3, 2, 3])

在这个例子中，tensor3d 的形状是 (3, 2, 3)，表示它有 3 个深度，每个深度有 2 行，每行有 3 列。

访问每个维度的大小

你可以分别访问每个维度的大小：

depth = tensor3d.shape[0]
rows = tensor3d.shape[1]
columns = tensor3d.shape[2]

print(f"Depth (第一维度): {depth}")
print(f"Rows (第二维度): {rows}")
print(f"Columns (第三维度): {columns}")

详细解释

1. 第一维度 (Depth)：表示数据的深度，在这个例子中是 3，表示有 3 个 2x3 的矩阵。
2. 第二维度 (Rows)：表示每个深度中的行数，在这个例子中是 2，表示每个深度有 2 行。
3. 第三维度 (Columns)：表示每行中的列数，在这个例子中是 3，表示每行有 3 列。

生活例子

假设你有一个三层的书架，每层有两排，每排有三本书。你可以用一个三维张量来表示这个书架：

• 第一维度 (Depth)：表示书架的层数。
• 第二维度 (Rows)：表示每层的排数。
• 第三维度 (Columns)：表示每排的书的数量。

所以，如果你有一个书架，其形状是 (3, 2, 3)，那么你可以说：

• 有 3 层（第一维度）。
• 每层有 2 排（第二维度）。
• 每排有 3 本书（第三维度）。

实际代码

import torch

# 创建一个三维张量表示书架
bookshelf = torch.tensor([
    [[1, 2, 3], [4, 5, 6]],
    [[7, 8, 9], [10, 11, 12]],
    [[13, 14, 15], [16, 17, 18]]
])

# 查看书架的形状
print(bookshelf.shape)  # 输出: torch.Size([3, 2, 3])

# 访问每个维度的大小
depth = bookshelf.shape[0]
rows = bookshelf.shape[1]
columns = bookshelf.shape[2]

print(f"Depth (第一维度): {depth}")
print(f"Rows (第二维度): {rows}")
print(f"Columns (第三维度): {columns}")

这样，你可以清楚地看到三维数据在每个维度上的形状。

要查看和使用三维数据的索引，可以通过访问特定位置的元素或子张量。以下是详细说明如何在三维数据中使用索引的步骤和示例：

创建三维张量

首先，创建一个三维张量：

import torch

# 创建一个三维张量
tensor3d = torch.tensor([
    [[1, 2, 3], [4, 5, 6]],
    [[7, 8, 9], [10, 11, 12]],
    [[13, 14, 15], [16, 17, 18]]
])

# 查看三维张量的形状
print(tensor3d.shape)  # 输出: torch.Size([3, 2, 3])

查看具体元素

通过指定每个维度的索引来查看具体的元素：

# 查看第一个深度（0），第一行（0），第一列（0）的元素
print(tensor3d[0, 0, 0])  # 输出: tensor(1)

# 查看第二个深度（1），第二行（1），第三列（2）的元素
print(tensor3d[1, 1, 2])  # 输出: tensor(12)

# 查看第三个深度（2），第一行（0），第二列（1）的元素
print(tensor3d[2, 0, 1])  # 输出: tensor(14)

查看子张量

你还可以通过索引查看子张量：

# 查看第一个深度（0）的所有元素
print(tensor3d[0])  # 输出: tensor([[1, 2, 3], [4, 5, 6]])

# 查看第二个深度（1）的第一行所有列
print(tensor3d[1, 0])  # 输出: tensor([7, 8, 9])

# 查看所有深度（:），第一行（0），第二列（1）的所有元素
print(tensor3d[:, 0, 1])  # 输出: tensor([ 2,  8, 14])

生活例子

假设你有一个三层的书架，每层有两排，每排有三本书：

bookshelf = torch.tensor([
    [[1, 2, 3], [4, 5, 6]],
    [[7, 8, 9], [10, 11, 12]],
    [[13, 14, 15], [16, 17, 18]]
])

1. 查看某本书：假设你要查看第二层（深度1）的第二排（行1）的第三本书（列2）：

python     print(bookshelf[1, 1, 2])  # 输出: tensor(12)    

2. 查看某一层的所有书：查看第三层（深度2）的所有书：

python     print(bookshelf[2])  # 输出: tensor([[13, 14, 15], [16, 17, 18]])    

3. 查看某排的所有书：查看第一层（深度0）的第一排（行0）的所有书：

python     print(bookshelf[0, 0])  # 输出: tensor([1, 2, 3])    

4. 查看某列的所有书：查看所有层（深度:）的第二排（行1）的第一本书（列0）：

python     print(bookshelf[:, 1, 0])  # 输出: tensor([ 4, 10, 16])    

代码总结

以下是完整的代码示例：

import torch

# 创建一个三维张量
tensor3d = torch.tensor([
    [[1, 2, 3], [4, 5, 6]],
    [[7, 8, 9], [10, 11, 12]],
    [[13, 14, 15], [16, 17, 18]]
])

# 查看三维张量的形状
print(tensor3d.shape)  # 输出: torch.Size([3, 2, 3])

# 查看具体元素
print(tensor3d[0, 0, 0])  # 输出: tensor(1)
print(tensor3d[1, 1, 2])  # 输出: tensor(12)
print(tensor3d[2, 0, 1])  # 输出: tensor(14)

# 查看子张量
print(tensor3d[0])        # 输出: tensor([[1, 2, 3], [4, 5, 6]])
print(tensor3d[1, 0])     # 输出: tensor([7, 8, 9])
print(tensor3d[:, 0, 1])  # 输出: tensor([ 2,  8, 14])

通过这些索引操作，你可以方便地查看和操作三维数据中的特定元素或子集。

在张量操作中，索引使用 1 和 -1 有不同的含义：

1. 1：表示索引第一个维度（以 0 为起点的索引方式）。例如，在三维张量 tensor3d 中，tensor3d[1] 表示索引第二个深度（第一个维度）的所有元素。

2. -1：在张量操作中，-1 通常有两种含义：
      - 负索引：表示从末尾开始计数的索引。例如，tensor3d[-1] 表示索引最后一个深度的所有元素。负索引允许从数据结构的末尾开始计数，这对于从最后一个元素开始访问数据非常有用。
      - 自动推导尺寸：在改变张量形状时使用。例如，在 torch.reshape 中使用 -1 可以自动推导出某个维度的大小，以使总元素数量保持不变。

示例

假设我们有一个三维张量：

import torch

# 创建一个三维张量
tensor3d = torch.tensor([
    [[1, 2, 3], [4, 5, 6]],
    [[7, 8, 9], [10, 11, 12]],
    [[13, 14, 15], [16, 17, 18]]
])

使用正索引 (1)

# 查看第二个深度（第一维度索引1）的所有元素
print(tensor3d[1])  
# 输出: tensor([[ 7,  8,  9], [10, 11, 12]])

# 查看第二个深度，第一行，第二列的元素
print(tensor3d[1, 0, 1])  
# 输出: tensor(8)

使用负索引 (-1)

# 查看最后一个深度（第一维度索引-1）的所有元素
print(tensor3d[-1])  
# 输出: tensor([[13, 14, 15], [16, 17, 18]])

# 查看最后一个深度，最后一行，最后一列的元素
print(tensor3d[-1, -1, -1])  
# 输出: tensor(18)

使用 -1 进行形状重塑

# 原始形状为 (3, 2, 3)
print(tensor3d.shape)  
# 输出: torch.Size([3, 2, 3])

# 将张量重塑为 (3, 6)，自动推导第二个维度的大小
reshaped_tensor = tensor3d.view(3, -1)
print(reshaped_tensor.shape)  
# 输出: torch.Size([3, 6])

# 将张量重塑为 (1, -1)，自动推导第二个维度的大小
reshaped_tensor = tensor3d.view(1, -1)
print(reshaped_tensor.shape)  
# 输出: torch.Size([1, 18])

总结

• 正索引 (1)：直接从前向后索引。
• 负索引 (-1)：从后向前索引，或者在形状变化中自动推导维度大小。
    
  这些索引和形状变换操作使得张量操作更加灵活和便捷，适用于多种情况。

view重塑过程:

view 是 PyTorch 中用于重塑张量的方法。它可以改变张量的形状（shape），但不会改变其数据。在 view 方法中，-1 表示自动推导某个维度的大小，以确保总元素数量保持不变。

重塑张量的基本原理

假设你有一个形状为 (a, b, c) 的三维张量。重塑它时，总元素数量必须保持不变。例如，原始张量的元素总数是 a * b * c。重塑后，新形状的元素总数也必须是 a * b * c。

view 方法

view 方法允许你指定新形状中的每个维度。如果你使用 -1，PyTorch 会根据剩余的维度和总元素数量自动计算这个维度的大小。

示例解释

假设我们有一个三维张量 tensor3d：

import torch

# 创建一个三维张量
tensor3d = torch.tensor([
    [[1, 2, 3], [4, 5, 6]],
    [[7, 8, 9], [10, 11, 12]],
    [[13, 14, 15], [16, 17, 18]]
])

# 查看张量的形状
print(tensor3d.shape)  
# 输出: torch.Size([3, 2, 3])

这个张量的形状是 (3, 2, 3)，它有 3 * 2 * 3 = 18 个元素。

使用 view 重塑张量

现在我们使用 view 方法将这个三维张量重塑为形状 (3, 6)：

# 将张量重塑为 (3, 6)，自动推导第二个维度的大小
reshaped_tensor = tensor3d.view(3, -1)
print(reshaped_tensor.shape)  
# 输出: torch.Size([3, 6])

在这个例子中：

1. 原始形状： (3, 2, 3)
2. 总元素数量： 3 * 2 * 3 = 18
3. 新形状： (3, -1)。这里 -1 表示自动推导维度大小。PyTorch 会计算出 6，因为 3 * 6 = 18。

因此，新的张量形状是 (3, 6)。

view 的转换过程

# 原始形状为 (3, 2, 3)
print(tensor3d.shape)  
# 输出: torch.Size([3, 2, 3])

# 查看原始张量
print(tensor3d)
# 输出:
# tensor([[[ 1,  2,  3],
#          [ 4,  5,  6]],
#
#         [[ 7,  8,  9],
#          [10, 11, 12]],
#
#         [[13, 14, 15],
#          [16, 17, 18]]])

# 将张量重塑为 (3, 6)
reshaped_tensor = tensor3d.view(3, -1)
print(reshaped_tensor.shape)  
# 输出: torch.Size([3, 6])

# 查看重塑后的张量
print(reshaped_tensor)
# 输出:
# tensor([[ 1,  2,  3,  4,  5,  6],
#         [ 7,  8,  9, 10, 11, 12],
#         [13, 14, 15, 16, 17, 18]])

在 view 转换过程中，张量的元素顺序保持不变，只是重新组织了形状。你可以看到原始张量中的元素按行展开，重新排列成形状 (3, 6)。

总结

• view 方法重塑张量时，总元素数量必须保持不变。
• 使用 -1 让 PyTorch 自动计算某个维度的大小。
• 重塑后的张量元素顺序不变，只是改变了形状。

希望这个解释能帮助你理解 view 方法以及重塑张量的过程。如果你有更多问题，请随时问我！

什么是维度？
标量（0维）：一个单一的数值，没有任何维度。

例子：一个人的体温 36.6 度。
向量（1维）：一列数值，只有一个维度。

例子：一个人一周内的体温记录 [36.5, 36.7, 36.6, 36.8, 36.9, 37.0, 36.7]。
矩阵（2维）：一个二维的数值网格，有两个维度。

例子：一个班级每个学生一周内的体温记录。

csharp
复制代码

[ [36.5, 36.7, 36.6, 36.8, 36.9, 37.0, 36.7], # 学生A [36.4, 36.6, 36.5, 36.7, 36.8, 36.9, 36.6], # 学生B … ]

三维张量（3维）：一个三维的数值立方体，有三个维度。

例子：一个学校每个班级每个学生一周内的体温记录。

csharp
复制代码

[ [ [36.5, 36.7, 36.6, 36.8, 36.9, 37.0, 36.7], # 班级1, 学生A [36.4, 36.6, 36.5, 36.7, 36.8, 36.9, 36.6], # 班级1, 学生B … ], [ [36.6, 36.8, 36.7, 36.9, 37.0, 37.1, 36.8], # 班级2, 学生A [36.5, 36.7, 36.6, 36.8, 36.9, 37.0, 36.7], # 班级2, 学生B … ], … ]