Aprende PyTorch: implementación práctica de algoritmos de IA

PyTorch es una biblioteca de código abierto para Python con la que se construyen y entrenan redes neuronales de deep learning. Sirve para trabajar con tensores, calcular gradientes de forma automática y acelerar los cálculos con GPU, y se usa en visión por computadora, procesamiento del lenguaje natural y modelos de lenguaje.

Ante los grandes avances de la tecnología, cada vez son más las nuevas ramas tecnológicas que buscan dar respuesta a nuevas necesidades.

Es así como a día de hoy de seguro escucharás hablar mucho sobre el Deep Learning, Machine Learning y, por supuesto, sobre Inteligencia Artificial.

Aunque no lo creas, todos estos términos tienen mucho que ver entre sí y existen programas que permiten la creación de redes neuronales que pueden ser la base para el desarrollo de nuevos algoritmos.

Entre las opciones para crear redes neuronales, una que conviene conocer es PyTorch. En esta guía vemos qué es, para qué sirve, cómo instalarlo y cómo se ve su código.

¿Aún no sabes de qué se trata? Entonces prepárate para conocer distintos aspectos importantes que te permitirán comprenderlo a fondo.

Términos básicos para entender PyTorch

Antes de entrar en materia es importante establecer las definiciones de algunos términos básicos que te permitirán comprender mejor todo el funcionamiento de PyTorch.

Son términos que te aparecerán mucho una vez que comiences a aprender sobre el tema y algunos de los más relevantes son:

1. Machine Learning (aprendizaje automático)

Se trata de un campo dentro del mundo de la computación y perteneciente al campo de la inteligencia artificial que tiene por objetivo el desarrollo de técnicas para el aprendizaje computacional.

Existen muchos programas en los artefactos tecnológicos capaces de realizar tareas de manera automática y con pocas especificaciones. Alguna vez te has preguntado, ¿cómo es eso posible?

Esto es gracias al machine learning, este campo científico se ha encargado de darle a los ordenadores las directrices necesarias para identificar patrones de datos y realizar análisis predictivos.

Se usa sobre todo en la programación de asistentes virtuales e incluso en las plataformas de streaming para mostrarles a los usuarios recomendaciones adaptadas a sus gustos personales.

1. Deep Learning (aprendizaje profundo)

Por su parte, el deep learning se presenta como el conjunto de algoritmos que son empleados por el machine learning.

A través de estos algoritmos se busca emular el funcionamiento del cerebro humano para darle a los ordenadores una serie de redes neuronales que les permitan aprender, tal y como lo haría un humano.

Es gracias a esto que los programas, asistentes virtuales y aplicaciones de inteligencia artificial se ven en la posibilidad de obtener un aprendizaje a partir de los datos otorgados.

La tecnología detrás del deep learning es la que ha permitido la creación de servicios automatizados, sin necesidad de interacción humana, pero con la misma capacidad para llegar a conclusiones, tal y como lo haría un humano.

1. Redes neuronales

Ahora bien, las redes neuronales pueden ser tanto artificiales, como simuladas, pero sin importar cuál sea el caso, se presentan como el eje de los algoritmos creados por el deep learning.

Son una serie de redes que pretenden simular al cerebro humano, pero por medio de directrices informáticas y estadísticas para lograr una resolución de problemas eficiente.

Es por ello que su objetivo es imitar lo más posible el modo en el que actúan las neuronas biológicas en los seres humanos. Claro que, en el caso de estas neuronas artificiales, están compuestas por nodos y capas para lograr la interconexión entre cada una.

1. NLP (procesamiento del lenguaje natural)

Se trata de una rama perteneciente de la informática que se encarga de brindarles a los ordenadores una capacidad completa para la comprensión de palabras y textos completos, de la misma forma en la que lo harían los seres humanos.

Su intención principal es desarrollar artefactos o programas con la capacidad de entender información presentada en textos o en audios y que se vean en la posibilidad de responder de la misma manera. Es decir, tal y como lo harían los humanos.

Como te podrás imaginar, las inteligencias artificiales actuales trabajan mucho con esto para su composición.

Es por ello que la lingüística computacional ha cobrado mayor relevancia durante los últimos años y ha trabajado, de la mano con modelos estadísticos, para procesar de forma más acertada el lenguaje humano.

¿Qué es PyTorch?

Ahora sí, es momento de entrar en el tema principal y comprender de qué se trata Pytorch.

