pytorch 2 张量操作

张量的创建

直接创建

torch.tensor

torch.tensor(data，dtype=None，device=None，requires_grad=False，pin_memory=False)

• data(array_like) - tensor的初始数据，可以是list, tuple, numpy array, scalar或其他类型。

• dtype(torch.dtype, optional) - tensor的数据类型，如torch.uint8, torch.float, torch.long等

• device (torch.device, optional) – 决定tensor位于cpu还是gpu。如果为None，将会采用默认值，默认值在torch.set_default_tensor_type()中设置，默认为 cpu。

• requires_grad (bool, optional) – 决定是否需要计算梯度。

• pin_memory (bool, optional) – 是否将tensor存于锁页内存。这与内存的存储方式有关，通常为False。

l = [[1,2,3],[4,5,6],[7,8,9]]  
t = torch.tensor(l)  
print(t)  
print(t.dtype)  
ll = [[1.,-1.],[1.,-1.]]  
t2 = torch.tensor(ll,dtype=torch.float64) 
print(t2)  
print(t2.dtype)  
t3 = torch.tensor(ll)  
print(t3)  
print(t3.dtype)

![[Pasted image 20240809213925.png]]
浮点数默认是torch.float32类型，可以指定参数dtype进行指定数据类型

arr = np.array([[1,2,3],[4,5,6]])
t_from_arr = torch.tensor(arr,dtype=torch.uint8)
print(t_from_arr)

torch.from_numpy

还有一种常用的通过numpy创建tensor方法是torch.from_numpy()。这里需要特别注意的是，创建的**tensor和原array共享同一块内存（**The returned tensor and ndarray share the same memory. ），即当改变array里的数值，tensor中的数值也会被改变。

arr = np.array([[1,2,3],[4,5,6],[7,8,9]])  
t_from_numpy = torch.from_numpy(arr)  
print("numpy array:",arr)  
print("torch tensor:",t_from_numpy)  
print("\n修改arr")  
arr[0,0]=0  
print("numpy array:",arr)  
print("torch tensor:",t_from_numpy)  
print("\n修改tensor")  
t_from_numpy[0,1]=1  
print("numpy array:",arr)  
print("torch tensor:",t_from_numpy)

![[Pasted image 20240809215934.png]]

依数值创建

torch.zeros

