Capítulo 1. Primeros pasos con PyTorch

Este trabajo se ha traducido utilizando IA. Agradecemos tus opiniones y comentarios: translation-feedback@oreilly.com

En este capítulo establecemos todo lo que necesitamos para trabajar con PyTorch. Una vez que lo hayamos hecho, todos los capítulos siguientes se basarán en esta base inicial, así que es importante que lo hagamos bien. Esto nos lleva a nuestra primera pregunta fundamental: ¿deberías construir un ordenador de aprendizaje profundo personalizado o simplemente utilizar uno de los muchos recursos disponibles basados en la nube?

Construir una máquina de aprendizaje profundo personalizada

Cuando te sumerges en el aprendizaje profundo, sientes la necesidad de construirte un monstruo para todas tus necesidades informáticas. Puedes pasarte días examinando distintos tipos de tarjetas gráficas, aprendiendo los carriles de memoria que te ofrecerán las posibles selecciones de CPU, el mejor tipo de memoria que puedes comprar y el tamaño de una unidad SSD que puedes adquirir para que el acceso a tu disco sea lo más rápido posible. No pretendo ninguna inmunidad ante esto; hace un par de años me pasé un mes haciendo una lista de piezas y construyendo un ordenador nuevo en la mesa de mi comedor.

Mi consejo, especialmente si eres nuevo en el aprendizaje profundo, es el siguiente: no lo hagas. Puedes gastarte fácilmente varios miles de dólares en una máquina que quizá no utilices demasiado. En lugar de eso, te recomiendo que trabajes en este libro utilizando recursos en la nube (ya sea en Amazon Web Services, Google Cloud o Microsoft Azure) y sólo entonces empieces a pensar en construir tu propia máquina si crees que necesitas una sola máquina para trabajar 24 horas al día, 7 días a la semana. No necesitas hacer una inversión masiva en hardware para ejecutar ninguno de los códigos de este libro.

Puede que nunca necesites construirte una máquina a medida. Hay una especie de punto dulce, en el que puede ser más barato construir un equipo a medida si sabes que tus cálculos siempre van a limitarse a una sola máquina (con un puñado de GPU como máximo). Sin embargo, si tu cálculo empieza a requerir abarcar varias máquinas y GPUs, la nube vuelve a ser atractiva. Teniendo en cuenta el coste de montar una máquina a medida, yo me lo pensaría mucho antes de lanzarme.

Si no he conseguido disuadirte de que construyas el tuyo propio, en las secciones siguientes encontrarás sugerencias sobre lo que necesitarías para hacerlo.

GPU

El corazón de toda caja de aprendizaje profundo, la GPU, es lo que va a alimentar la mayoría de los cálculos de PyTorch, y probablemente será el componente más caro de tu máquina. En los últimos años, los precios de las GPU han aumentado, y los suministros han disminuido, debido a su uso en la minería de criptomonedas como Bitcoin. Afortunadamente, esa burbuja parece estar retrocediendo, y los suministros de GPUs vuelven a ser un poco más abundantes.

En el momento de escribir esto, recomiendo obtener la NVIDIA GeForce RTX 2080 Ti. Para una opción más barata, puedes optar por la 1080 Ti (aunque si estás sopesando la decisión de conseguir la 1080 Ti por razones presupuestarias, te sugiero de nuevo que busques opciones en la nube). Aunque existen tarjetas GPU fabricadas por AMD, su soporte en PyTorch no es actualmente lo suficientemente bueno como para recomendar otra cosa que no sea una tarjeta NVIDIA. Pero estate atento a su tecnología ROCm, que con el tiempo debería convertirla en una alternativa creíble en el espacio de las GPU.

CPU/Tarjeta madre

Probablemente querrás optar por una placa base de la serie Z370 de . Mucha gente te dirá que la CPU no importa para el aprendizaje profundo y que puedes arreglártelas con una CPU de menor velocidad siempre que tengas una GPU potente. Según mi experiencia, te sorprenderá la frecuencia con la que la CPU puede convertirse en un cuello de botella, especialmente cuando se trabaja con datos aumentados.

RAM

Más RAM es bueno, ya que significa que puedes guardar más datos sin tener que recurrir al almacenamiento en disco, mucho más lento (especialmente importante durante tus etapas de entrenamiento). Deberías buscar un mínimo de 64 GB de memoria DDR4 para tu máquina.

