PyTorch — Deep Learning Framework

Fundamentos do PyTorch 2.x: tensors, autograd e computational graph

PyTorch é um framework de deep learning Python‑first, baseado em tensors (arrays multidimensionais similares a NumPy, mas com suporte a GPU) e em grafos computacionais dinâmicos.

Conceitos chave:

• Tensors: estruturas base (torch.Tensor) com operações vetorizadas, suporte a CPU/GPU (.to(device)), tipos (float32, float16, bfloat16, etc.) e broadcasting.
• Computational graph dinâmico: a cada forward pass, PyTorch constrói um grafo que conecta operações e tensores; isso facilita debugging (quase como código Python puro).
• Autograd: sistema automático de diferenciação; tensores com requires_grad=True acumulam gradientes, e loss.backward() propaga derivadas pelo grafo.

Em PyTorch 2.x, o modelo padrão continua sendo eager execution, mas com torch.compile() é possível obter ganhos de performance sem abrir mão da natureza dinâmica.

Redes neurais com nn.Module

Arquiteturas são definidas como subclasses de nn.Module:

• __init__ define camadas (nn.Linear, nn.Conv2d, nn.LSTM, etc.).
• forward(self, x) define o fluxo de dados (forward pass).

Exemplo simplificado:

import torch.nn as nn

class MyModel(nn.Module):
    def __init__(self, in_features, hidden, out_features):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_features, hidden),
            nn.ReLU(),
            nn.Linear(hidden, out_features),
        )

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

Esse padrão oferece controle total sobre o forward, permitindo arquiteturas arbitrárias (residuals, attention, custom ops), com sintaxe Python idiomática.

Training loops e otimizadores (SGD, Adam, AdamW)

O ciclo de treinamento clássico em PyTorch:

1. model.train(); iterar sobre DataLoader.
2. Forward → cálculo de loss.
3. optimizer.zero_grad() → loss.backward() → optimizer.step().

Otimizadores em torch.optim:

• SGD (com/sem momentum, Nesterov).
• Adam: adaptativo, amplamente usado em NLP/visão.
• AdamW: variante de Adam com weight decay desacoplado, hoje o padrão recomendado para muitos modelos (e.g. transformers).

PyTorch 2.x mantém essas APIs, e torch.compile() pode envolver o model para acelerar treino/inferência com uma única linha.

Datasets e DataLoaders

Carregamento de dados:

• Datasets: subclasses de torch.utils.data.Dataset implementam __len__ e __getitem__, encapsulando lógica de acesso a dados (imagens, texto, tabular).
• DataLoader: empacota o dataset com batching, shuffling, multiprocess (num_workers), pinagem de memória e collate functions customizadas.

Para visão computacional, torchvision.datasets (CIFAR, ImageNet, COCO, etc.) e transforms (transforms.Compose) são amplamente usados; em NLP, usa‑se datasets da Hugging Face ou datasets customizados.

Transfer learning e fine-tuning (torchvision, Hugging Face)

PyTorch facilita o reuso de modelos pré‑treinados:

• torchvision.models: ResNet, EfficientNet, MobileNet, ViT, etc., com pesos pré‑treinados em ImageNet.
• Hugging Face Transformers: BERT, GPT, T5, ViT, CLIP, Stable Diffusion, etc., disponíveis via from_pretrained() com integração direta em PyTorch.

Padrão de fine‑tuning:

1. Carregar backbone pré‑treinado (pretrained=True / from_pretrained).
2. Congelar parte das camadas (requires_grad=False) para usar como feature extractor.
3. Substituir a head final por head específica da tarefa.
4. Treinar em dataset alvo com learning rate menor, usando schedulers e regularização adequada.

Visão computacional: CNNs e object detection

PyTorch é dominante em visão computacional:

• CNNs clássicas: ResNet, VGG, DenseNet, etc. para classificação de imagens.
• Detecção de objetos: implementações como torchvision.models.detection (Faster R‑CNN, RetinaNet, SSD), além de projetos externos como Detectron2 e YOLO em PyTorch.
• Segmentação: DeepLab, Mask R‑CNN, UNet, etc.

