Primeiros passos com PyTorch em 5 etapas – KDnuggets

PyTorch é uma estrutura popular de aprendizado de máquina de código aberto baseada em Python e otimizada para computação acelerada por GPU. Originalmente desenvolvido pela Meta AI em 2016 e agora parte da Linux Foundation, PyTorch rapidamente se tornou uma das estruturas mais utilizadas para pesquisas e aplicações de aprendizado profundo.

Ao contrário de algumas outras estruturas como o TensorFlow, o PyTorch usa gráficos de computação dinâmicos que permitem maior flexibilidade e recursos de depuração. Os principais benefícios do PyTorch incluem:

• API Python simples e intuitiva para construção de redes neurais
• Amplo suporte para aceleração GPU/TPU
• Suporte integrado para diferenciação automática
• Capacidades de treinamento distribuídas
• Interoperabilidade com outras bibliotecas Python como NumPy

Relâmpago PyTorch é um wrapper leve construído sobre PyTorch que simplifica ainda mais o processo de fluxo de trabalho do pesquisador e desenvolvimento de modelo. Com o Lightning, os cientistas de dados podem se concentrar mais no design de modelos, em vez de código padronizado. As principais vantagens do Lightning incluem:

• Fornece estrutura para organizar o código PyTorch
• Lida com código padrão do loop de treinamento
• Acelera experimentos de pesquisa com ajuste de hiperparâmetros
• Simplifica o dimensionamento e a implantação do modelo

Ao combinar o poder e a flexibilidade do PyTorch com as APIs de alto nível do Lightning, os desenvolvedores podem construir rapidamente sistemas escalonáveis ​​de aprendizado profundo e iterar com mais rapidez.

Para começar a usar PyTorch e Lightning, primeiro você precisa instalar alguns pré-requisitos:

• Python 3.6 ou superior
• Instalador de pacote Pip
• Uma GPU NVidia é recomendada para operações aceleradas (configuração somente de CPU possível, mas mais lenta)

Instalando Python e PyTorch

É recomendado usar o Anaconda para configurar um ambiente Python para ciência de dados e cargas de trabalho de aprendizagem profunda. Siga os passos abaixo:

• Baixe e instale o Anaconda para o seu sistema operacional em SUA PARTICIPAÇÃO FAZ A DIFERENÇA
• Crie um ambiente Conda (ou use outro gerenciador de ambiente Python): conda create -n pytorch python=3.8
• Ative o ambiente: conda activate pytorch
• Instale o PyTorch: conda install pytorch torchvision torchaudio -c pytorch

Verifique se o PyTorch está instalado corretamente executando um teste rápido em Python:

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

Isso imprimirá um tensor 3×3 aleatório, confirmando que o PyTorch está funcionando corretamente.

Instalando PyTorch Lightning

Com o PyTorch instalado, agora podemos instalar o Lightning usando pip:

pip install lightning-ai

Vamos confirmar se o Lightning está configurado corretamente:

import lightning_ai
print(lightning_ai.__version__)

Isso deve imprimir o número da versão, como 0.6.0.

Agora estamos prontos para começar a construir modelos de aprendizagem profunda.

PyTorch usa tensores, semelhantes aos arrays NumPy, como sua estrutura de dados principal. Os tensores podem ser operados por GPUs e suportam diferenciação automática para a construção de redes neurais.

Vamos definir uma rede neural simples para classificação de imagens:

import torch
import torch.nn as nn
import torch.nn.functional as F class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(3, 6, 5) self.pool = nn.MaxPool2d(2, 2) self.conv2 = nn.Conv2d(6, 16, 5) self.fc1 = nn.Linear(16 * 5 * 5, 120) self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) def forward(self, x): x = self.pool(F.relu(self.conv1(x))) x = self.pool(F.relu(self.conv2(x))) x = torch.flatten(x, 1) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x net = Net()

Isto define uma rede neural convolucional com duas camadas convolucionais e três camadas totalmente conectadas para classificar 10 classes. O forward() O método define como os dados passam pela rede.

Agora podemos treinar esse modelo em dados de amostra usando o Lightning.

O relâmpago fornece um LightningModule classe para encapsular o código do modelo PyTorch e o padrão do loop de treinamento. Vamos converter nosso modelo:

import pytorch_lightning as pl class LitModel(pl.LightningModule): def __init__(self): super().__init__() self.model = Net() def forward(self, x): return self.model(x) def training_step(self, batch, batch_idx): x, y = batch y_hat = self.forward(x) loss = F.cross_entropy(y_hat, y) return loss def configure_optimizers(self): return torch.optim.Adam(self.parameters(), lr=0.02) model = LitModel()

A training_step() define o avanço e cálculo de perdas. Configuramos um otimizador Adam com taxa de aprendizado de 0.02.

Agora podemos treinar este modelo facilmente:

trainer = pl.Trainer()
trainer.fit(model, train_dataloader, val_dataloader)

O Trainer lida com o loop de época, validação e registro automaticamente. Podemos avaliar o modelo em dados de teste:

result = trainer.test(model, test_dataloader)
print(result)

Para efeito de comparação, aqui está o código da rede e do loop de treinamento em PyTorch puro:

