Aprendizado Profundo Aplicado com PyTorch (Do Zero à Mestria)

Visão Geral: Esta aula fundamental apresenta o PyTorch e sua estrutura de dados central: o tensor. Começaremos estabelecendo por que o PyTorch é o framework preferido para pesquisas modernas em aprendizado profundo, enfatizando seu gráfico computacional dinâmico. O foco técnico principal é dominar a manipulação de tensores. Os alunos aprenderão a inicializar tensores — variando de escalares 0D a matrizes de dimensões superiores — usando diversos métodos (por exemplo, torch.zeros(), torch.rand()). Operações cruciais serão abordadas, incluindo aritmética elementar (adição, multiplicação) e operações especializadas de álgebra linear, como multiplicação de matrizes (torch.matmul). Também exploraremos técnicas de gerenciamento estrutural, como indexação, fatiamento, redimensionamento (.view(), .reshape()), e remoção de dimensões redundantes (.squeeze()). Finalmente, cobriremos o conceito crítico de utilizar diferentes dispositivos (CPU vs. GPU) via .to(), preparando os alunos para cálculos acelerados nas aulas subsequentes.

Resultados de Aprendizagem:

• Explicar o papel dos tensores como estrutura de dados fundamental no aprendizado profundo e no PyTorch.
• Criar e inicializar tensores do PyTorch de diversas dimensões (escalares, vetores, matrizes) usando métodos embutidos.
• Realizar aritmética padrão com tensores e operações especializadas como multiplicação de matrizes.
• Manipular a estrutura do tensor usando técnicas de indexação, fatiamento, redimensionamento e compactação.
• Mover tensores de forma eficiente entre dispositivos CPU e GPU para cálculos acelerados.

Visão Geral: Esta aula estabelece o fluxo de trabalho essencial e reprodutível do PyTorch, implementando um modelo básico de regressão linear do zero. Começamos com a preparação dos dados, focando na geração de dados sintéticos e na divisão entre conjuntos de treino e teste, destacando a importância da alinhamento de tipo de dado e dispositivo (CPU/GPU). Em seguida, definimos a arquitetura do modelo corretamente herdando de torch.nn.Module e implementando o método forward(). O cerne do fluxo envolve selecionar funções de perda adequadas (como nn.L1Loss para regressão) e otimizadores (Gradiente Estocástico Descendente ou SGD). Em seguida, construiremos meticulosamente o loop de treinamento (passagem para frente, cálculo de perda, zerar gradientes, passagem para trás, atualização do otimizador) e o loop de teste/avaliação para medição de desempenho. Por fim, concluímos o framework aprendendo a salvar dicionários de estado do modelo treinado usando torch.save() e carregá-los novamente para inferência ou reutilização, completando todo o ciclo end-to-end de ML.

Resultados de Aprendizagem:

• Estruturar e implementar os seis passos fundamentais do fluxo de trabalho end-to-end de machine learning do PyTorch.
• Construir um modelo linear simples definindo corretamente uma classe que herda de torch.nn.Module.
• Aplicar funções de perda adequadas (nn.L1Loss) e otimizadores (torch.optim.SGD) para tarefas básicas de regressão.
• Definir e executar o loop de treinamento, incluindo retropropagação e descida de gradiente, e o loop separado de avaliação.
• Implementar funcionalidade para salvar e carregar dicionários de estado do modelo usando utilitários do PyTorch para persistência de modelos.

Visão Geral: Esta aula aplica o fluxo de trabalho do PyTorch para resolver problemas de classificação não lineares, indo além da regressão linear simples. Começamos diferenciando entre cenários binários e multiclasse, demonstrando como estruturar a camada final de saída usando ativações Sigmoid (para binário) e Softmax (para multiclasse). O conceito crucial de não linearidade é introduzido integrando funções de ativação ReLU nas camadas ocultas, permitindo que a rede aprenda fronteiras de decisão complexas. Os alunos implementarão as funções de perda corretas para classificação: BCEWithLogitsLoss e CrossEntropyLoss. O componente prático envolve gerar e treinar uma rede neural em um conjunto de dados sintéticos complexo (por exemplo, o conjunto de dados 'moons') e plotar visualmente a superfície de decisão resultante para confirmar a capacidade da rede de separar pontos de dados não lineares de forma eficaz, garantindo domínio das arquiteturas fundamentais de modelos de aprendizado profundo.