Treinamento envolve DataLoaders com augmentations, losses específicas (cross‑entropy, focal loss, IoU/box regression) e métricas (mAP, IoU).

NLP com transformers

Transformers em PyTorch:

• A biblioteca Transformers (Hugging Face) tem backend PyTorch por padrão, fornecendo modelos pré‑treinados, tokenizers, Trainer API e integração com aceleradores.
• Tarefas: classificação de texto, QA, NER, summarization, tradução, geração de texto, embeddings.

PyTorch 2.x, com torch.compile() e suporte distribuído aprimorado, permite treinar/ajustar grandes modelos transformers com melhor performance.

PyTorch Lightning: código mais limpo

PyTorch Lightning é um framework “opinionated” que organiza código PyTorch, separando:

• LightningModule: define modelo, loss, otimizadores e steps de treino/validação/teste.
• Trainer: gerencia loops, logging, callbacks, checkpoints, mixed precision, multi‑GPU/multi‑node.

Benefícios:

• Menos boilerplate em training loops.
• Treinamento distribuído (DDP), mixed precision e integração com loggers (TensorBoard, WandB) com poucas linhas de configuração.

Usado amplamente para pesquisa e produção, mantendo compatibilidade com PyTorch puro.

Exportação de modelos: ONNX e TorchScript

Para deployment em diferentes runtimes:

• TorchScript: serializa o modelo (scripted ou traced) para execução em C++/Java via libtorch, com otimizações de grafo; útil para ambientes onde Python não é desejado.
• ONNX: formato aberto; PyTorch exporta modelos via torch.onnx.export(), permitindo rodar em ONNX Runtime, TensorRT, OpenVINO e outros backends otimizados.

ONNX é a cola para interoperabilidade: um modelo PyTorch pode ser exportado, otimizado (quantização, fusão) e servido com ONNX Runtime em produção.

Deploy em produção com TorchServe

TorchServe é a solução oficial para servir modelos PyTorch em produção:

• Permite empacotar modelos como arquivos .mar (model archive) com pesos, código e config.
• Oferece três APIs:
  • Management API (:8081 ou :8080 em docs) para registrar/remover modelos, controlar versões e workers.
  • Inference API para requisições REST de inferência.
  • Metrics API (Prometheus) para métricas de uso/performance.
• Suporta multi‑model serving, autoscaling de workers e deployment com Docker/Kubernetes.

Guia de deploy TorchServe (Vultr):

• Artigo: https://docs.vultr.com/deploy-a-machine-learning-model-to-production-using-torchserve
• PDF completo com exemplos de APIs, Docker Compose e Nginx/SSL: https://docs.vultr.com/public/doc-assets/pdfs/article/deploy-a-machine-learning-model-to-production-using-torchserve.pdf
  Outro guia de fluxo TorchServe (ApX ML): https://apxml.com/courses/advanced-pytorch/chapter-4-deployment-performance-optimization/torchserve
  Artigo adicional: https://blog.cobrasoft.org/deploy-a-machine-learning-model-to-production-using-torchserve/

torch.compile e otimizações no PyTorch 2.x

PyTorch 2.0 introduziu torch.compile() como forma simples de acelerar código:

• Envolve o nn.Module em um compilador que gera kernels otimizados, reduzindo overhead Python e leituras/escritas desnecessárias em GPU.
• Benchmarks oficiais: torch.compile() funciona em ~93% dos 163 modelos testados (Hugging Face, timm, TorchBench) e fornece em média 43% de speedup no treinamento em A100 (21% em FP32, 51% em AMP).

Modos de otimização (API ainda evoluindo):

torch.compile(model)  # padrão, foca em grandes modelos
torch.compile(model, mode="reduce-overhead")  # melhora overhead em modelos pequenos
torch.compile(model, mode="max-autotune")     # busca máxima velocidade, com compile-time maior

Benchmarks independentes mostram:

