Crear un tensor en Pytorch

Todo el aprendizaje profundo son cálculos sobre tensores, que son generalizaciones de una array que se puede indexar en más de 2 dimensiones. Los tensores se pueden crear a partir de listas de Python con la función torch.tensor().

El método tensor():

Para crear tensores con Pytorch, simplemente podemos usar el método tensor():

Sintaxis: 

torch.tensor(Data)

Ejemplo:

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

Producción: 

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

Para crear una array podemos usar:

import torch
  
M_data = [[1., 2., 3.], [4, 5, 6]]
M = torch.tensor(M_data)
print(M)

Producción: 

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

Para crear un tensor 3D, puede usar la siguiente plantilla de código:

import torch
  
T_data = [[[1., 2.], [3., 4.]],
          [[5., 6.], [7., 8.]]]
T = torch.tensor(T_data)
print(T)

Producción: 

tensor([[[1., 2.],
         [3., 4.]],

        [[5., 6.],
         [7., 8.]]])

Sin embargo, si ejecutamos el siguiente código:

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

Producción: 

ValueError: expected sequence of length 2 at dim 1 (got 3)

Esto sucede porque los tensores son básicamente arrays y no pueden tener un número desigual de elementos en cada dimensión.

El método randint():

El método randint() devuelve un tensor lleno de enteros aleatorios generados uniformemente entre bajo (inclusivo) y alto (exclusivo) para una forma dada. La forma la da el usuario, que puede ser una tupla o una lista con miembros no negativos. El valor predeterminado para low es 0. Cuando solo se pasa un argumento int, low obtiene el valor 0 de forma predeterminada y high obtiene el valor pasado. Al igual que zeros(), una tupla o lista vacía para la forma crea un tensor con dimensión cero.

Syntax: torch.randint(<low>,<high>,<shape>)

Ejemplo:

import torch
  
randint_tensor = torch.randint(5, (3,3))
print(randint_tensor)

Producción:

tensor([[3, 2, 3],
        [4, 4, 0],
        [3, 3, 4]])

El método complejo():

El método complex() toma dos argumentos ( real e imag ) y devuelve un tensor complejo con su parte real igual a real y su parte imaginaria igual a imag donde tanto real como imag son tensores que tienen el mismo tipo de datos y la misma forma.

Sintaxis: torch.complex(<tensor real>,<otro tensor real que se utilizará como parte imaginaria>)

Ejemplo:

import torch
  
real = torch.rand(2, 2)
print(real)
imag = torch.rand(2, 2)
print(imag)
complex_tensor = torch.complex(real, imag)
print(complex_tensor)

Producción:

tensor([[0.7655, 0.7181],
        [0.8479, 0.0369]])
tensor([[0.5604, 0.0012],
        [0.6316, 0.6574]])
tensor([[0.7655+0.5604j, 0.7181+0.0012j],
        [0.8479+0.6316j, 0.0369+0.6574j]])

El método ojo():

El método eye() devuelve un tensor 2-D con unos en la diagonal y ceros en otros lugares (array de identidad) para una forma dada (n,m) donde n y m no son negativos. El número de filas está dado por n y el de columnas está dado por m. El valor predeterminado para m es el valor de n y cuando solo se pasa n, crea un tensor en forma de array de identidad.

Syntax: torch.eye(<n,m or the shape>)

Ejemplo:

import torch
  
n = m = 3
eye_tensor = torch.eye(n, m)
print(eye_tensor)

Producción:

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

El método ceros() :

Este método se puede usar cuando necesita un tensor donde todos los elementos son ceros, de una forma específica. La forma se puede dar como una tupla o una lista o ninguna. Si pasa una tupla vacía o una lista vacía, el método zeros() devuelve un tensor de forma (dimensión) 0, que tiene 0 como único elemento, cuyo tipo de datos es flotante. Los números negativos o flotantes no se pueden pasar como una forma.

Sintaxis: 

torch.zero(D1,D2)

