Tensores en Pytorch

Un tensor Pytorch es básicamente lo mismo que una array NumPy. Esto significa que no sabe nada sobre el aprendizaje profundo o los gráficos o gradientes computacionales y es solo una array genérica de n dimensiones que se utilizará para el cálculo numérico arbitrario. Sin embargo, la mayor diferencia entre una array NumPy y un tensor PyTorch es que un tensor PyTorch puede ejecutarse en CPU o GPU. Para ejecutar operaciones en la GPU, simplemente envíe el tensor a un tipo de datos cuda usando:

dispositivo = antorcha.dispositivo(“cpu”)

# para crear datos de entrada y salida aleatorios,

# y H es la dimensión oculta; D_out es la dimensión de salida.

N, D_entrada, H, D_salida = 32, 100, 10, 2 

x = torch.randn(N, D_in, device=device, dtype=torch.float) #donde x es un tensor 

En el ejemplo anterior, se puede pensar en x como un tensor de características aleatorias como una entrada para un modelo. Veremos cómo crear tensores, diferentes atributos y operaciones en un tensor en este artículo.

¿Cómo crear un tensor?

Puede crear un tensor usando algunas líneas simples de código como se muestra a continuación.

import torch
V_data = [1, 2, 3, 4, 5]
V = torch.tensor(V_data)
print(V)

Producción: 

tensor([1, 2, 3, 4, 5])

También puede crear un tensor de datos aleatorios con una dimensionalidad dada como:

import torch
  
x = torch.randn((3, 4, 5))
print(x)

Producción :

tensor([[[ 0.8332, -0.2102,  0.0213,  0.4375, -0.9506],
         [ 0.0877, -1.5845, -0.1520,  0.3944, -0.7282],
         [-0.6923,  0.0332, -0.4628, -0.9127, -1.4349],
         [-0.3641, -0.5880, -0.5963, -1.4126,  0.5308]],

        [[ 0.4492, -1.2030,  2.5985,  0.8966,  0.4876],
         [ 0.5083,  1.4515,  0.6496,  0.3407,  0.0093],
         [ 0.1237,  0.3783, -0.7969,  1.4019,  0.0633],
         [ 0.4399,  0.3827,  1.2231, -0.0674, -1.0158]],

        [[-0.2490, -0.5475,  0.6201, -2.2092,  0.8405],
         [ 0.1684, -1.0118,  0.7414, -3.3518, -0.3209],
         [ 0.6543,  0.1956, -0.2954,  0.1055,  1.6523],
         [-0.9872, -2.0118, -1.6609,  1.4072,  0.0632]]])

También puede crear tensores usando las siguientes funciones:

• torch.zeros(): crea un nuevo tensor con todos los elementos, inicializados como ceros.

import torch
  
z= torch.zeros([3,3], dtype=torch.int32)
print(z)

Producción:  

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

• torch.ones() : crea un nuevo tensor con todos los elementos, inicializados como unos.

import torch
  
z = torch.ones([3,3])
print(z)

Producción:

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

• torch.full() y torch.full_like():   estas funciones devuelven un tensor del tamaño requerido lleno con el valor de relleno requerido proporcionado. El prototipo completo de torch.full() es:

Sintaxis: torch.full(size, fill_value, out=Ninguno, dtype=Ninguno, layout=torch.strided, device=Ninguno, require_grad=False)

Y torch.full_like() es:

Sintaxis: torch.full_like(input, fill_value, out=Ninguno, dtype=Ninguno, layout=torch.strided, device=Ninguno, require_grad=False, memory_format=torch.preserve_format)

import torch
  
# example of torch.full()
newTensor= torch.full((4, 3), 3.14,dtype= torch.float32)
print(newTensor)

Producción:

tensor([[3.1400, 3.1400, 3.1400],
        [3.1400, 3.1400, 3.1400],
        [3.1400, 3.1400, 3.1400],
        [3.1400, 3.1400, 3.1400]])

import torch
  
# Example for torch.full_like()
x = torch.full_like(newTensor,3.24, dtype=None )
print(x)

Producción: 

tensor([[3.2400, 3.2400, 3.2400],
        [3.2400, 3.2400, 3.2400],
        [3.2400, 3.2400, 3.2400],
        [3.2400, 3.2400, 3.2400]])

Aquí se devuelve un nuevo Tensor, con el mismo tamaño y tipo que el newTensor que se devolvió anteriormente del método torch.full en el ejemplo que se muestra arriba.

Atributos del tensor:

Cada tensor ( torch.Tensor ) tiene atributos torch.dtype, torch.device y torch.layout . 

• torch.dtype : un torch.dtype es un objeto que representa el tipo de datos de torch.Tensor . PyTorch tiene doce tipos de datos diferentes.
• torch.device : Un torch.device es un objeto que representa el dispositivo en el que se asigna o se asignará un torch.Tensor . El dispositivo torch.device contiene un tipo de dispositivo (‘cpu’ o ‘cuda’) y un ordinal de dispositivo opcional para el tipo de dispositivo.

Ejemplo:

torch.device('cuda:0')

Producción : 

device(type='cuda', index=0)

