Python com ML Básico
Carregando, aguarde alguns segundos.

30 - Arquiteturas de Deep Learning com TensorFlow / PyTorch

TensorFlow e PyTorch são dois dos frameworks mais populares para deep learning, oferecendo ferramentas robustas para construir e treinar redes neurais complexas.

Exemplo: Treinar uma Rede Neural com TensorFlow 

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten

# Carregar o conjunto de dados MNIST
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Pré-processamento dos dados
X_train = X_train / 255.0
X_test = X_test / 255.0

# Construir o modelo
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

# Compilar e treinar o modelo
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=5, batch_size=32, validation_data=(X_test, y_test))

# Avaliar o modelo
loss, accuracy = model.evaluate(X_test, y_test)
print(f'Accuracy: {accuracy}')

Exemplo: Treinar uma Rede Neural com PyTorch 

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from torchvision import datasets, transforms

# Carregar o conjunto de dados MNIST
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = DataLoader(trainset, batch_size=32, shuffle=True)

# Definir o modelo
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(28 * 28, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.flatten(x)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = Net()

# Definir a perda e o otimizador
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Treinar o modelo
for epoch in range(5):
    for images, labels in trainloader:
        optimizer.zero_grad()
        output = model(images)
        loss = criterion(output, labels)
        loss.backward()
        optimizer.step()
    print(f'Epoch {epoch+1}, Loss: {loss.item()}')

# Avaliar o modelo
testset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = DataLoader(testset, batch_size=32, shuffle=False)

correct = 0
total = 0
with torch.no_grad():
    for images, labels in testloader:
        output = model(images)
        _, predicted = torch.max(output.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

accuracy = correct / total
print(f'Accuracy: {accuracy}')

Exemplo: Treinar uma Rede Neural com PyTorch 

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor
import matplotlib.pyplot as plt

# Carregar o conjunto de dados MNIST
train_data = datasets.MNIST(
    root='data',
    train=True,
    download=True,
    transform=ToTensor()
)
test_data = datasets.MNIST(
    root='data',
    train=False,
    download=True,
    transform=ToTensor()
)

# Pré-processamento dos dados
train_dataloader = DataLoader(train_data, batch_size=32)
test_dataloader = DataLoader(test_data, batch_size=32)

# Construir o modelo
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
            nn.ReLU()
        )
    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

# Compilar e treinar o modelo
model = NeuralNetwork()
print(model)

# Avaliar o modelo
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)

# Treinar o modelo
epocas = 5
for t in range(epocas):
    print(f'Época {t+1}\n-------------------------------')
    train_loop(train_dataloader, model, loss_fn, optimizer)
    test_loop(test_dataloader, model, loss_fn)
print('Feito!')
Arduino
Coautor
Betobyte
Autor
Autores
||| Áreas ||| Estatística ||| Python ||| Projetos ||| Dicas & Truques ||| Quantum ||| Python com ML Básico || Python para Iniciantes || Python Básico || Matplotlib || Numpy || Seaborn || Pandas || Django || Estatística para Cientistas de Dados || Python com ML Básico || Python com ML Básico || Aulas | Introdução (Introdução) | Guia Rápido do Python (Guia Rápido do Python) | Aprendizado (Aprendizado supervisionado, não supervisionado e por reforço) | Modelos (Modelos de Regressão e Classificação) | Agrupamento (Algoritmos de Agrupamento) | Pre-processamento de Dados (Pré-processamento de dados e técnicas de engenharia de características) | Métricas (Métricas de avaliação para modelos de ML) | Treinamento e Avaliação (Funções para pré-processamento de dados, treinamento de modelos e avaliação) | Seaborn e Matplotlib (Seaborn e Matplotlib para visualização) | Pandas (Pandas para processamento) | Scikit-learn (Scikit-learn, uma biblioteca de ML em Python) | R (Pacotes dplyr, caret e vip para R) | Emsemble e RNA (Métodos de ensemble e redes neurais artificiais) | Aplicações (Aplicações de aprendizado de máquina) | Matemática (Fundamentos matemáticos para ML) | Otimização (Métodos de otimização e treinamento de modelos) | Problemas Comuns (Problemas comuns de ML e MLOps) | Ferramentas de Nuvem (Ferramentas baseadas em nuvem como GCP, AWS e Microsoft Azure) | Frameworks e Bibliotecas DL (Ferramentas de MLOps de código aberto como MLflow) | Ajustes de Hiperparâmetros (Técnicas de ajuste de hiperparâmetros como grid search e random search) | Frameworks e Biblioteca DL (Frameworks e bibliotecas de deep learning como PyTorch e TensorFlow) | Implementação (Implementar soluções de ML com conjuntos de dados do mundo real) | NLP (Visão computacional e Processamento de Linguagem Natural (NLP)) | Arquiteturas DL (Arquiteturas avançadas de deep learning como RNNs e GANs) | Arquiteturas LLM (Arquiteturas de transformadores em LLMs (BERT e GPT)) | Design (Design de aprendizado por reforço e RAG) | Ciclo de Vida de MLOps (Ciclo de vida de MLOps e últimas tendências de pesquisa em ML) | Provedores (Provedores de nuvem e ferramentas de código aberto para ciclo de vida completo de MLOps) | Frameworks RL (Frameworks de aprendizado por reforço como OpenAI Gym) | Ferramentas LLM (Langchain e ferramentas similares para LLMs customizados) | Repositórios LLKM (Desenvolver ou usar LLMs de repositórios como Hugging Face) | Arquitetura DL (Arquiteturas de deep learning com TensorFlow / PyTorch) |