Tensores PyTorch e Autograd
torch.Tensor, requires_grad, backward(), cálculo de gradientes e operações com tensores.
Tensores PyTorch e Autograd é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn AI with Python, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn AI with Python inclui 4 aulas no total.
O que é PyTorch?
PyTorch é uma estrutura de aprendizagem profunda baseada em tensores, matrizes multidimensionais com aceleração por GPU e diferenciação automática. Os dois pilares que deve dominar primeiro são os tensores e a diferenciação automática.
pip install torch
import torchCriando tensores
Um tensor é semelhante a uma matriz do NumPy, mas pode residir em uma GPU e acompanhar gradientes. Crie um com torch.tensor. Os tensores têm uma shape e um dtype.
x = torch.tensor([1.0, 2.0, 3.0])
print(x.shape) # torch.Size([3])
print(x.dtype) # torch.float32Operações com tensores
Os tensores permitem cálculos elemento a elemento, multiplicação de matrizes e remodelagem. As operações são vetorizadas e executadas rapidamente pelo hardware. Essa é a base computacional de toda rede neural.
a = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
b = torch.tensor([[5.0, 6.0], [7.0, 8.0]])
print(a + b)
print(a @ b) # matrix multiplyrequires_grad: rastreamento de gradientes
Para calcular gradientes, crie um tensor com requires_grad=True. O PyTorch registra então cada operação realizada nele, construindo um grafo computacional que pode diferenciar posteriormente.
x = torch.tensor([2.0, 3.0], requires_grad=True)
print(x.requires_grad) # TrueConstruindo um cálculo
Aplique operações a um tensor que acompanha gradientes para produzir uma saída escalar. Aqui, elevamos cada elemento ao quadrado e calculamos a soma, obtendo um único número que podemos diferenciar em relação a x.
x = torch.tensor([2.0, 3.0], requires_grad=True)
y = x.pow(2).sum() # y = x0^2 + x1^2
print(y) # tensor(13., grad_fn=...)Chamando backward()
Chame .backward() em um escalar para calcular gradientes por retropropagação. O PyTorch percorre o grafo registrado no sentido inverso, preenchendo os derivados automaticamente.
y.backward()Lendo .grad
Após backward(), cada tensor de entrada armazena seu gradiente em .grad. Para y = sum(x^2), a derivada é 2x, portanto o gradiente é [4, 6].
print(x.grad) # tensor([4., 6.])Os gradientes se acumulam
Há uma armadilha sutil: os gradientes se somam em várias chamadas de backward(). Em um ciclo de treinamento, deve zerá-los a cada etapa com x.grad.zero_() ou com o zero_grad() do otimizador.
x.grad.zero_() # reset before the next backward()torch.no_grad() para inferência
Durante a inferência, não precisa de gradientes, e acompanhá-los desperdiça memória. Envolva o código de previsão em with torch.no_grad(): para desativar a construção do grafo e acelerar a execução.
with torch.no_grad():
preds = x.pow(2).sum()
print(preds.requires_grad) # Falsedetach() para interromper o fluxo de gradientes
.detach() retorna um tensor que compartilha os dados, mas é retirado do grafo computacional. Use-o para utilizar um valor sem permitir que os gradientes fluam de volta por ele, por exemplo, ao registrar informações ou congelar parte de uma rede.
z = x.detach()
print(z.requires_grad) # FalsePor que a diferenciação automática é importante
A diferenciação automática é o que torna a aprendizagem profunda prática: define o cálculo direto, e o PyTorch deriva automaticamente os gradientes para a retropropagação. Todo ciclo de treinamento que escrever se baseia em requires_grad, backward e .grad.
Verificação rápida
Teste sua compreensão da diferenciação automática.
Recapitulação: tensores e diferenciação automática
Você criou tensores com torch.tensor e ativou o rastreamento de gradientes por meio de requires_grad=True. Calculou uma saída, executou .backward() e leu as derivadas em .grad. Aprendeu que os gradientes se acumulam, usou torch.no_grad() para inferência e .detach() para interromper o fluxo de gradientes.
Perguntas Frequentes
A aula “Tensores PyTorch e Autograd” é grátis?
Sim — o texto completo de “Tensores PyTorch e Autograd” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn AI with Python, atualize para CoddyKit PRO. O curso de Learn AI with Python inclui 4 aulas no total.
O que vou aprender em “Tensores PyTorch e Autograd”?
torch.Tensor, requires_grad, backward(), cálculo de gradientes e operações com tensores. Você pratica Learn AI with Python com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Learn AI with Python?
Nenhuma experiência prévia é necessária. Learn AI with Python no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Tensores PyTorch e Autograd”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Learn AI with Python?
Sim. Cada aula de Learn AI with Python inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Tensores PyTorch e Autograd
- Conjuntos de dados e DataLoaders personalizados
- Construção e treinamento de CNNs com PyTorch
- Detecção de objetos com YOLOv8