Programando Redes Neurais em PyTorch em Apenas 10 Minutos #1

Olá e bem-vindo ao primeiro tutorial da série "Programando em 10 minutos" sobre Redes Neurais em PyTorch! Neste tutorial, vamos abordar o básico de como criar e treinar redes neurais utilizando a biblioteca PyTorch em apenas 10 minutos. Vamos lá!

O PyTorch é uma biblioteca de aprendizado de máquina de código aberto que oferece suporte a computação numérica eficiente utilizando tensores. Ele também é conhecido por sua facilidade de uso e flexibilidade para desenvolvimento de modelos de aprendizado profundo. Vamos começar instalando o PyTorch em seu ambiente Python:

!pip install torch torchvision

Agora que temos o PyTorch instalado, vamos começar a construir nossa rede neural. Vamos criar uma rede simples com uma camada de entrada, uma camada oculta e uma camada de saída. Aqui está o código para isso:

import torch
import torch.nn as nn

class RedeNeural(nn.Module):
    def __init__(self):
        super(RedeNeural, self).__init__()
        self.camada_oculta = nn.Linear(784, 128)  # 784 é o número de features de entrada, 128 é o número de neurônios na camada oculta
        self.camada_saida = nn.Linear(128, 10)  # 10 é o número de classes de saída

    def forward(self, x):
        x = torch.flatten(x, 1)  # Achatando os dados de entrada
        x = torch.relu(self.camada_oculta(x))  # Aplicando a função de ativação ReLU na camada oculta
        x = self.camada_saida(x)  # Camada de saída
        return x

Agora que temos nossa rede neural definida, vamos instanciá-la e definir a função de perda e otimizador que usaremos para treinar o modelo. Vamos usar o conjunto de dados MNIST para este tutorial:

from torchvision import datasets, transforms

# Carregando o dataset MNIST
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])  # Normalizando os dados
train_dataset = datasets.MNIST('data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)

# Instanciando a rede neural
rede = RedeNeural()

# Definindo a função de perda e o otimizador
criterio = nn.CrossEntropyLoss()
otimizador = torch.optim.Adam(rede.parameters(), lr=0.001)

Agora vamos treinar nosso modelo! Vamos executar o loop de treinamento por 10 épocas e imprimir a precisão do modelo a cada época:

# Treinamento do modelo
for epoch in range(10):
    for batch_idx, (x, y) in enumerate(train_loader):
        saida = rede(x)
        perda = criterio(saida, y)

        otimizador.zero_grad()
        perda.backward()
        otimizador.step()

        if batch_idx % 100 == 0:
            print('Época {}: Perda: {:.6f}'.format(epoch, perda.item()))

# Avaliando o modelo
rede.eval()
acuracia = 0
total = 0
for x, y in train_loader:
    saida = rede(x)
    _, pred = torch.max(saida, 1)
    acuracia += (pred == y).sum().item()
    total += y.size(0)

print('Acurácia do modelo: {:.2f}%'.format(100 * acuracia/total))

E é isso! Em apenas 10 minutos, você aprendeu como criar e treinar uma rede neural simples utilizando o PyTorch. Este é apenas o começo e há muito mais para explorar com o PyTorch. Continue praticando e experimentando para aprimorar suas habilidades em redes neurais. Espero que este tutorial tenha sido útil e que você esteja motivado a continuar aprendendo! Obrigado por ler e boa sorte em sua jornada de aprendizado de aprendizado de máquina com PyTorch.