import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader # Assume Net class and train_dataloader, val_dataloader, test_dataloader are defined class Net(torch.nn.Module): # Define your network architecture here pass # Initialize model and optimizer
model = Net()
optimizer = torch.optim.Adam(model.parameters(), lr=0.02) # Training Loop
for epoch in range(10): # Number of epochs for batch_idx, (x, y) in enumerate(train_dataloader): optimizer.zero_grad() y_hat = model(x) loss = F.cross_entropy(y_hat, y) loss.backward() optimizer.step() # Validation Loop
model.eval()
with torch.no_grad(): for x, y in val_dataloader: y_hat = model(x) # Testing Loop and Evaluate
model.eval()
test_loss = 0
with torch.no_grad(): for x, y in test_dataloader: y_hat = model(x) test_loss += F.cross_entropy(y_hat, y, reduction='sum').item()
test_loss /= len(test_dataloader.dataset)
print(f"Test loss: {test_loss}")

O Lightning torna o desenvolvimento do modelo PyTorch incrivelmente rápido e intuitivo.

O Lightning fornece muitos recursos integrados para ajuste de hiperparâmetros, prevenção de overfitting e gerenciamento de modelos.

Ajuste de hiperparâmetros

Podemos otimizar hiperparâmetros como taxa de aprendizagem usando Lightning's tuner módulo:

tuner = pl.Tuner(trainer)
tuner.fit(model, train_dataloader)
print(tuner.results)

Isso executa uma pesquisa bayesiana no espaço de hiperparâmetros.

Lidando com overfitting

Estratégias como camadas de abandono e parada antecipada podem reduzir o overfitting:

model = LitModel()
model.add_module('dropout', nn.Dropout(0.2)) # Regularization trainer = pl.Trainer(early_stop_callback=True) # Early stopping

Salvando e Carregando Modelo

O Lightning simplifica salvar e recarregar modelos:

# Save
trainer.save_checkpoint("model.ckpt") # Load
model = LitModel.load_from_checkpoint(checkpoint_path="model.ckpt")

Isso preserva o estado completo do modelo e os hiperparâmetros.

Tanto PyTorch quanto PyTorch Lightning são bibliotecas poderosas para aprendizado profundo, mas atendem a propósitos diferentes e oferecem recursos exclusivos. Embora o PyTorch forneça os blocos básicos para projetar e implementar modelos de aprendizado profundo, o PyTorch Lightning visa simplificar as partes repetitivas do treinamento do modelo, acelerando assim o processo de desenvolvimento.

Diferenças Chaves

Aqui está um resumo das principais diferenças entre PyTorch e PyTorch Lightning:

Flexibilidade vs Conveniência

PyTorch é conhecido por sua flexibilidade, principalmente com gráficos de computação dinâmica, o que é excelente para pesquisa e experimentação. No entanto, essa flexibilidade geralmente acarreta o custo de escrever mais código clichê, especialmente para o loop de treinamento, treinamento distribuído e ajuste de hiperparâmetros. Por outro lado, o PyTorch Lightning abstrai grande parte desse padrão, ao mesmo tempo que permite personalização total e acesso às APIs PyTorch de nível inferior quando necessário.

Velocidade de Desenvolvimento

Se você estiver iniciando um projeto do zero ou conduzindo experimentos complexos, o PyTorch Lightning pode economizar muito tempo. A classe LightningModule agiliza o processo de treinamento, automatiza o registro e até simplifica o treinamento distribuído. Isso permite que você se concentre mais na arquitetura do modelo e menos nos aspectos repetitivos do treinamento e validação do modelo.

O Veredicto

Em resumo, o PyTorch oferece um controle mais granular e é excelente para pesquisadores que precisam desse nível de detalhe. O PyTorch Lightning, no entanto, foi projetado para tornar o ciclo da pesquisa à produção mais suave e rápido, sem prejudicar o poder e a flexibilidade que o PyTorch oferece. A escolha do PyTorch ou do PyTorch Lightning dependerá de suas necessidades específicas, mas a boa notícia é que você pode alternar facilmente entre os dois ou até mesmo usá-los em conjunto para diferentes partes do seu projeto.

Neste artigo, cobrimos os princípios básicos do uso do PyTorch e do PyTorch Lightning para aprendizado profundo:

• PyTorch fornece uma estrutura poderosa e flexível para a construção de redes neurais
• PyTorch Lightning simplifica fluxos de trabalho de treinamento e desenvolvimento de modelos
• Recursos importantes como otimização de hiperparâmetros e gerenciamento de modelos aceleram a pesquisa de aprendizagem profunda

Com essas bases você pode começar a construir e treinar modelos avançados como CNNs, RNNs, GANs e muito mais. A comunidade ativa de código aberto também oferece suporte ao Lightning e adições como Bolt, uma biblioteca de componentes e otimização.

Feliz aprendizado profundo!

 
 
Mateus Mayo (@mattmayo13) possui mestrado em ciência da computação e pós-graduação em mineração de dados. Como editor-chefe do KDnuggets, Matthew pretende tornar acessíveis conceitos complexos de ciência de dados. Seus interesses profissionais incluem processamento de linguagem natural, algoritmos de aprendizado de máquina e exploração de IA emergente. Ele é movido pela missão de democratizar o conhecimento na comunidade de ciência de dados. Matthew codifica desde os 6 anos de idade.
 

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• Fonte: https://www.kdnuggets.com/5-steps-getting-started-pytorch?utm_source=rss&utm_medium=rss&utm_campaign=getting-started-with-pytorch-in-5-steps