Es una biblioteca de código abierto centrada en el deep learning y que presenta una plataforma dinámica, poderosa y flexible para la creación de redes neuronales.

Dicha biblioteca se encuentra estructurada sobre el lenguaje de programación de Python, el lenguaje con el que se usa su API principal.

PyTorch se basa en la biblioteca de deep learning de Torch, combinada con una API eficiente. Por lo tanto, se caracteriza por ser una biblioteca sencilla de utilizar y con mucha flexibilidad para trabajar.

Es por ello que muchos profesionales en el área catalogan a PyTorch como uno de los marcos de aprendizaje automáticos más empleados por las comunidades investigativas del mundo actual.

Su objetivo principal es trabajar como una plataforma desde la cual los desarrolladores puedan crear nuevas redes neuronales y entrenarlas para que resulten eficientes y escalables.

Asimismo, permite la integración de una amplia variedad de redes neuronales según diversos tipos de arquitecturas. No solo trabaja con algoritmos básicos, sino también con modelos generativos, arquitecturas transformer o redes neuronales mucho más complejas.

Todo esto por medio de una interfaz intuitiva que hace del proceso de aprendizaje un camino más sencillo de emprender, así como promueve la experimentación con nuevos algoritmos de inteligencia artificial.

Al ser fundamentado sobre Python, no solo hace que más personas lo comprendan, sino que también les brinda a los científicos de datos la oportunidad de centrarse en las estructuras, a la par que disminuyen el tiempo total de trabajo.

¿Para qué sirve PyTorch?

PyTorch sirve para entrenar y ejecutar modelos de aprendizaje profundo: desde un clasificador sencillo hasta modelos de lenguaje. Se aplica sobre todo en visión por computadora, procesamiento del lenguaje natural y generación de contenido, y destaca porque trabaja con tensores en GPU y calcula los gradientes de forma automática.

• Clasificar: decidir si una imagen o un texto pertenece a una categoría.

• Entender y generar lenguaje: la base de los modelos de lenguaje; si quieres ver cómo funcionan, tienes la guía sobre qué es un LLM.

En la web oficial aparecen proyectos del ecosistema como Captum (interpretabilidad), PyTorch Geometric (datos en forma de grafo) y skorch (compatibilidad con scikit-learn).

Si ya programas en Python y quieres aplicarlo a proyectos con modelos de lenguaje, el Máster en AI Engineer de ThePower propone «3 horas semanales de sesiones en directo» y «6 horas adicionales de práctica y revisión de guías». Consulta el dossier del programa.

¿Por qué PyTorch es importante en el desarrollo de la inteligencia artificial?

Debido a su integración con el machine learning y el deep learning, PyTorch se presenta como una herramienta importante para quienes quieran trabajar en el desarrollo de la inteligencia artificial a día de hoy.

Por supuesto, su relevancia no pasa desapercibida entre los desarrolladores y ellos la recomiendan por diversos motivos.

Uno de los más relevantes, sin duda alguna, es su facilidad de uso. La interfaz de PyTorch se estructura de manera sencilla e intuitiva, lo cual le permite a todos un aprendizaje mucho más rápido y les da la oportunidad de experimentar mucho mejor con nuevas inteligencias artificiales.

Claro está, su simpleza de uso no es lo único importante, otro aspecto que cabe resaltar es su capacidad para crear cómputos en GPUs acelerados para brindar un rendimiento indiscutible.

Es gracias a esto que, conforme avances, podrás entrenar modelos que resulten más complejos, pero en mucho menos tiempo.

Asimismo, PyTorch cuenta con todo un ecosistema sólido y bien elaborado de extensiones y herramientas, las cuales han sido desarrolladas por su propia comunidad.

Por lo tanto, conforme pase el tiempo, cada vez son más las herramientas disponibles dentro de esta biblioteca para permitirte realizar un trabajo de mucha más calidad.

¿Cuáles son los fundamentos de PyTorch?

Tras comprender su importancia en la actual era tecnológica, de seguro ya te preguntarás cómo comenzar a trabajar con PyTorch.

Esta biblioteca cuenta con una estructura matemática con la capacidad para simplificar los flujos de trabajo, pero esto es posible gracias a los diversos fundamentos sobre los cuales su funcionamiento se erige.

Por lo tanto, para trabajar de manera efectiva con PyTorch, es fundamental tener en cuenta que sus fundamentos principales son:

1. Python

Su fundamento principal es el lenguaje de programación sobre el cual se encuentra estructurado y ese es Python.