Almacenamiento

El almacenamiento para un equipo personalizado debe instalarse en dos clases: en primer lugar, una unidad de estado sólido (SSD) con interfaz M2 -tan grande como puedas permitirte- para tus datos calientes, a fin de mantener el acceso lo más rápido posible cuando estés trabajando activamente en un proyecto. Para la segunda clase de almacenamiento, añade una unidad Serial ATA (SATA) de 4 TB para los datos en los que no estés trabajando activamente, y transfiérelos al almacenamiento caliente y frío según sea necesario.

Te recomiendo que eches un vistazo a PCPartPicker para echar un vistazo a las máquinas de aprendizaje profundo de otras personas (¡también puedes ver todas las ideas de carcasas extrañas y salvajes!). Te harás una idea de las listas de piezas de las máquinas y los precios asociados, que pueden fluctuar mucho, especialmente en el caso de las tarjetas GPU.

Ahora que has examinado las opciones de tu máquina física local, es el momento de dirigirte a las nubes.

Aprendizaje profundo en la nube

Vale, ¿te preguntarás por qué es mejor la opción de la nube? ¿Especialmente si has mirado el esquema de precios de Amazon Web Services (AWS) y has calculado que construir una máquina de aprendizaje profundo se amortizará en seis meses? Piénsalo: si estás empezando, no vas a utilizar esa máquina 24 horas al día, 7 días a la semana, durante esos seis meses. Simplemente no lo harás. Lo que significa que puedes apagar la máquina en la nube y pagar céntimos por los datos almacenados mientras tanto.

Y si estás empezando, no necesitas ir a por todas y utilizar una de las tarjetas leviatán Tesla V100 de NVIDIA conectada a tu instancia en la nube de inmediato. Puedes empezar con una de las instancias mucho más baratas (a veces incluso gratuitas) basadas en K80 y pasar a la tarjeta más potente cuando estés preparado. Eso es un poco menos caro que comprar una tarjeta GPU básica y actualizarla a una 2080Ti en tu caja personalizada. Además, si quieres añadir ocho tarjetas V100 a una sola instancia, puedes hacerlo con unos pocos clics. Intenta hacer eso con tu propio hardware.

La otra cuestión es el mantenimiento. Si adquieres el buen hábito de volver a crear tus instancias en la nube con regularidad (lo ideal sería empezar de nuevo cada vez que vuelvas a trabajar en tus experimentos), casi siempre tendrás una máquina actualizada. Si tienes tu propia máquina, la actualización depende de ti. Aquí es donde confieso que tengo mi propia máquina de aprendizaje profundo personalizada, e ignoré la instalación de Ubuntu en ella durante tanto tiempo que se quedó sin actualizaciones compatibles, lo que me llevó a pasarme un día intentando que el sistema volviera a recibir actualizaciones. Qué vergüenza.

En fin, has tomado la decisión de pasarte a la nube. ¡Hurra! A continuación: ¿qué proveedor?

Colaboratorio Google

Pero espera, antes de hablar de proveedores, ¿qué pasa si no quieres hacer nada? ¿Nada de esa molesta construcción de una máquina o tener que pasar por todas las molestias de configurar instancias en la nube? ¿Dónde está la opción realmente perezosa? Google tiene lo que necesitas. Colaboratory (o Colab) es un entorno personalizado de Jupyter Notebook prácticamente gratuito y que no requiere instalación. Necesitarás una cuenta de Google para configurar tus propios cuadernos. La Figura 1-1 muestra una captura de pantalla de un cuaderno creado en Colab.

Lo que hace que Colab sea una forma estupenda de sumergirse en el aprendizaje profundo es que incluye versiones preinstaladas de TensorFlow y PyTorch, por lo que no tienes que hacer ninguna configuración más allá de escribir import torch , y cada usuario puede obtener acceso gratuito a una GPU NVIDIA T4 para hasta 12 horas de tiempo de ejecución continuo. Gratis. Para ponerlo en contexto, la investigación empírica sugiere que obtienes aproximadamente la mitad de velocidad que una 1080 Ti para entrenamiento, pero con 5 GB extra de memoria para que puedas almacenar modelos más grandes. También ofrece la posibilidad de conectarse a GPU más recientes y al hardware TPU personalizado de Google en una opción de pago, pero prácticamente puedes hacer todos los ejemplos de este libro por nada con Colab. Por ese motivo, te recomiendo que utilices Colab junto con este libro para empezar, y luego puedes decidir si te pasas a instancias dedicadas en la nube y/o a tu propio servidor personal de aprendizaje profundo si es necesario.