Resultados de Aprendizagem:

• Diferenciar e implementar modelos do PyTorch para tarefas de classificação binária e multiclasse.
• Explicar a necessidade de funções de ativação não lineares (ReLU, Sigmoid, Softmax) para habilitar fronteiras de decisão complexas.
• Aplicar funções de perda apropriadas (BCEWithLogitsLoss, CrossEntropyLoss) e calcular métricas de precisão de classificação.
• Implementar todo o fluxo de trabalho de classificação do PyTorch em um conjunto de dados não linear.
• Visualizar a fronteira de decisão aprendida por um modelo e interpretar sua capacidade de classificar pontos de dados.

Visão Geral: Esta sessão marca a transição crítica de lidar com dados estruturados para processar dados de imagem de alta dimensão, exigindo arquiteturas especializadas de aprendizado profundo. Começaremos desmistificando a representação de imagens como tensores multidimensionais do PyTorch, focando intensamente na notação padrão de formato (N, C, H, W: Tamanho do Lote, Canais, Altura, Largura). O núcleo teórico introduz as Redes Neurais Convolucionais (CNNs) explicando como camadas convolucionais (nn.Conv2d) extraem eficientemente características espaciais locais, e como camadas de pooling (nn.MaxPool2d) reduzem a dimensionalidade preservando informações importantes. Através de uma abordagem code-first, construiremos e trearemos uma arquitetura completa e pequena de CNN — uma réplica do TinyVGG — do zero, fornecendo um exemplo prático de modelo funcional de visão computacional. Finalmente, compararemos as diferenças fundamentais entre esta estrutura de CNN e as redes lineares usadas anteriormente para solidificar a intuição sobre por que as CNNs se destacam no reconhecimento de padrões em imagens.

Resultados de Aprendizagem:

• Explicar e utilizar o formato de tensor (N, C, H, W) para representar dados de imagem no PyTorch.
• Implementar camadas convolucionais (nn.Conv2d) e de pooling (nn.MaxPool2d) dentro de um modelo do PyTorch.
• Construir e treinar uma arquitetura completa de CNN de pequeno porte (uma réplica do TinyVGG) para uma tarefa de classificação.
• Articular as diferenças fundamentais na extração de características e capacidades de compartilhamento de pesos entre camadas lineares e CNNs.

Visão Geral: Esta sessão crucial pontua a lacuna entre exemplos estruturados (como MNIST) e dados de imagem real-world complexos e não estruturados, preparando o terreno para o projeto prático "FoodVision" de visão computacional. Começaremos aprendendo a estruturar diretórios de dados corretamente para o PyTorch, utilizando a classe altamente eficiente torchvision.datasets.ImageFolder para carregamento automático e inferência de rótulos a partir dos caminhos dos arquivos. Crucialmente, dominaremos o conceito da classe personalizada torch.utils.data.Dataset, que proporciona controle total sobre a lógica de carregamento de dados, pré-processamento e tratamento de rótulos para formatos arbitrários. Em seguida, introduziremos o DataLoader para gerenciar o carregamento eficiente de lotes, embaralhamento e carregamento multi-threaded. Por fim, a sessão abordará técnicas essenciais de aumento de dados e transformações do PyTorch, vitais para expandir o tamanho efetivo de conjuntos de dados limitados e melhorar a generalização e robustez do modelo.

Resultados de Aprendizagem:

• Estruturar dados de imagem do mundo real em formatos de diretório esperados pelas ferramentas do PyTorch.
• Utilizar torchvision.datasets.ImageFolder para carregar conjuntos de dados de imagem personalizados do disco de forma eficiente.
• Implementar uma classe personalizada torch.utils.data.Dataset para lidar com requisitos únicos ou complexos de carregamento de dados.
• Aplicar uma variedade de torchvision.transforms para pré-processamento (redimensionamento, conversão para tensor) e aumento de dados (rotação, espelhamento).
• Integrar a Dataset com o DataLoader para gerenciar lotes, embaralhamento e carregamento paralelo otimizado.

