Introducción
En el mundo en rápida evolución del aprendizaje profundo y las redes neuronales, las bibliotecas y los marcos son esenciales para simplificar y acelerar el proceso de desarrollo. PyTorch Lightning es una de esas poderosas bibliotecas construida sobre el popular PyTorch. Lightning está diseñado para permitir que los científicos de datos y los ingenieros de ML escalen fácilmente sus modelos, eviten el código repetitivo y mejoren la legibilidad general. Sin embargo, mientras trabaja con PyTorch Lightning, es posible que a menudo se enfrente a problemas como el error de atributo 'pytorch_lightning.metrics'. En este artículo, abordaremos el problema y lo guiaremos a través de su solución, desglosando el código para una mejor comprensión. Además, discutiremos las bibliotecas relacionadas y las funciones involucradas en la solución de este problema.
Solución al problema
Uno de los principales problemas relacionados con el error '%27pytorch_lightning%27 no tiene atributo %27metrics%27' es que es posible que haya instalado la versión anterior de PyTorch Lightning que no incluía el módulo de métricas. Para solucionar esto, simplemente puede actualizar su PyTorch Lightning a la última versión ejecutando el siguiente comando:
pip install --upgrade pytorch-lightning
Explicación paso a paso del código
Una vez que haya actualizado la biblioteca, podemos comenzar a trabajar con las métricas basadas en PyTorch Lightning. El primer paso es importar los módulos necesarios desde PyTorch Lightning. Usaremos la métrica de precisión con fines ilustrativos en este artículo.
import torch from pytorch_lightning import LightningModule from pytorch_lightning.metrics.functional import accuracy
A continuación, definamos nuestra red neuronal usando LightningModule como clase base. Dentro de los métodos 'training_step' y 'validation_step', calcularemos nuestros tensores de predicción y verdad del suelo, y calcularemos la precisión utilizando la función métrica de 'precisión' proporcionada por PyTorch Lightning.
class Classifier(LightningModule):
def __init__(self):
super().__init__()
self.layer1 = torch.nn.Linear( 32, 128)
self.layer2 = torch.nn.Linear(128, 10)
def forward(self, x):
x = torch.relu(self.layer1(x))
x = self.layer2(x)
return x
def training_step(self, batch, batch_idx):
x, y = batch
y_hat = self(x)
loss = torch.nn.functional.cross_entropy(y_hat, y)
acc = accuracy(y_hat, y) # Compute accuracy using PyTorch Lightning
self.log('train_loss', loss)
self.log('train_acc', acc, prog_bar=True)
return loss
def validation_step(self, batch, batch_idx):
x, y = batch
y_hat = self(x)
loss = torch.nn.functional.cross_entropy(y_hat, y)
acc = accuracy(y_hat, y) # Compute accuracy using PyTorch Lightning
self.log('val_loss', loss, prog_bar=True)
self.log('val_acc', acc, prog_bar=True)
return loss
Finalmente, siguiendo esta estructura de código, debería poder trabajar sin problemas con PyTorch Lightning-metrics sin encontrar el error de atributo mencionado.
Bibliotecas relacionadas: Torchmetrics
- Otra biblioteca que vale la pena mencionar es Antorchasmétricas, una biblioteca basada en PyTorch especializada en proporcionar métricas para evaluar modelos de aprendizaje profundo. La biblioteca Torchmetrics es creada por los mismos desarrolladores que PyTorch Lightning, lo que garantiza la compatibilidad y proporciona una API simple y consistente.
- Torchmetrics ofrece varias métricas como Exactitud, Precisión, Recuperación, puntuación F1 y muchas más. Reduce la tensión de implementar estas métricas manualmente y le permite concentrarse en otros aspectos de sus proyectos.
Mejora de la legibilidad del código con PyTorch Lightning
Uno de los beneficios clave de usar PyTorch Lightning es que simplifica significativamente la estructura del ciclo de entrenamiento y hace que el código sea más legible. LightningModule encapsula los componentes principales de una red neuronal, como la arquitectura del modelo, la lógica de entrenamiento y la lógica de validación, lo que le brinda la capacidad de administrar estos elementos de forma modular. Como resultado, puede desarrollar y escalar sus modelos de manera más eficiente, lo que le brinda una mejor comprensión de su código y, al mismo tiempo, mejora la colaboración entre los miembros del equipo.