Colab es el enfoque de esfuerzo cero, pero puede que quieras tener un poco más de control sobre cómo se instalan las cosas u obtener acceso Secure Shell (SSH) a tu instancia en la nube, así que echemos un vistazo a lo que ofrecen los principales proveedores de la nube.

Proveedores de la nube

Cada uno de los tres grandes proveedores de la nube (Amazon Web Services, Google Cloud Platform y Azure de Microsoft) ofrece instancias basadas en GPU (también denominadas máquinas virtuales o VM) e imágenes oficiales para implementar en esas instancias. Tienen todo lo que necesitas para ponerte en marcha sin tener que instalar tú mismo los controladores y las bibliotecas de Python. Veamos lo que ofrece cada proveedor.

Servicios web de Amazon

AWS, el gorila de 800 libras del mercado de la nube, está más que encantado de satisfacer tus necesidades de GPU y ofrece los tipos de instancia P2 y P3 para ayudarte. (El tipo de instancia G3 suele utilizarse más en aplicaciones basadas en gráficos reales, como la codificación de vídeo, por lo que no lo trataremos aquí). Las instancias P2 utilizan las antiguas tarjetas NVIDIA K80 (se pueden conectar un máximo de 16 a una instancia), y las instancias P3 utilizan las rapidísimas tarjetas NVIDIA V100 (y puedes conectar ocho de ellas a una instancia si te atreves).

Si vas a utilizar AWS, mi recomendación para este libro es que optes por la clase p2.xlarge . Esto te costará sólo 90 céntimos la hora en el momento de escribir esto y proporciona mucha potencia para trabajar con los ejemplos. Puede que quieras subir a las clases P3 cuando empieces a trabajar en algunas competiciones Kaggle.

Crear una caja de aprendizaje profundo en funcionamiento en AWS es increíblemente fácil:

Inicia sesión en la consola de AWS.
Selecciona EC2 y haz clic en Lanzar Instancia.
Busca la opción Aprendizaje Profundo AMI (Ubuntu) y selecciónala.
Elige p2.xlarge como tipo de instancia.
Lanza la instancia, creando un nuevo par de claves o reutilizando un par de claves existente.
Conéctate a la instancia utilizando SSH y redirigiendo el puerto 8888 de tu máquina local a la instancia:
```
ssh -L localhost:8888:localhost:8888 \
-i your .pem filename ubuntu@your instance DNS
```
Inicia Jupyter Notebook introduciendo jupyter notebook. Copia la URL que se genera y pégala en tu navegador para acceder a Jupyter.

Recuerda apagar tu instancia cuando no la estés utilizando. Para ello, haz clic con el botón derecho del ratón sobre la instancia en la interfaz web y selecciona la opción Apagar. Esto apagará la instancia, y no se te cobrará por ella mientras no esté funcionando. Sin embargo, se te cobrará por el espacio de almacenamiento que le hayas asignado aunque la instancia esté apagada, así que tenlo en cuenta. Para eliminar por completo la instancia y el almacenamiento, selecciona en su lugar la opción Finalizar.

Azure

Al igual que AWS, Azure ofrece una mezcla de instancias más baratas basadas en K80 e instancias más caras Tesla V100. Azure también ofrece instancias basadas en el hardware más antiguo P100 como punto intermedio entre las otras dos. De nuevo, recomiendo para este libro el tipo de instancia que utiliza un único K80 (NC6), que también cuesta 90 céntimos por hora, y pasa a otros tipos de NC, NCv2 (P100) o NCv3 (V100) a medida que los necesites.

A continuación te explicamos cómo configurar la máquina virtual en Azure:

