Búsqueda de sitios web

Creando un tensor en Pytorch


<h2>¿Qué es Pytorch? <p>Pytorch es un marco de aprendizaje automático basado en Python que se utiliza principalmente para cálculos científicos y para crear modelos de aprendizaje profundo.

Un tensor es un concepto popular en el aprendizaje automático y la ciencia de datos. Los tensores son un término generalizado para matrices y vectores. En palabras simples, los tensores pueden ser cualquier cosa: una matriz de n dimensiones, un vector o una matriz. En este artículo, veremos los múltiples métodos utilizados para crear tensores en Pytorch.

Método de creación de tensores

Los tensores se pueden crear mediante varios métodos. Algunos de los métodos importantes se enumeran a continuación.

  • Creando un tensor usando unos

  • Creando un tensor usando ceros

  • Creando un tensor usando arange

  • Creando un tensor usando rand()

  • Creando un tensor usando full()

  • Creando un tensor usando linspace

  • Creando un tensor usando randint()

  • Creando un tensor usando el método eye()

  • Creando un tensor usando el método tensor

  • creando un tensor usando un método complejo

Como paso inicial, primero debemos importar la antorcha antes de pasar a los diferentes métodos de creación de tensores.

Sintaxis

#importing torch
import torch

Método 1: crear un tensor usando unos()

Usando la función ones(), el tensor se crea de modo que todos sus elementos se establezcan en 1.

Escribamos un código en programación Python para crear un tensor usando la función ones().

Ejemplo

#creating a tensor using ones()
tensor_using_ones = torch.ones(4,4,5)
#prints the created tensor
print(tensor_using_ones)

Producción

Podemos ver en el resultado siguiente que el tensor recién creado tiene todas las entradas configuradas en "1" en la forma (4,4,5).

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., 1.],
      [1., 1., 1., 1., 1.],
      [1., 1., 1., 1., 1.],
      [1., 1., 1., 1., 1.]]])       

Método 2: crear un tensor usando ceros()

Usamos la función zeros() para crear un tensor que tiene todos sus elementos establecidos en 0. Usando esto, los valores se pueden pasar como una lista, una tupla o valores vacíos. Los tensores se pueden crear de cualquiera de estas formas.

Usando la función zeros(), el tensor se crea de manera que todos sus elementos se establezcan en 0.

Ejemplo

#creating a tensor using zeros()
tensor_using_zeros = torch.zeros(4,4,5)
#prints the created tensor
print(tensor_using_zeros)

Producción

Podemos ver en el resultado siguiente que el tensor recién creado tiene todas las entradas configuradas en "0" en la forma (4,4,5).

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

Método 3: Crear un tensor usando arange() – Ejemplo 1

La función arange() se utiliza para crear un tensor unidimensional (1D).

Sintaxis

La función arange() tiene la siguiente sintaxis.

torch.arange(start,end,step-size)

dónde,

inicio - es inclusivo

final - es exclusivo de la forma especificada

Escribimos un código en Python para crear un tensor 1-D con las especificaciones de forma (5,30,2).

Ejemplo

#creating a tensor using arange
tensor_using_arange = torch.arange(5, 30,2)
#prints the created tensor
print(tensor_using_arange)

Producción

Aquí, se crea un tensor unidimensional con el elemento inicial como 5, el elemento final como 29 (es decir, 30-1) con una diferencia común (paso) de "2".

tensor([ 5,  7,  9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29])

Método 4: Crear un tensor usando arange() - Ejemplo 2

Veamos otro ejemplo de creación de un tensor en Pytorch donde el valor inicial es negativo, es decir, -5 y un paso de "1".

Escribimos un código en Python para crear un tensor 1-D con las especificaciones de forma (-5,25,1).

Ejemplo

#creating a tensor using arange
tensor_using_arange1 = torch.arange(-5, 25,1)
#prints the created tensor
print(tensor_using_arange1)

Producción

Aquí, se crea un tensor unidimensional con el elemento inicial como -5, el elemento final como 24 (es decir, 25-1) con una diferencia común (paso) de "1".

tensor([-5, -4, -3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24])

Método 5: crear un tensor usando rand()

Otro método comúnmente utilizado para crear un tensor en Python es el método rand(). Se creará un tensor que contiene números aleatorios utilizando el método rand() para la forma especificada.

Sintaxis

La sintaxis del método rand() se muestra a continuación:

torch.rand(shape)

Ejemplo

Ahora, para comprender la creación de un tensor usando el método rand(), escribamos un código en programación Python.

#creating a tensor using rand()
tensor_using_rand = torch.rand(5, 5)
#prints the created tensor
print(tensor_using_rand)

Producción

Podemos ver en el resultado siguiente que se crea un tensor de forma 5X5 utilizando el método rand(). Los elementos dentro del tensor son números aleatorios de distribución uniforme.

tensor(
   [[0.2000, 0.6068, 0.3968, 0.6269, 0.8587],
   [0.1754, 0.5050, 0.8569, 0.5139, 0.9026],
   [0.2634, 0.6543, 0.3015, 0.6873, 0.2214],
   [0.9257, 0.6045, 0.4763, 0.5107, 0.7925],
   [0.7465, 0.0279, 0.4937, 0.0989, 0.8806]])

Método 6: crear un tensor usando full()

El método full() en Tensor se usa siempre que se prefiere que los elementos en un Tensor sean el mismo número.

Sintaxis

La sintaxis del método full() es la siguiente.

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

dónde,

fill_value: es el valor (mismo número) que queremos que esté en el tensor.