Se trata de un lenguaje de alto nivel que es utilizado, de forma principal, dentro de la ciencia de datos. Es por ello que se presenta como una excelente opción para los científicos de datos que quieran mejorar sus labores con el deep learning.

Además, desde su creación, Python se ha diferenciado de otros lenguajes debido a la simpleza de su sintaxis, la cual es simple de entender, funciona en diversos sistemas operativos y no requiere de mucho tiempo de aprendizaje.

1. Módulos

Dentro de PyTorch se trabaja con módulos, los cuales suelen ser entendidos como los bloques que permiten la construcción de los modelos de deep learning.

Gracias a esta estructuración, el proceso de creación se presenta mucho más sencillo para los desarrolladores, quienes podrán crear las redes neuronales sin que sea una labor muy tediosa.

Cabe destacar que los módulos también hacen posible la creación de redes neuronales mucho más elaboradas. Lo cual da pie a la creación de modelos más complejos que pueden transferirse en máquinas tanto GPU, como CPU.

1. Tensores

Al trabajar con la creación de algoritmos para el deep learning, se deben representar los datos con una forma numérica. En el caso de PyTorch, esto se hace por medio de los denominados tensores.

Dentro de esta biblioteca, los tensores no son más que las unidades fundamentales de datos, empleadas para realizar los cálculos dentro de su plataforma.

Asimismo, en el ámbito del deep learning, los tensores son reconocidos como matrices multidimensionales de números. Son muy parecidos a los arrays y las matrices, con una diferencia clave: pueden almacenarse y calcularse en un acelerador como la GPU, no solo en la CPU.

1. Diferenciación automática

Al comenzar a trabajar con la creación de redes neuronales, te encontrarás con el método de la retropropagación que permite medir el error en las predicciones.

En el caso de PyTorch, el motor de diferenciación integrado se llama torch.autograd y calcula los gradientes por ti: marcas los tensores con requires_grad, llamas a loss.backward() y recuperas el resultado en .grad.

Esto es gracias a que esta técnica permite trabajar con la denominada “regla de cadena”, una forma de cálculo que permite realizar operaciones con derivadas complejas, para convertirlas en derivadas simples, todo de forma automática.

1. DCG (gráficos de cálculo dinámico)

En PyTorch, los gráficos de cálculo dinámico son reconocidos como la manera en la que los modelos de deep learning son presentados.

Por ejemplo, a la hora de trabajar con los gráficos, se mapea el flujo de datos. De esa manera, el código establecido en las redes neuronales pasa a ser presentado en un diagrama de flujo.

Dentro del mismo, se pueden observar las operaciones, las secuencias, pasos y dependencias de manera mucho más organizada.

En la práctica significa que el grafo se construye mientras el código se ejecuta: según la documentación, después de cada llamada a .backward(), autograd empieza a rellenar un grafo nuevo. Por eso puedes usar bucles y condicionales de Python dentro del modelo y cambiar su comportamiento de una iteración a otra.

1. Conjuntos y cargadores de datos

Para finalizar, también hay que hacer mención, tanto de su conjunto de datos, como de sus cargadores de datos.

Al trabajar con conjuntos de datos grandes, el proceso de entrenamiento de los modelos del deep learning puede tomar un poco más de trabajo.

Sin embargo, PyTorch presenta unas primitivas de datos con las cuales el proceso de carga se torna mucho más fácil. Algunas de ellas son los datasets o dataloaders.

Con ellas, es posible hacer que el proceso de carga de datos sea más fluido y también ayudará a que el código final sea mucho más sencillo de leer.

Primeros pasos con PyTorch: instalación y un ejemplo mínimo

Cómo instalar PyTorch

La última versión estable es PyTorch 2.14.1, publicada el 30 de septiembre de 2026 según su ficha en PyPI, y requiere Python 3.10 o posterior, según la guía oficial de instalación.

En esa página eliges sistema operativo, gestor de paquetes (por ejemplo, pip), lenguaje y plataforma de cómputo (CUDA, otras opciones o CPU), y la web te da el comando exacto. Para aprender no necesitas GPU: el código de los tutoriales oficiales cae a la CPU si no hay acelerador. Después comprueba la instalación:

import torch
print(torch.__version__)
print(torch.accelerator.is_available())

import torch
print(torch.__version__)
print(torch.accelerator.is_available())

import torch
print(torch.__version__)
print(torch.accelerator.is_available())

Tu primer ejemplo: tensores y autograd