Accede al portal de Azure y busca la imagen de la Máquina Virtual de Ciencia de Datos en Azure Marketplace.
Haz clic en el botón Consíguelo ahora.
Rellena los datos de la máquina virtual (dale un nombre, elige disco SSD en lugar de HDD, un nombre de usuario/contraseña SSH, la suscripción a la que facturarás la instancia y establece que la ubicación sea la más cercana a ti que ofrezca el tipo de instancia NC).
Haz clic en la opción Crear. La instancia debería aprovisionarse en unos cinco minutos.
Puedes utilizar SSH con el nombre de usuario/contraseña que hayas especificado para el nombre público del Sistema de Nombres de Dominio (DNS) de esa instancia.
El Cuaderno Jupyter debería ejecutarse cuando se aprovisione la instancia; navega a http://dns name of instance:8000 y utiliza la combinación de nombre de usuario y contraseña que utilizaste para SSH para iniciar sesión.

Plataforma en la nube de Google

Además de ofrecer instancias respaldadas por K80, P100 y V100 como Amazon y Azure, Google Cloud Platform (GCP) ofrece las ya mencionadas TPUs para quienes tengan enormes necesidades de datos y computación. No necesitas TPUs para este libro, y son caros, pero funcionarán con PyTorch 1.0, así que no pienses que tienes que usar TensorFlow para aprovecharlos si tienes un proyecto que requiera su uso.

Empezar a utilizar Google Cloud también es bastante fácil:

Busca máquinas virtuales de aprendizaje profundo en GCP Marketplace.
Haz clic en Iniciar en Motor de Computación.
Dale un nombre a la instancia y asígnala a la región más cercana a ti.
Establece el tipo de máquina en 8 vCPUs.
Pon la GPU a 1 K80.
Asegúrate de que PyTorch 1.0 está seleccionado en la sección Framework.
Selecciona la casilla "¿Instalar automáticamente la GPU NVIDIA en el primer inicio?" .
Configura el Disco de Arranque como Disco Persistente SSD.
Haz clic en la opción Implementación. La máquina virtual tardará unos 5 minutos en desplegarse por completo.
Para conectarte a Jupyter en la instancia, asegúrate de que has iniciado sesión en el proyecto correcto en gcloud y emite este comando:
```
gcloud compute ssh _INSTANCE_NAME_ -- -L 8080:localhost:8080
```

Las tarifas de Google Cloud deberían ascender a unos 70 céntimos por hora, lo que lo convierte en el más barato de los tres principales proveedores de nube.

¿Qué proveedor de servicios en la nube debo utilizar?

Si no tienes nada que te empuje en ninguna dirección, te recomiendo Google Cloud Platform (GCP); es la opción más barata, y puedes escalar hasta utilizar TPUs si es necesario, con mucha más flexibilidad que las ofertas de AWS o Azure. Pero si ya dispones de recursos en alguna de las otras dos plataformas, no tendrás ningún problema para funcionar en esos entornos.

Una vez que tengas tu instancia en la nube en funcionamiento, podrás iniciar sesión en su copia de Jupyter Notebook, así que echemos un vistazo a eso a continuación.

Utilizar Jupyter Notebook

Si aún no lo conoces, aquí tienes toda la información sobre Jupyter Notebook: este entorno basado en navegador te permite mezclar código en vivo con texto, imágenes y visualizaciones, y se ha convertido en una de las herramientas de facto de los científicos de datos de todo el mundo. Los cuadernos creados en Jupyter pueden compartirse fácilmente; de hecho, encontrarás todos los cuadernos en este libro. Puedes ver una captura de pantalla de Jupyter Notebook en acción en la Figura 1-2.

En este libro no utilizaremos ninguna función avanzada de Jupyter; todo lo que necesitas saber es cómo crear un cuaderno nuevo y que Mayúsculas-Entrar ejecuta el contenido de una celda. Pero si nunca lo has utilizado, te sugiero que consultes la documentación de Jupyter antes de llegar al Capítulo 2.

Antes de entrar en el uso de PyTorch, veremos una última cosa: cómo instalarlo todo manualmente.

Instalar PyTorch desde cero

Tal vez quieras un poco más de control sobre tu software que utilizando una de las anteriores imágenes proporcionadas por la nube. O necesitas una versión concreta de PyTorch para tu código. O, a pesar de todas mis advertencias, realmente quieres esa plataforma en tu sótano. Veamos cómo instalar PyTorch en un servidor Linux en general.

Advertencia