*torch.zeros(size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

功能：依给定的size创建一个全0的tensor，默认数据类型为torch.float32（也称为torch.float）。

*size 是 Python 中的一种特殊语法，表示“可变长度参数”。
具体来说，*size 的作用是允许函数接收任意数量的参数，并将这些参数作为一个元组传递给函数。在 torch.zeros 中，size 表示张量的形状（即它的维度）。通过使用 *size，你可以传递一个或多个整数来指定张量的每一维的大小。

1. 单个参数：

   torch.zeros(3)
   

   这会创建一个一维的张量，其大小为3。

2. 多个参数：

   torch.zeros(3, 4)
   

   这会创建一个二维的张量，其形状为3x4。

3. 使用元组解包：

   你也可以通过传递一个元组并使用 * 操作符解包参数：

   size = (3, 4, 5)
   torch.zeros(*size)
   

   这会创建一个三维的张量，其形状为3x4x5。

主要参数：

1. out (tensor, optional)

• 作用: out 参数允许你指定一个已有的张量，用于接收 torch.zeros 创建的张量结果。这意味着函数的输出不会生成一个新的张量，而是将结果直接存储到 out 参数指定的张量中。

• 使用场景:

  • 内存优化: 在高效计算和节省内存分配方面非常有用。如果你已经有一个张量，并且希望在相同的内存位置存储新的数据（例如，全零的张量），可以使用 out 参数。
  • 避免不必要的内存分配: 对于大型张量，避免了重复分配内存的开销。

• 使用示例:

existing_tensor = torch.empty(2, 3) # 创建一个未初始化的张量
torch.zeros(2, 3, out=existing_tensor) # 使用 out 参数将全零的张量结果存储在 existing_tensor 中
print(existing_tensor)

n = np.random.randint(0, 10, size=(3, 3)) #生成一个 3x3 的矩阵，每个元素是 [0, 10) 之间的随机整数
print(n)
#转为张量
nn = torch.from_numpy(n)
#使用 torch.zeros 并将结果存储在 nn 中
torch.zeros(3,3,out=nn)
print(nn)

![[Pasted image 20240809221307.png]]
2. `layout (torch.layout, optional)`

- **作用**: `layout` 参数决定张量在内存中的存储布局方式。PyTorch 支持不同的内存布局，适用于不同的计算需求。

- **常见布局**:
- **`torch.strided`**: 默认的内存布局。数据以密集格式存储，张量元素按照一定的步长（stride）在内存中排列。
- **`torch.sparse_coo`**: 稀疏张量的布局方式，适用于大部分元素为零的稀疏矩阵。这种布局只存储非零元素及其索引，节省内存。

- **使用场景**:
- **默认密集存储**: 如果你的数据是密集的（大多数元素非零），使用默认的 `torch.strided` 布局。
- **稀疏数据**: 如果你的数据是稀疏的（大多数元素为零），使用 `torch.sparse_coo` 布局更为高效。

- **使用示例**:

(1) 默认布局(连续存储):

```python
import torch

# 创建一个形状为 (2, 3) 的默认连续布局零张量
default_tensor = torch.zeros(2, 3)
print(default_tensor)
print(default_tensor.is_contiguous())  # 输出: True

![[Pasted image 20240809222238.png]]
(2) 指定 strided 布局:

# 创建一个形状为 (2, 3) 的 strided 布局零张量
strided_tensor = torch.zeros(2, 3, layout=torch.strided)
print(strided_tensor)
print(strided_tensor.is_contiguous())  # 输出: True

![[Pasted image 20240809222245.png]]
(3) 稀疏布局:

# 创建一个稀疏布局的零张量
sparse_tensor = torch.zeros(2, 3, layout=torch.sparse_coo)
print(sparse_tensor)
print(sparse_tensor.is_sparse)  # 输出: True

![[Pasted image 20240809222349.png]]
解释：
1. indices=tensor([], size=(2, 0)):
- 这表示稀疏张量中非零元素的索引。
- size=(2, 0) 表示这是一个2D张量，但目前没有任何索引（因为张量是空的）。
- 第一个维度 (2) 对应于张量的维数（在这里是2D）。
- 第二个维度 (0) 表示没有非零元素。

2. `values=tensor([], size=(0,))`: 
   - 这表示非零元素的值。
   - 当前为空，因为没有非零元素。

3. `size=(2, 3)`: 
   - 这是整个稀疏张量的形状。
   - 它表示这个稀疏张量在稠密形式下会是一个 2x3 的矩阵。

4. `nnz=0`: 
   - "nnz" 代表 "number of non-zero elements"（非零元素的数量）。
   - 这里为0，表示没有非零元素。

5. `layout=torch.sparse_coo`: 
   - 这指定了张量的布局。
   - `sparse_coo` 表示这是一个 COO（Coordinate）格式的稀疏张量。

(4) 使用 as_strided 创建非连续布局:

# 创建一个非连续布局的零张量
non_contiguous_tensor = torch.zeros(4, 4).as_strided((2, 2), (2, 1))
print(non_contiguous_tensor)
print(non_contiguous_tensor.is_contiguous())  # 输出: False

![[Pasted image 20240809222532.png]]
解释：

1. torch.zeros(4, 4):

   • 首先，创建一个 4x4 的全零张量。
   • 这个张量在内存中是连续存储的。

2. .as_strided((2, 2), (2, 1)):

   • 然后，使用 as_strided 方法重新解释这个张量的存储。

   • as_strided 接受两个主要参数：新的形状和新的步长（stride）。

   • 新的形状 (2, 2):
     这表示我们要将原来的 4x4 张量重新解释为一个 2x2 的张量。

   • 新的步长 (2, 1):

     • 步长定义了在内存中如何"跳跃"以获取下一个元素。
     • 2 表示在第一个维度上，每次需要跳过2个元素。
     • 1 表示在第二个维度上，每次只需要移动到下一个相邻元素。

结果是什么样的？

原始的 4x4 张量（用索引表示）：

0  1  2  3
4  5  6  7
8  9  10 11
12 13 14 15

应用 as_str