Este ejemplo crea un tensor, consulta sus atributos y calcula el gradiente de una suma:

import torch

x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
print(x.shape, x.dtype, x.device)

w = torch.tensor(2.0, requires_grad=True)
perdida = (w * x).sum()
perdida.backward()
print(w.grad)  # tensor(10.)

import torch

x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
print(x.shape, x.dtype, x.device)

w = torch.tensor(2.0, requires_grad=True)
perdida = (w * x).sum()
perdida.backward()
print(w.grad)  # tensor(10.)

import torch

x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
print(x.shape, x.dtype, x.device)

w = torch.tensor(2.0, requires_grad=True)
perdida = (w * x).sum()
perdida.backward()
print(w.grad)  # tensor(10.)

El gradiente vale 10 porque la derivada de (w * x).sum() respecto a w es la suma de los elementos de x (1 + 2 + 3 + 4).

Un modelo completo en pocas líneas: el bucle de entrenamiento

Todo entrenamiento repite el mismo patrón: predecir, medir el error, calcular gradientes y actualizar pesos. Este ejemplo usa datos aleatorios solo para enseñar la estructura:

import torch
from torch import nn

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"

class RedSencilla(nn.Module):
    def __init__(self):
        super().__init__()
        self.capas = nn.Sequential(
            nn.Linear(4, 16),
            nn.ReLU(),
            nn.Linear(16, 3),
        )

    def forward(self, x):
        return self.capas(x)

model = RedSencilla().to(device)
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)

X = torch.rand(8, 4, device=device)             # 8 ejemplos con 4 características
y = torch.randint(0, 3, (8,), device=device)    # 3 clases posibles

model.train()
pred = model(X)
loss = loss_fn(pred, y)
loss.backward()
optimizer.step()
optimizer.zero_grad()
print(loss.item())

import torch
from torch import nn

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"

class RedSencilla(nn.Module):
    def __init__(self):
        super().__init__()
        self.capas = nn.Sequential(
            nn.Linear(4, 16),
            nn.ReLU(),
            nn.Linear(16, 3),
        )

    def forward(self, x):
        return self.capas(x)

model = RedSencilla().to(device)
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)

X = torch.rand(8, 4, device=device)             # 8 ejemplos con 4 características
y = torch.randint(0, 3, (8,), device=device)    # 3 clases posibles

model.train()
pred = model(X)
loss = loss_fn(pred, y)
loss.backward()
optimizer.step()
optimizer.zero_grad()
print(loss.item())

import torch
from torch import nn

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"

class RedSencilla(nn.Module):
    def __init__(self):
        super().__init__()
        self.capas = nn.Sequential(
            nn.Linear(4, 16),
            nn.ReLU(),
            nn.Linear(16, 3),
        )

    def forward(self, x):
        return self.capas(x)

model = RedSencilla().to(device)
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-2)

X = torch.rand(8, 4, device=device)             # 8 ejemplos con 4 características
y = torch.randint(0, 3, (8,), device=device)    # 3 clases posibles

model.train()
pred = model(X)
loss = loss_fn(pred, y)
loss.backward()
optimizer.step()
optimizer.zero_grad()
print(loss.item())

El módulo (nn.Module) define las capas en __init__ y el recorrido de los datos en forward; el bloque final es el bucle de entrenamiento de la documentación. En uno real lo repetirías por lote con un Dataset y un DataLoader, como en el tutorial de inicio rápido.

Errores habituales al empezar

• Aplicar softmax antes de la pérdida. nn.CrossEntropyLoss espera valores sin normalizar (logits), no probabilidades.

• Olvidar optimizer.zero_grad(). Según el tutorial de optimización, los gradientes se suman por defecto y hay que ponerlos a cero en cada iteración.

Cómo clasificar texto con PyTorch

Clasificar un texto con PyTorch consiste en convertir las palabras en números, pasarlos por una red neuronal y obtener una puntuación por cada categoría. El modelo se entrena con ejemplos ya etiquetados, midiendo el error con una función de pérdida como CrossEntropyLoss y ajustando los pesos con un optimizador.

• Preparar los datos: textos con su etiqueta, y un número para cada palabra o fragmento (tokenizar).

• Representar: una capa nn.Embedding, «una tabla de consulta simple» de embeddings según la documentación, convierte cada número en un vector.

• Clasificar: capas nn.Linear reducen esos vectores a una salida por categoría.

• Entrenar y evaluar: el bucle del ejemplo anterior y, para medir, model.eval() con torch.no_grad().