Puedes utilizar PyTorch con Python 2.x, pero te recomiendo encarecidamente que no lo hagas. Aunque la saga de actualización de Python 2.x a 3.x lleva ya más de una década en marcha, cada vez más paquetes están empezando a abandonar el soporte de Python 2.x. Así que, a menos que tengas una buena razón, asegúrate de que tu sistema ejecuta Python 3.

Descargar CUDA

Aunque PyTorch puede ejecutarse completamente en modo CPU, en la mayoría de los casos, para un uso práctico se requiere PyTorch potenciado por GPU, por lo que vamos a necesitar soporte para GPU. Esto es bastante sencillo; suponiendo que tengas una tarjeta NVIDIA, esto lo proporciona su API Compute Unified Device Architecture (CUDA). Descarga el formato de paquete apropiado para tu tipo de Linux e instálalo.

Para Red Hat Enterprise Linux (RHEL) 7:

sudo rpm -i cuda-repo-rhel7-10-0local-10.0.130-410.48-1.0-1.x86_64.rpm
sudo yum clean all
sudo yum install cuda

Para Ubuntu 18.04:

sudo dpkg -i cuda-repo-ubuntu1804-10-0-local-10.0.130-410.48_1.0-1_amd64.deb
sudo apt-key add /var/cuda-repo-<version>/7fa2af80.pub
sudo apt-get update
sudo apt-get install cuda

Anaconda

Python tiene una variedad de sistemas de empaquetado, todos los cuales tienen puntos buenos y no tan buenos. Al igual que los desarrolladores de PyTorch, te recomiendo que instales Anaconda, un sistema de empaquetado dedicado a producir la mejor distribución de paquetes para los científicos de datos. Al igual que CUDA, es bastante fácil de instalar.

Dirígete a Anaconda y elige el archivo de instalación para tu máquina. Como se trata de un archivo masivo que se ejecuta mediante un script de shell en tu sistema, te animo a que ejecutes md5sum en el archivo que has descargado y lo compruebes con la lista de firmas antes de ejecutarlo con bash Anaconda3-VERSION-Linux-x86_64.sh para asegurarte de que la firma de tu máquina coincide con la de la página web. Esto garantiza que el archivo descargado no ha sido manipulado y significa que es seguro ejecutarlo en tu sistema. El script presentará varias preguntas sobre las ubicaciones en las que se instalará; a menos que haya una buena razón, simplemente acepta los valores predeterminados.

Nota

Quizá te preguntes: "¿Puedo hacer esto en mi MacBook ?". Lamentablemente, la mayoría de los Macs vienen con GPUs Intel o AMD hoy en día y realmente no tienen soporte para ejecutar PyTorch en modo acelerado por GPU. Te recomiendo que utilices Colab o un proveedor en la nube en lugar de intentar utilizar tu Mac localmente.

Por fin, ¡PyTorch! (y Jupyter Notebook)

Ahora que tienes Anaconda instalado, configurarte con PyTorch es sencillo:

conda install pytorch torchvision -c pytorch

Esto instala PyTorch y la biblioteca torchvision que utilizaremos en los próximos capítulos para crear arquitecturas de aprendizaje profundo que funcionen con imágenes. Anaconda también nos ha instalado Jupyter Notebook, así que podemos empezar por iniciarlo:

jupyter notebook

Dirígete a http://YOUR-IP-ADDRESS:8888 en tu navegador, crea un nuevo bloc de notas e introduce lo siguiente:

import torch
print(torch.cuda.is_available())
print(torch.rand(2,2))

Esto debería producir un resultado similar a éste:

True
 0.6040  0.6647
 0.9286  0.4210
[torch.FloatTensor of size 2x2]

Si cuda.is_available() devuelve False, necesitas depurar tu instalación CUDA para que PyTorch pueda ver tu tarjeta gráfica. Los valores del tensor serán diferentes en tu instancia.

Pero, ¿qué es este tensor? Los tensores están en el corazón de casi todo en PyTorch, así que necesitas saber qué son y qué pueden hacer por ti.

Tensores