Visão Geral: Esta sessão é crucial para a transição de código experimental em notebooks Jupyter para práticas sustentáveis de engenharia de software prontas para produção no ecossistema PyTorch. Cobriremos os passos obrigatórios para refatorar código monolítico de notebook em scripts Python estruturados e reutilizáveis. O conceito central envolve estabelecer uma estrutura padrão de projeto PyTorch, separando preocupações em módulos dedicados. Módulos-chave a serem criados incluem data_setup.py (responsável pelo carregamento de dados, transformações e DataLoaders), model_builder.py (contendo definições de modelos herdando de nn.Module) e engine.py (gerenciando loops de treinamento e teste). Finalmente, os alunos aprenderão como inicializar e executar todo o fluxo de treinamento — incluindo a definição de hiperparâmetros e seleção de dispositivo — diretamente pela linha de comando usando execução padrão do Python, essencial para implantação e experimentação em larga escala.

Resultados de Aprendizagem:

• Explicar as diferenças entre código experimental de notebook e arquitetura modular e organizada de scripts Python.
• Implementar uma estrutura padrão de projeto PyTorch projetada para escalabilidade e colaboração.
• Refatorar a lógica existente de treinamento de modelo em módulos distintos e reutilizáveis (por exemplo, data_setup.py, model_builder.py, engine.py).
• Configurar um script principal para executar todo o processo de treinamento via linha de comando.
• Descrever os benefícios práticos do código modular quanto a testes, controle de versão e prontidão para implantação em produção.

Visão Geral: A Transferência de Aprendizado é uma técnica poderosa que permite aproveitar conhecimentos adquiridos de modelos treinados em grandes conjuntos de dados, como ImageNet, e aplicá-los de forma eficiente a problemas menores e especializados. Esta sessão introduz a teoria básica, enfatizando por que pesos pré-treinados (especificamente de modelos como ResNet ou EfficientNet via torchvision.models) são cruciais para alcançar resultados de vanguarda com menos dados e tempo de computação. A implementação prática concentra-se em Extração de Características: os alunos aprenderão a carregar um modelo, congelar os parâmetros de suas camadas base convolucionais usando requires_grad=False do PyTorch, e depois substituir e treinar apenas a cabeça final de classificação adaptada a um novo domínio, como o projeto contínuo "FoodVision". Também contrastaremos este método com a abordagem mais intensiva em computação de Fine-tuning da rede inteira.

Resultados de Aprendizagem:

• Explicar a vantagem teórica e os cenários comuns onde a Transferência de Aprendizado é necessária.
• Carregar e inspecionar arquiteturas de modelos pré-treinados comuns usando a utilidade torchvision.models do PyTorch.
• Implementar Extração de Características com sucesso, congelando os parâmetros das camadas convolucionais base.
• Modificar a cabeça de classificação de um modelo pré-treinado para lidar com novas tarefas de classificação personalizadas.
• Diferenciar as estratégias de Extração de Características (congelamento) e Fine-tuning (descongelamento).

Visão Geral: À medida que avançamos de treinar modelos individuais para executar comparações sofisticadas (por exemplo, comparar uma CNN vanilla com um modelo de Transferência de Aprendizado), o rastreamento manual torna-se insuficiente. Esta aula estabelece a prática crucial de rastreamento sistemático de experimentos. Introduziremos e implementaremos a solução nativa do PyTorch, torch.utils.tensorboard.SummaryWriter, para registrar e gerenciar dados de desempenho. Os alunos aprenderão a instrumentar seus loops de treinamento para registrar métricas escalares vitais, como perda de treinamento e teste, acurácia e taxas de aprendizado por época. O objetivo principal é dominar a execução e utilização da interface TensorBoard para comparar visualmente os resultados de múltiplos experimentos lado a lado, permitindo análise objetiva de mudanças de hiperparâmetros, decisões arquiteturais e estratégias de otimização, garantindo reprodutibilidade e acelerando a melhoria do modelo.

