[Marco de Pytorch] 2.1.1 Conceptos básicos de PyTorch: Tensor

Conceptos básicos de PyTorch: tensores

En el primer capítulo, ya tenemos una cierta comprensión de PyTorch a través del tutorial introductorio oficial.Este capítulo presentará los conocimientos básicos de PyTorch en detalle.
Una vez que haya dominado todos estos conocimientos básicos, podrá avanzar más rápidamente en las siguientes aplicaciones. Si ya tiene un cierto conocimiento de PyTorch, puede omitir este capítulo.

# 首先要引入相关的包
import torch
import numpy as np
#打印一下版本
torch.__version__

'1.0.0'

Tensor

El inglés del tensor es Tensor, que es la unidad de operación básica en PyTorch. Es el mismo que el ndarray de Numpy y representa una matriz multidimensional.
La mayor diferencia con ndarray es que PyTorch's Tensor puede ejecutarse en la GPU, mientras que ndarray de numpy solo puede ejecutarse en la CPU. La ejecución en la GPU acelera enormemente el cálculo.

A continuación generamos un tensor simple

x = torch.rand(2, 3)
x

tensor([[0.6904, 0.7419, 0.8010],
        [0.1722, 0.2442, 0.8181]])

Lo anterior generó una matriz con 2 filas y 3 columnas. Veamos su tamaño:

# 可以使用与numpy相同的shape属性查看
print(x.shape)
# 也可以使用size()函数，返回的结果都是相同的
print(x.size())

torch.Size([2, 3])
torch.Size([2, 3])

Tensor es un mapeo lineal múltiple definido en el producto cartesiano de algunos espacios vectoriales y algunos espacios duales. Sus coordenadas están en | n | espacio dimensional y una cantidad con | n | componentes, donde cada Cada componente es una función de coordenadas, y durante transformación de coordenadas, estos componentes también se transforman linealmente de acuerdo con ciertas reglas. r se llama rango u orden del tensor (no tiene nada que ver con el rango y orden de la matriz). (De la enciclopedia Baidu)

Generemos algunos tensores multidimensionales:

y=torch.rand(2,3,4,5)
print(y.size())
y

torch.Size([2, 3, 4, 5])





tensor([[[[0.9071, 0.0616, 0.0006, 0.6031, 0.0714],
          [0.6592, 0.9700, 0.0253, 0.0726, 0.5360],
          [0.5416, 0.1138, 0.9592, 0.6779, 0.6501],
          [0.0546, 0.8287, 0.7748, 0.4352, 0.9232]],

         [[0.0730, 0.4228, 0.7407, 0.4099, 0.1482],
          [0.5408, 0.9156, 0.6554, 0.5787, 0.9775],
          [0.4262, 0.3644, 0.1993, 0.4143, 0.5757],
          [0.9307, 0.8839, 0.8462, 0.0933, 0.6688]],

         [[0.4447, 0.0929, 0.9882, 0.5392, 0.1159],
          [0.4790, 0.5115, 0.4005, 0.9486, 0.0054],
          [0.8955, 0.8097, 0.1227, 0.2250, 0.5830],
          [0.8483, 0.2070, 0.1067, 0.4727, 0.5095]]],

​

        [[[0.9438, 0.2601, 0.2885, 0.5457, 0.7528],
          [0.2971, 0.2171, 0.3910, 0.1924, 0.2570],
          [0.7491, 0.9749, 0.2703, 0.2198, 0.9472],
          [0.1216, 0.6647, 0.8809, 0.0125, 0.5513]],

         [[0.0870, 0.6622, 0.7252, 0.4783, 0.0160],
          [0.7832, 0.6050, 0.7469, 0.7947, 0.8052],
          [0.1755, 0.4489, 0.0602, 0.8073, 0.3028],
          [0.9937, 0.6780, 0.9425, 0.0059, 0.0451]],

         [[0.3851, 0.8742, 0.5932, 0.4899, 0.8354],
          [0.8577, 0.3705, 0.0229, 0.7097, 0.7557],
          [0.1505, 0.3527, 0.0843, 0.0088, 0.8741],
          [0.6041, 0.8797, 0.6189, 0.9495, 0.1479]]]])

En el sentido de isomorfismo, el tensor de orden cero (r = 0) es un escalar (Escalar), el tensor de primer orden (r = 1) es un vector (Vector) y el tensor de segundo orden (r = 2) es Become una matriz (Matrix), el tercer orden y superiores se denominan colectivamente tensor multidimensional.

Una cosa a la que hay que prestar especial atención es el escalar, primero generamos un escalar:

#我们直接使用现有数字生成
scalar =torch.tensor(3.1433223)
print(scalar)
#打印标量的大小
scalar.size()

tensor(3.1433)





torch.Size([])

Para escalar, podemos usar directamente .item () para recuperar el valor del objeto python correspondiente

scalar.item()

3.143322229385376

Especial: si el tensor con un solo elemento en el tensor también puede llamar al tensor.itemmétodo