Un tensor es tanto un contenedor de números como un conjunto de reglas que definen transformaciones entre tensores que producen nuevos tensores. Probablemente nos resulte más fácil pensar en los tensores como matrices multidimensionales. Cada tensor tiene un rango que corresponde a su espacio dimensional. Un simple escalar (por ejemplo, 1) puede representarse como un tensor de rango 0, un vector es de rango 1, una matriz n × n es de rango 2, y así sucesivamente. En el ejemplo anterior, hemos creado un tensor de rango 2 con valores aleatorios utilizando torch.rand(). También podemos crearlos a partir de listas:

x = torch.tensor([[0,0,1],[1,1,1],[0,0,0]])
x
>tensor([[0, 0, 1],
    [1, 1, 1],
    [0, 0, 0]])

Podemos cambiar un elemento de un tensor utilizando la indexación estándar de Python:

x[0][0] = 5
>tensor([[5, 0, 1],
    [1, 1, 1],
    [0, 0, 0]])

Puedes utilizar funciones de creación especiales para generar tipos concretos de tensores. En concreto, ones() y zeroes() generarán tensores llenos de 1s y 0s, respectivamente:

torch.zeros(2,2)
> tensor([[0., 0.],
    [0., 0.]])

Puedes realizar operaciones matemáticas estándar con tensores (por ejemplo, sumar dos tensores):

tensor.ones(1,2) + tensor.ones(1,2)
> tensor([[2., 2.]])

Y si tienes un tensor de rango 0, puedes sacar el valor con item():

torch.rand(1).item()
> 0.34106671810150146

Los tensores pueden vivir en la CPU o en la GPU y pueden copiarse entre dispositivos utilizando la función to():

cpu_tensor = tensor.rand(2)
cpu_tensor.device
> device(type='cpu')

gpu_tensor = cpu_tensor.to("cuda")
gpu_tensor.device
> device(type='cuda', index=0)

Operaciones tensoriales

Si echas un vistazo a la documentación de PyTorch, verás que hay un montón de funciones que puedes aplicar a los tensores: desde encontrar el elemento máximo hasta aplicar una transformada de Fourier . En este libro, no necesitas conocerlas todas para convertir imágenes, texto y audio en tensores y manipularlos para realizar nuestras operaciones, pero necesitarás algunas. Te recomiendo que eches un vistazo a la documentación, sobre todo después de terminar este libro. Ahora vamos a repasar todas las funciones que se utilizarán en los próximos capítulos.

En primer lugar, a menudo necesitamos encontrar el elemento máximo de un tensor, así como el índice que contiene el valor máximo (ya que éste suele corresponder a la clase que la red neuronal ha decidido en su predicción final). Esto se puede hacer con las funciones max() y argmax() . También podemos utilizar item() para extraer un valor estándar Python de un tensor 1D.

torch.rand(2,2).max()
> tensor(0.4726)
torch.rand(2,2).max().item()
> 0.8649941086769104

A veces, nos gustaría cambiar el tipo de un tensor; por ejemplo, de LongTensor a FloatTensor. Podemos hacerlo con to() :

long_tensor = torch.tensor([[0,0,1],[1,1,1],[0,0,0]])
long_tensor.type()
> 'torch.LongTensor'
float_tensor = torch.tensor([[0,0,1],[1,1,1],[0,0,0]]).to(dtype=torch.float32)
float_tensor.type()
> 'torch.FloatTensor'

La mayoría de las funciones que operan sobre un tensor y devuelven un tensor crean un nuevo tensor para almacenar el resultado. Sin embargo, si quieres ahorrar memoria, mira a ver si está definida una función in-place, que debería tener el mismo nombre que la función original pero con un guión bajo añadido (_).

random_tensor = torch.rand(2,2)
random_tensor.log2()
>tensor([[-1.9001, -1.5013],
        [-1.8836, -0.5320]])
random_tensor.log2_()
> tensor([[-1.9001, -1.5013],
        [-1.8836, -0.5320]])

Otra operación habitual es remodelar un tensor. Esto puede ocurrir a menudo porque la capa de tu red neuronal puede requerir una forma de entrada ligeramente distinta de la que tienes actualmente para alimentarla. Por ejemplo, el conjunto de datos de dígitos manuscritos del Instituto Nacional Modificado de Estándares y Tecnología (MNIST) es una colección de imágenes de 28 × 28, pero la forma en que está empaquetado es en matrices de longitud 784. Para utilizar las redes que estamos construyendo, tenemos que volver a convertirlas en tensores de 1 × 28 × 28 (el 1 inicial es el número de canales -normalmente rojo, verde y azul-, pero como los dígitos del MNIST son sólo escala de grises, sólo tenemos un canal). Podemos hacerlo con view() o reshape() :