Resultados de Aprendizagem:

• Explicar a necessidade de rastreamento sistemático de experimentos para garantir reprodutibilidade e eficiência no aprendizado profundo.
• Implementar a classe torch.utils.tensorboard.SummaryWriter para registrar métricas escalares (perda, acurácia) dentro de um loop de treinamento do PyTorch.
• Iniciar e navegar pela interface TensorBoard para visualizar curvas de métricas e comparar o desempenho de diferentes execuções experimentais.
• Aplicar técnicas de rastreamento para comparar sistematicamente o impacto de diferentes configurações de hiperparâmetros (por exemplo, tamanho de lote, taxa de aprendizado) e arquiteturas de modelo.

Visão Geral: Esta aula serve como ápice do curso, desafiando os alunos a traduzir pesquisas teóricas em aprendizado profundo em código funcional replicando uma arquitetura moderna a partir de um artigo científico. Começaremos desmistificando a estrutura de um artigo típico de ML, focando especificamente em como extrair detalhes arquiteturais e formulações matemáticas da seção de Metodologia. A tarefa técnica principal envolve mapear equações matemáticas complexas — como aquelas que governam mecanismos de atenção ou tipos de camadas novas — diretamente em módulos do PyTorch usando classes nn.Module personalizadas. Um exemplo moderno, como o Vision Transformer (ViT), será usado como estudo de caso para implementação. O foco estará em estratégias sistemáticas de depuração necessárias para modelos complexos e multi-componentes, abordando desafios como compatibilidade de formas, inicialização de pesos e verificação do fluxo de gradientes, garantindo que os alunos possam implementar com sucesso modelos de ponta do zero.

Resultados de Aprendizagem:

• Decompor e analisar descrições arquiteturais e notações matemáticas apresentadas em artigos de pesquisa em aprendizado de máquina.
• Traduzir etapas algorítmicas complexas e fórmulas (por exemplo, mecanismos de auto-atenção) diretamente em código PyTorch idiomático usando classes nn.Module personalizadas.
• Implementar e integrar todos os componentes necessários de uma arquitetura moderna e complexa de aprendizado profundo (por exemplo, Vision Transformer) completamente do zero.
• Aplicar estratégias avançadas de depuração para resolver erros de forma, conflitos de dispositivo e falhas lógicas encontradas ao replicar modelos de vanguarda.

Visão Geral: Esta aula final foca na transição de um modelo PyTorch treinado do ambiente de pesquisa para uma aplicação web interativa acessível publicamente. Começaremos aprendendo os passos cruciais de preparar um modelo para implantação, com foco no carregamento eficiente e inferência em produção. A atividade prática principal envolve construir uma demonstração funcional de web usando ferramentas de prototipagem rápida como Gradio ou Streamlit, permitindo que usuários finais insiram dados e recebam previsões instantâneas. Cobriremos estratégias práticas para hospedar essas aplicações, aproveitando plataformas como Hugging Face Spaces. Finalmente, dedicaremos tempo para explorar o futuro do framework, especificamente olhando para as melhorias de desempenho e recursos de compilação introduzidos no PyTorch 2.0, demonstrando como inovações como 'torch.compile' oferecem ganhos significativos de velocidade tanto para treinamento quanto para implantação.

Resultados de Aprendizagem:

• Preparar um artefato de modelo PyTorch treinado para carregamento eficiente e inferência em produção.
• Desenvolver uma interface funcional e interativa de demonstração web usando Gradio ou Streamlit.
• Hospedar a aplicação de aprendizado de máquina desenvolvida em uma plataforma pública (por exemplo, Hugging Face Spaces).
• Explicar o conceito central e o mecanismo da funcionalidade 'torch.compile' do PyTorch 2.0.
• Integrar conhecimentos de implantação com práticas de código modular anteriores para criar um projeto final end-to-end.