tensor = torch.tensor([3.1433223]) 
print(tensor)
tensor.size()

tensor([3.1433])





torch.Size([1])

tensor.item()

3.143322229385376

tipo básico

Hay cinco tipos de datos básicos de Tensor:

• Tipo de coma flotante de 32 bits: antorcha.FloatTensor. (defecto)
• Entero de 64 bits: antorcha.LongTensor.
• Entero de 32 bits: antorcha.IntTensor.
• Entero de 16 bits: antorcha.ShortTensor.
• Tipo de coma flotante de 64 bits: antorcha. DoubleTensor.

Además de los tipos numéricos anteriores, existen tipos de
bytes y gráficos

long=tensor.long()
long

tensor([3])

half=tensor.half()
half

tensor([3.1426], dtype=torch.float16)

int_t=tensor.int()
int_t

tensor([3], dtype=torch.int32)

flo = tensor.float()
flo

tensor([3.1433])

short = tensor.short()
short

tensor([3], dtype=torch.int16)

ch = tensor.char()
ch

tensor([3], dtype=torch.int8)

bt = tensor.byte()
bt

tensor([3], dtype=torch.uint8)

Gran conversión

Use el método numpy para convertir Tensor a ndarray

a = torch.randn((3, 2))
# tensor转化为numpy
numpy_a = a.numpy()
print(numpy_a)

[[ 0.46819344  1.3774964 ]
 [ 0.9491934   1.4543315 ]
 [-0.42792308  0.99790514]]

Convertir numpy en tensor

torch_a = torch.from_numpy(numpy_a)
torch_a

tensor([[ 0.4682,  1.3775],
        [ 0.9492,  1.4543],
        [-0.4279,  0.9979]])

Los objetos tensor y numpy comparten memoria, por lo que la conversión entre ellos es rápida y casi no consume recursos. Pero esto también significa que si uno de ellos cambia, el otro también cambiará.

Cambiar entre dispositivos

En circunstancias normales, puedes usar el método .cuda para mover el tensor a gpu. Este paso requiere compatibilidad con el dispositivo cuda

cpu_a=torch.rand(4, 3)
cpu_a.type()

'torch.FloatTensor'

gpu_a=cpu_a.cuda()
gpu_a.type()

'torch.cuda.FloatTensor'

Utilice el método .cpu para mover el tensor a la cpu

cpu_b=gpu_a.cpu()
cpu_b.type()

'torch.FloatTensor'

Si tenemos varias GPU, podemos usar el método to para determinar qué dispositivo usar. Aquí hay un ejemplo simple:

#使用torch.cuda.is_available()来确定是否有cuda设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)
#将tensor传送到设备
gpu_b=cpu_b.to(device)
gpu_b.type()

cuda





'torch.cuda.FloatTensor'

inicialización

Hay muchos métodos de inicialización predeterminados disponibles en Pytorch

# 使用[0,1]均匀分布随机初始化二维数组
rnd = torch.rand(5, 3)
rnd

tensor([[0.3804, 0.0297, 0.5241],
        [0.4111, 0.8887, 0.4642],
        [0.7302, 0.5913, 0.7182],
        [0.3048, 0.8055, 0.2176],
        [0.6195, 0.1620, 0.7726]])

##初始化，使用1填充
one = torch.ones(2, 2)
one

tensor([[1., 1.],
        [1., 1.]])

##初始化，使用0填充
zero=torch.zeros(2,2)
zero

tensor([[0., 0.],
        [0., 0.]])

#初始化一个单位矩阵，即对角线为1 其他为0
eye=torch.eye(2,2)
eye

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

Método común

La operación api para tensores en PyTorch es muy similar a NumPy. Si está familiarizado con las operaciones en NumPy, entonces las dos son básicamente las mismas:

x = torch.randn(3, 3)
print(x)

tensor([[ 0.6922, -0.4824,  0.8594],
        [ 0.4509, -0.8155, -0.0368],
        [ 1.3533,  0.5545, -0.0509]])

# 沿着行取最大值
max_value, max_idx = torch.max(x, dim=1)
print(max_value, max_idx)

tensor([0.8594, 0.4509, 1.3533]) tensor([2, 0, 0])

# 每行 x 求和
sum_x = torch.sum(x, dim=1)
print(sum_x)

tensor([ 1.0692, -0.4014,  1.8568])

y=torch.randn(3, 3)
z = x + y
print(z)

tensor([[-0.3821, -2.6932, -1.3884],
        [ 0.7468, -0.7697, -0.0883],
        [ 0.7688, -1.3485,  0.7517]])

Como se indica en el tutorial oficial de 60 minutos, todos aquellos que terminen con _ cambiarán el valor de la llamada

# add 完成后x的值改变了
x.add_(y)
print(x)

tensor([[-0.3821, -2.6932, -1.3884],
        [ 0.7468, -0.7697, -0.0883],
        [ 0.7688, -1.3485,  0.7517]])

Las operaciones básicas de los tensores están casi introducidas. El siguiente capítulo presenta el mecanismo de derivación automática de PyTorch