Here,
D1: It represents the horizontal dimension of the tensor.
D2: It represents the vertical dimension of the tensor.

Ejemplo:

import torch
  
zeros_tensor = torch.zeros(3,2)
print(zeros_tensor)

Producción: 

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

El método random():

El método rand() devuelve un tensor lleno de números aleatorios de una distribución uniforme en el intervalo 0 (inclusive) a 1 (exclusivo) para una forma determinada. La forma la da el usuario y se puede dar como una tupla, una lista o ninguna. Similar a zeros() y ones(), pasar una tupla o lista vacía crea un tensor escalar de dimensión cero. Al igual que zeros(), el argumento de la forma solo toma una tupla o una lista con miembros no negativos. Una tupla o lista vacía crea un tensor con dimensión cero.

El método rand() se puede utilizar para establecer pesos y sesgos aleatorios en una red neuronal.

Syntax: torch.rand(<shape>)

import torch
  
rand_tensor = torch.rand(3, 3)
print(rand_tensor)

Producción:

tensor([[0.6307, 0.7281, 0.0130],
        [0.7359, 0.0241, 0.2845],
        [0.2154, 0.3773, 0.6545]])

El método ones():

Similar a zeros(), ones() devuelve un tensor donde todos los elementos son 1, de tamaño (forma) especificado.

Syntax: torch.tensor(<shape>)

Ejemplo:

import torch
  
ones_tensor = torch.ones((4,4,4))
print(ones_tensor)

Producción: 

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

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]],

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]],

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]]])

El método arange():

El método arange() se usa para obtener un tensor 1-D (array de filas), con elementos desde el inicio (incluido) hasta el final (exclusivo) con un paso de diferencia común (el valor predeterminado para el inicio es 0 mientras que para el paso es 1 ). Se puede decir que los elementos del tensor están en progresión aritmética, con el paso dado como diferencia común. Los tres parámetros, inicio, final y paso pueden ser positivos, negativos o flotantes.

Syntax: torch.arange(<start>,<end>,<step-size>)

Ejemplo:

import torch
  
arange_tensor = torch.arange(2, 20, 2)
print(arange_tensor)

Producción:

 tensor([ 2,  4,  6,  8, 10, 12, 14, 16, 18])

El método completo():

El método full() se usa cuando necesitamos un tensor de una forma dada por el argumento de la forma, con todos sus elementos iguales al valor de relleno dado por el usuario. Nuevamente, pasar una tupla o lista vacía crea un tensor escalar de dimensión cero. Al usar full, es necesario darle forma como una tupla o una lista (que puede estar vacía), o arroja un error. Además, los miembros de la lista de formas no pueden ser negativos ni flotantes.

Syntax: torch.full(<shape>,<value to be filled with>)

Ejemplo:

import torch
  
full_tensor = torch.full((3,2), 3)
print(full_tensor)

Producción:

tensor([[3, 3],
        [3, 3],
        [3, 3]])

El método linspace():

El método linspace() también devuelve un tensor dimensional 1-D (array de fila), con elementos desde el inicio (inclusive) hasta el final (inclusive). Sin embargo, a diferencia de arange(), pasamos la cantidad de elementos que necesitamos en nuestro tensor 1D en lugar de pasar el tamaño del paso (como se muestra arriba). Pytorch calcula el paso automáticamente para los valores iniciales y finales dados. Es comprensible que el número de elementos solo pueda ser un número entero no negativo.

Syntax: torch.linspace(<start> , <end>, <number of elements>)

Ejemplo:

import torch
  
linspace_tensor = torch.linspace(1, 7.75, 4)
print(linspace_tensor)

Producción: 

tensor([ 1.0000,  3.2500,  5.5000,  7.7500])

A diferencia de arange() , en linspace() podemos tener un inicio mayor que el final ya que la diferencia común se calcula automáticamente.

Tensor([[0.6307, 0.7281, 0.0130],
        [0.7359, 0.0241, 0.2845],
        [0.2154, 0.3773, 0.6545]])

Y así es como podemos crear tensores en PyTorch.