pytorch官方教程学习笔记1

官方教程地址

目录

• • 张量Tensor
  • 张量初始化
  • 张量属性
  • 张量运算
  • 与NumPy的关系

张量Tensor

张量是一种特殊的数据结构，相似于数组和矩阵。在Pytorch中，我们使用张量来对模型的输入、输出和参数进行编码。张量和Numpy相近，但是tensor可以运行在GPU上

import torch
import numpy as np

张量初始化

张量初始化主要有如下4种方式

直接从数据初始化

data = [[1, 2],[3, 4]]
x_data = torch.tensor(data)

从Numpy数组初始化

np_array = np.array(data)
x_np = torch.from_numpy(np_array)

从另一个张量初始化

除非显式覆盖，新的张量保持参数张量的属性（shape，datatype）。

x_ones = torch.ones_like(x_data) # retains the properties of x_data
print(f"Ones Tensor: \n {x_ones} \n")

x_rand = torch.rand_like(x_data, dtype=torch.float) # overrides the datatype of x_data
print(f"Random Tensor: \n {x_rand} \n")
'''
Ones Tensor:
 tensor([[1, 1],
        [1, 1]])

Random Tensor:
 tensor([[0.2323, 0.8183],
        [0.5833, 0.5744]])
'''

用随机值或常量初始化

shape是一个张量维度的元组

shape = (2,3,)
rand_tensor = torch.rand(shape)
ones_tensor = torch.ones(shape)
zeros_tensor = torch.zeros(shape)

print(f"Random Tensor: \n {rand_tensor} \n")
print(f"Ones Tensor: \n {ones_tensor} \n")
print(f"Zeros Tensor: \n {zeros_tensor}")

'''
Random Tensor:
 tensor([[0.3978, 0.3713, 0.5716],
        [0.9703, 0.4166, 0.3322]])

Ones Tensor:
 tensor([[1., 1., 1.],
        [1., 1., 1.]])

Zeros Tensor:
 tensor([[0., 0., 0.],
        [0., 0., 0.]])
'''

张量属性

张量的属性包含shape，datatype和存储所在的device

tensor = torch.rand(3,4)

print(f"Shape of tensor: {tensor.shape}")
print(f"Datatype of tensor: {tensor.dtype}")
print(f"Device tensor is stored on: {tensor.device}")

'''
Shape of tensor: torch.Size([3, 4])
Datatype of tensor: torch.float32
Device tensor is stored on: cpu
'''

张量运算

张量可以进行超过100种运算，包括转置transposing、索引indexing、切片slicing、数学运算、线性代数、随机采样等等，它们都可以运行在GPU上。

# We move our tensor to the GPU if available
if torch.cuda.is_available():
  tensor = tensor.to('cuda')

下面是几个常见的运算示例

标准的类似于numpy的索引和切片

tensor = torch.ones(4, 4)
tensor[:,1] = 0
print(tensor)
'''
tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])
        '''

连接张量

t1 = torch.cat([tensor, tensor, tensor], dim=1)
print(t1)
'''
tensor([[1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.]])
'''

张量乘法

1.按元素相乘

# This computes the element-wise product
print(f"tensor.mul(tensor) \n {tensor.mul(tensor)} \n")
# Alternative syntax:
print(f"tensor * tensor \n {tensor * tensor}")
'''
tensor.mul(tensor)
 tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])

tensor * tensor
 tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])
        '''

2.矩阵相乘

print(f"tensor.matmul(tensor.T) \n {tensor.matmul(tensor.T)} \n")
# Alternative syntax:
print(f"tensor @ tensor.T \n {tensor @ tensor.T}")
'''
tensor.matmul(tensor.T)
 tensor([[3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.]])

tensor @ tensor.T
 tensor([[3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.]])
'''

in-place运算

有_后缀的运算称为in-place运算

print(tensor, "\n")
tensor.add_(5)
print(tensor)
'''
tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])

tensor([[6., 5., 6., 6.],
        [6., 5., 6., 6.],
        [6., 5., 6., 6.],
        [6., 5., 6., 6.]])
'''

in-place操作可以节省一些内存，但在计算导数时可能会出现问题，因为会立即丢失历史记录。因此，不鼓励使用它们。

与NumPy的关系

CPU上的张量和Numpy数组可以共享底层内存，改变一个就会改变另一个。

张量toNumpy数组

t = torch.ones(5)
print(f"t: {t}")
n = t.numpy()
print(f"n: {n}")
'''
t: tensor([1., 1., 1., 1., 1.])
n: [1. 1. 1. 1. 1.]
'''
t.add_(1)
print(f"t: {t}")
print(f"n: {n}")
'''
t: tensor([2., 2., 2., 2., 2.])
n: [2. 2. 2. 2. 2.]
'''

Numpy数组to张量

n = np.ones(5)
t = torch.from_numpy(n)
np.add(n, 1, out=n)
print(f"t: {t}")
print(f"n: {n}")
'''
t: tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
n: [2. 2. 2. 2. 2.]
'''