Para repasar los conceptos previos, tienes la guía de redes neuronales.

Beneficios de trabajar con PyTorch

Tal y como se ha mencionado desde el inicio, PyTorch es una herramienta muy eficiente y es gracias a sus diversos fundamentos y a la estructura de su interfaz, que se convierte en una excelente opción para cualquiera que quiera trabajar con las inteligencias artificiales.

Aunque, si aún no estás muy convencido de utilizar esta biblioteca, debes conocer la lista de sus beneficios:

• Te permite trabajar con una estructura flexible.

• Es una biblioteca intuitiva y sencilla de utilizar.

• Permite la experimentación interactiva.

• Su fundamentación sobre Python permite la compatibilidad con herramientas del mismo lenguaje.

• Es una biblioteca veloz y eficiente.

• Tiene una gran comunidad virtual activa.

• Es una biblioteca que permite la escalabilidad de los proyectos.

Qué ha cambiado en PyTorch: torch.compile y las versiones 2.x

PyTorch publica versiones nuevas cada pocos meses: según PyPI, la 2.12 salió en mayo de 2026, la 2.13 en julio y la 2.14 en septiembre. Conviene comprobar la versión antes de seguir un tutorial antiguo.

Una de las novedades de uso de la serie 2.x es torch.compile, que según la documentación «optimiza el modelo o función dado usando TorchDynamo y el backend especificado» (por defecto, Inductor). Se aplica con una línea, sin cambiar el modelo:

compiled_model = torch.compile(model)

compiled_model = torch.compile(model)

compiled_model = torch.compile(model)

Su modo por defecto ofrece «un buen equilibrio entre rendimiento y sobrecarga». Úsalo cuando el modelo ya funcione y quieras más velocidad.

Cuidado con el código antiguo: las notas de la versión 2.14.0 indican que se eliminaron torch.cholesky() y torch.qr() (se sustituyen por torch.linalg.cholesky() y torch.linalg.qr()) y que cambió el gradiente de clamp en los empates.

Para comparar enfoques, tienes la guía para aprender TensorFlow, y para el rol profesional que usa estas herramientas, qué hace un AI Engineer.

Para seguir avanzando con acompañamiento, el Máster en AI Engineer de ThePower incluye «Acceso durante 12 meses a la plataforma y a las grabaciones de tus sesiones» y termina con «Certificación AI Engineer al completar el máster y entregar los proyectos». Descarga el dossier del programa.

Conclusión

Como puedes ver, PyTorch es una herramienta muy poderosa con la cual podrás convertir tus ideas en realidad en el desarrollo de inteligencias artificiales.

Sin lugar a dudas, el mundo del aprendizaje automático tiene mucho potencial y durante los próximos años se espera que tenga un mayor impacto.

Por lo tanto, ahora que ya sabes más sobre PyTorch, su funcionamiento y cómo se desarrollan sus procesos, estás listo para comenzar a trabajar con él.

Ten por seguro que, con el paso del tiempo, te será muy sencillo crear tus proyectos de inteligencia artificial desde cero.

Sin duda, es una excelente herramienta con diversas opciones que te permitirán darle rienda suelta a tu creatividad. Y a ti, ¿qué te parece? ¿Trabajarías con PyTorch en algún momento?

Preguntas frecuentes

¿Qué es PyTorch?

PyTorch es una biblioteca de código abierto para Python que sirve para crear y entrenar redes neuronales de deep learning. Ofrece tensores que pueden calcularse en GPU, diferenciación automática (autograd) y módulos para construir modelos.

¿Para qué sirve PyTorch?

PyTorch sirve para entrenar y ejecutar modelos de aprendizaje profundo. Se usa en visión por computadora, procesamiento del lenguaje natural, modelos de lenguaje y generación de contenido.

¿Cómo se instala PyTorch?

Entra en la guía oficial de instalación de pytorch.org, elige tu sistema operativo, el gestor de paquetes, el lenguaje y la plataforma de cómputo (CUDA, otras opciones o CPU) y ejecuta el comando que te genera. La versión estable actual, la 2.14.1, requiere Python 3.10 o posterior.

¿Se puede usar PyTorch para clasificar texto?

Sí. Se convierte el texto en números, se pasa por una capa de embeddings y capas lineales, y se entrena con ejemplos etiquetados y una función de pérdida como CrossEntropyLoss. Es el esquema básico, por ejemplo, para analizar el sentimiento de reseñas.