• Modelos simples podem ficar iguais ou até levemente mais lentos, devido ao overhead de compilação.
• Modelos complexos (ConvNets grandes, arquiteturas mistas) podem alcançar speedups de até 5x em casos específicos.

Referências:

• Página oficial PyTorch 2.x: https://pytorch.org/get-started/pytorch-2-x/
• Tutoriais torch.compile end‑to‑end:
  • https://docs.pytorch.org/tutorials/intermediate/torch_compile_full_example.html
  • https://docs.pytorch.org/tutorials/intermediate/torch_compile_tutorial.html
• Análises práticas de benchmarks:
  • https://www.mrdbourke.com/pytorch-2/
  • https://ashishmalik.in/post/torch_compile/

Multi-GPU e treinamento distribuído

PyTorch oferece diversos padrões para escalar treinamento:

• DataParallel (DP): simples, mas menos eficiente; recomendado migrar para DDP.
• DistributedDataParallel (DDP): padrão de fato para multi‑GPU/multi‑node, com sincronização de gradientes via NCCL; bem suportado em Lightning e frameworks de RL/NLP.
• FSDP / ZeRO‑like: sharding de parâmetros/otimizadores/gradientes para treinar modelos muito grandes (billions de parâmetros).

PyTorch 2.x continua evoluindo as APIs de distribuição e integração com torch.compile(), tornando mais fácil combinar compilação + distribuição para performance máxima.

Comparativo PyTorch vs TensorFlow em 2026

O panorama 2025–2026:

• Dev experience & pesquisa:

  • PyTorch segue como padrão de fato em pesquisa (NeurIPS/ICLR/ICML, grandes modelos open‑source) devido à execução dinâmica, debugging intuitivo e ecossistema (Lightning, HF Transformers, timm, Diffusers).
  • TensorFlow, via Keras 3, melhora DX e pode usar múltiplos backends (TF, PyTorch, JAX), mas PyTorch ainda é visto como mais natural para Pythonistas.

• Performance:

  • Com torch.compile(), PyTorch 2.x atinge ou ultrapassa TensorFlow/XLA em muitos cenários de treino de GPU único.
  • TensorFlow ainda se destaca em inference otimizado em larga escala, especialmente com TF Serving, TFLite e integração profunda com TensorRT.

• Deployment / MLOps:

  • TensorFlow: stack de produção muito maduro (TF Serving, TFLite, TensorFlow.js, TFX), forte integração com GCP (Vertex AI) e enterprise.
  • PyTorch: melhorias significativas com TorchScript, ONNX Runtime, TorchServe e suporte de clouds (SageMaker, Azure ML, GCP), mas ainda percebido como menos “opinionated” que TF em MLOps puro.

• Adoção e comunidade:

  • Alguns estudos apontam TensorFlow ainda com maior market share geral (por volta de 38% vs 23% para PyTorch em 2025), puxado por legado enterprise.
  • Outros relatórios mostram PyTorch com ~55% de share em produção em Q3 2025, especialmente em empresas AI‑first e produtos recentes.
  • Consenso: PyTorch domina pesquisa e novos projetos; TensorFlow permanece forte em ambientes enterprise estabelecidos.

Referências de comparação:

• “PyTorch vs TensorFlow 2025: Which one wins after 72 hours?”: https://dev.to/dev_tips/pytorch-vs-tensorflow-2025-which-one-wins-after-72-hours-a2b
• “PyTorch vs TensorFlow (2026): Which Framework Should You Use?”: https://www.girikon.com/blog/pytorch-vs-tensorflow/
• “PyTorch Vs TensorFlow (2025): An In-Depth Comparison”: https://acecloud.ai/blog/pytorch-vs-tensorflow/
• Guia enterprise “PyTorch vs TensorFlow 2026: Enterprise AI Decision Guide”: https://americanchase.com/pytorch-vs-tensorflow/

Esses materiais detalham trade‑offs em DX, performance, deployment, ecosistema e casos de uso, ajudando a escolher o framework mais adequado para cada contexto em 2026.