Si el dispositivo ordinal no está presente, este objeto siempre representará el dispositivo actual para el tipo de dispositivo, incluso después de llamar a torch.cuda.set_device().

• torch.layout: un torch.layout es un objeto que representa el diseño de memoria de un torch.Tensor. Actualmente, la antorcha admite dos tipos de diseño de memoria.

1. torch.strided: representa tensores densos y es el diseño de memoria que se usa más comúnmente. Cada tensor pisado tiene una antorcha asociada . Almacenamiento,que contiene sus datos. Estos tensores brindan una vista multidimensional del almacenamiento. La zancada de una array (también conocida como incremento, paso o tamaño de paso) es el número de ubicaciones en la memoria entre los comienzos de elementos sucesivos de la array, medidos en bytes o en unidades del tamaño de los elementos de la array. El paso no puede ser más pequeño que el tamaño del elemento, pero puede ser más grande, lo que indica espacio adicional entre los elementos. Así que básicamente aquí los Pasos son una lista de números enteros: el k-ésimo paso representa el salto en la memoria necesario para pasar de un elemento al siguiente en la k-ésima dimensión del Tensor. Este concepto hace posible realizar muchas operaciones tensoriales de manera eficiente.

Ejecutemos algunos fragmentos de ejemplo:

x = torch.Tensor([[1, 2, 3, 4], [5, 7, 8, 9]])
x.stride()

Producción:

(4,1)

2. torch.sparse_coo_tensor: se usa para almacenar una array en la lista de coordenadas dispersas. En formato COO, los elementos especificados se almacenan como tuplas de índices de elementos y los valores correspondientes. 

i = [[0, 1, 1],
     [2, 0, 2]]
  
v =  [3, 4, 5]
s = torch.sparse_coo_tensor(i, v, (2, 3))
Print(s)

Producción: 

tensor(indices=tensor([[0, 1, 1],
                       [2, 0, 2]]),
       values=tensor([3, 4, 5]),
       size=(2, 3), nnz=3, layout=torch.sparse_coo)

Operaciones tensoriales:

Puedes sumar dos tensores como la suma de arrays.

x = torch.tensor([1., 2., 3.])
y = torch.tensor([4., 5., 6.])
z = x + y
print(z)

Producción: 

tensor([5., 7., 9.])

• torch.cat() : Concatena una lista de tensores

x_1 = torch.randn(2, 5)
y_1 = torch.randn(3, 5)
z_1 = torch.cat([x_1, y_1])
print(z_1)

Producción: 

tensor([[ 0.5761,  0.6781,  0.1621,  0.4986,  0.3410],
        [-0.8428,  0.2510, -0.2668, -1.1475,  0.5675],
        [-0.2797, -0.0699,  2.8936,  1.8260,  2.1227],
        [ 1.3765, -0.0939, -0.3774, -0.3834,  0.0682],
        [ 2.3666,  0.0904,  0.7956,  1.2281,  0.5561]])

Para concatenar columnas puedes hacer lo siguiente.

x_2 = torch.randn(2, 3)
y_2 = torch.randn(2, 5)
  
# second argument specifies which axis to concat along
z_2 = torch.cat([x_2, y_2], 1)
print(z_2)

Producción:

tensor([[ 0.5818,  0.7047,  0.1581,  1.8658,  0.5953, -0.9453, -0.6395, -0.7106],
        [ 1.2197,  0.8110, -1.6072,  0.1463,  0.4895, -0.8226, -0.1889,  0.2668]])

• view(): Puede remodelar tensores usando el método .view() como se muestra a continuación.

x = torch.randn(2, 3, 4)
print(x)
  
# reshape to 2 rows, 12 columns
print(x.view(2, 12))

Producción:

tensor([[[ 0.4321,  0.2414, -0.4776,  1.6408],
         [ 0.9085,  0.9195,  0.1321,  1.1891],
         [-0.9267, -0.1384,  0.0115, -0.4731]],

        [[ 0.7256,  0.6990, -1.7374,  0.6053],
         [ 0.0224, -1.2108,  0.1974,  0.0655],
         [-0.6182, -0.0797,  0.2603, -1.3280]]])
tensor([[ 0.4321,  0.2414, -0.4776,  1.6408,  0.9085,  0.9195,  0.1321,  1.1891,
         -0.9267, -0.1384,  0.0115, -0.4731],
        [ 0.7256,  0.6990, -1.7374,  0.6053,  0.0224, -1.2108,  0.1974,  0.0655,
         -0.6182, -0.0797,  0.2603, -1.3280]])

• torch.argmax(): Devuelve el índice del valor máximo de todos los elementos en el tensor de entrada.

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

Producción: 

(tensor([[ 1.9610, -0.7683, -2.6080],
        [-0.3659, -0.1731,  0.1061],
        [ 0.8582,  0.6420, -0.2380]]), tensor(0))

• torch.argmin(): similar a argmax(), devuelve el valor mínimo de todos los elementos en el tensor de entrada.

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

Producción: 

(tensor([[ 0.9838, -1.2761,  0.2257],
        [-0.4754,  1.2677,  1.1973],
        [-1.2298, -0.5710, -1.3635]]), tensor(8))