Supongamos que queremos crear un tensor que tenga el mismo número (4) que todos los elementos. Podemos escribir el código en programación Python como se muestra a continuación. Fill_value se especifica como 4. Ese es el valor que será el elemento común en el tensor.

Ejemplo

#creating a tensor using full method
tensor1 = torch.full((5,5,4)
#prints the created tensor
print(tensor1)

Producción

Para el código anterior, damos un tensor con una matriz de 5X5 con 4 como todos los elementos.

tensor([[4, 4, 4, 4, 4],
      [4, 4, 4, 4, 4],
      [4, 4, 4, 4, 4],
      [4, 4, 4, 4, 4],
      [4, 4, 4, 4, 4]])

Método 7: crear un tensor usando linspace

Sintaxis

El método Linspace() tiene la siguiente sintaxis.

linspace (start, stop, num, endpoint=True, retstep=False, dtype=None, axis=0)

dónde,

bajo - elemento inicial(inclusive)

elemento de alta gama (incluido)

num- número de elementos que se generarán en el tensor

Ejemplo

Usamos el método Linspace() para crear un tensor unidimensional (1D). La forma que especificamos, por ejemplo, en este caso es (2,20,4). En nuestro ejemplo, 2 es el elemento inicial, 20 es el elemento final y 4 es el número de elementos que estarán presentes en el tensor 1-D.

#creating a tensor using linspace
tensor_using_linspace = torch.linspace(2, 20, 4)
#prints the created tensor
print(tensor_using_linspace)

Producción

Podemos ver que el código anterior produce el siguiente resultado donde se crea un tensor 1-D con 4 elementos.

tensor([ 2.,  8., 14., 20.])

Método 8: crear un tensor usando randint()

El método randint() crea un tensor con números enteros aleatorios generados según la forma especificada.

Sintaxis

torch.randint(low,high,shape)

dónde,

bajo - elemento inicial(inclusive)

elemento de alta gama (exclusivo)

forma - forma del tensor

Ejemplo

Escribimos un código Python usando los métodos randint() como se muestra a continuación.

#creating a tensor using randint
tensor_using_randint = torch.randint(10,100, (2,2))
#prints the created tensor
print(tensor_using_randint)

Producción

En el siguiente resultado, vemos un tensor con elementos aleatorios generados entre la forma (10,100, (5,5)). Aquí obtenemos un tensor con elementos aleatorios entre 10 y 99 en forma de matriz de 5X5.

tensor([[71, 32, 56, 34, 21],
      [37, 71, 98, 63, 40],
      [41, 45, 27, 41, 50],
      [51, 42, 43, 71, 14],
      [87, 52, 77, 88, 85]])

Método 9: crear un tensor usando eye()

El método eye() es útil cuando queremos crear un Tensor 2D donde los elementos de la diagonal son 1 y ceros como el resto de elementos.

Sintaxis

torch.eye (shape)

Ahora, escribimos un código Python usando el método eye().

Ejemplo 1

#creating a tensor using eye
tensor1_using_eye = torch.eye(4, 4)
#prints the created tensor
print(tensor1_using_eye)

Producción

Ahora hemos creado un tensor 2D 4X4 usando el método eye().

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

Veamos otro ejemplo de creación de un tensor usando la función ocular.

Ejemplo-2

#creating a tensor using eye
tensor2_using_eye = torch.eye(3)
#prints the created tensor
print(tensor2_using_eye)

Producción

Ahora hemos creado un tensor 2D 3X3 usando el método eye() como se muestra en el siguiente resultado.

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

Método 10: crear un tensor utilizando el método Complex()

El método complejo() es el último método que veremos. Se utiliza para crear un Tensor Complejo donde el Tensor creado tendrá tanto una parte imaginaria como una parte real.

Sintaxis

El método complex() tiene la siguiente sintaxis.

torch.complex(real part, imaginary part)

Ejemplo

El código para el método complex() se escribe a continuación.

real_tensor = torch.rand(4,5)
print(real_tensor)
imaginary_tensor = torch.rand(4, 5)
print(imaginary_tensor)
tensor_using_complex = torch.complex(real_tensor, imaginary_tensor)
#prints created tensor
print(tensor_using_complex )

Producción

Así, hemos creado un tensor complejo que tiene la parte imaginaria y la parte real de forma 4X5.

Tensor([[0.8284, 0.7833, 0.4952, 0.7634, 0.9098],
      [0.6373, 0.3428, 0.0352, 0.6095, 0.8066],
      [0.7292, 0.0703, 0.3846, 0.6653, 0.1924],
      [0.2920, 0.2676, 0.4669, 0.2841, 0.5974]])
tensor([[0.5236, 0.9037, 0.7622, 0.7044, 0.3362],
      [0.8543, 0.6088, 0.4882, 0.0563, 0.9318],
      [0.7075, 0.1176, 0.6272, 0.3318, 0.3751],
      [0.6317, 0.1482, 0.3772, 0.6941, 0.9126]])
tensor([[0.8284+0.5236j, 0.7833+0.9037j, 0.4952+0.7622j, 0.7634+0.7044j, 0.9098+0.3362j],
      [0.6373+0.8543j, 0.3428+0.6088j, 0.0352+0.4882j, 0.6095+0.0563j, 0.8066+0.9318j],
      [0.7292+0.7075j, 0.0703+0.1176j, 0.3846+0.6272j, 0.6653+0.3318j, 0.1924+0.3751j],
      [0.2920+0.6317j, 0.2676+0.1482j, 0.4669+0.3772j, 0.2841+0.6941j, 0.5974+0.9126j]])     

Conclusión

De este artículo, hemos aprendido varias formas de crear tensores en Pytorch. Te recomendamos que eches un vistazo también a nuestros artículos.