flat_tensor = torch.rand(784)
viewed_tensor = flat_tensor.view(1,28,28)
viewed_tensor.shape
> torch.Size([1, 28, 28])
reshaped_tensor = flat_tensor.reshape(1,28,28)
reshaped_tensor.shape
> torch.Size([1, 28, 28])

Ten en cuenta que la forma del tensor remodelado tiene que tener el mismo número de elementos totales que el original. Si intentas flat_tensor.reshape(3,28,28), verás un error como éste:

RuntimeError Traceback (most recent call last)
<ipython-input-26-774c70ba5c08> in <module>()
----> 1 flat_tensor.reshape(3,28,28)

RuntimeError: shape '[3, 28, 28]' is invalid for input of size 784

Ahora te preguntarás cuál es la diferencia entre view() y reshape(). La respuesta es que view() funciona como una vista sobre el tensor original, de modo que si cambian los datos subyacentes, también cambiará la vista (y viceversa). Sin embargo, view() puede lanzar errores si la vista requerida no es contigua; es decir, no comparte el mismo bloque de memoria que ocuparía si se creara desde cero un nuevo tensor de la forma requerida. Si esto ocurre, tienes que llamar a tensor.contiguous() antes de poder utilizar view(). Sin embargo, reshape() hace todo eso entre bastidores, por lo que, en general, recomiendo utilizar reshape() en lugar de view().

Por último, puede que necesites reordenar las dimensiones de un tensor. Es probable que te encuentres con esto en el caso de las imágenes, que a menudo se almacenan como tensores [height, width, channel], pero PyTorch prefiere tratarlas en [channel, height, width]. Puedes utilizar permute() para tratarlas de una manera bastante sencilla:

hwc_tensor = torch.rand(640, 480, 3)
chw_tensor = hwc_tensor.permute(2,0,1)
chw_tensor.shape
> torch.Size([3, 640, 480])

Aquí, acabamos de aplicar permute a un tensor [640,480,3], siendo los argumentos los índices de las dimensiones del tensor, por lo que queremos que la dimensión final (2, debido a la indexación cero) esté al principio de nuestro tensor, seguida de las dos dimensiones restantes en su orden original.

Difusión tensorial

Tomado prestado de NumPy, la difusión te permite realizar operaciones entre un tensor y otro tensor más pequeño. Puedes emitir a través de dos tensores si, empezando hacia atrás desde sus dimensiones finales:

Las dos dimensiones son iguales.
Una de las dimensiones es 1.

En nuestro uso de la emisión, funciona porque 1 tiene una dimensión de 1, y como no hay otras dimensiones, el 1 puede expandirse para abarcar el otro tensor. Si intentáramos añadir un tensor [2,2] a un tensor [3,3], obtendríamos este mensaje de error:

The size of tensor a (2) must match the size of
tensor b (3) at non-singleton dimension 1

Pero podríamos añadir un tensor [1,3] al tensor [3,3] sin ningún problema. La difusión es una pequeña función muy útil que aumenta la brevedad del código, y a menudo es más rápida que ampliar manualmente el tensor tú mismo.

Con esto hemos terminado todo lo relativo a los tensores que necesitas para empezar. Cubriremos algunas otras operaciones a medida que las encontremos más adelante en el libro, pero esto es suficiente para que te sumerjas en Capítulo 2.

Conclusión

Ya sea en la nube o en tu máquina local, ahora deberías tener PyTorch instalado. Te he presentado el bloque de construcción fundamental de la biblioteca, el tensor, y has echado un breve vistazo a Jupyter Notebook. ¡Esto es todo lo que necesitas para empezar! En el siguiente capítulo, utilizarás todo lo que has visto hasta ahora para empezar a construir redes neuronales y clasificar imágenes, así que asegúrate de que te sientes cómodo con los tensores y Jupyter antes de seguir adelante.

Otras lecturas

Get Programación de PyTorch para Aprendizaje Profundo now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Programación de PyTorch para Aprendizaje Profundo by Ian Pointer