
PTCA (PyTorch Certified Associate) is the Linux Foundation and PyTorch Foundation's beginner certification for PyTorch, the deep learning framework behind most modern AI research and many production models. The exam checks whether you understand tensors, devices, autograd, training and evaluation loops, nn.Module building blocks, datasets and DataLoaders, mixed precision, performance measurement and the basics of distributed training. It is a good credential for students and Python developers moving into ML engineering and generative AI roles, where interviewers often ask candidates to write a training loop.
This guide follows the official Linux Foundation exam page. It covers the exam facts, the four domains with weights, a complete training example, performance tips, a 5-week plan and 15 original practice questions.
Quick facts (Linux Foundation, November 2026)
| Item | Detail |
|---|---|
| Format | Online, proctored, multiple choice |
| Duration | 120 minutes |
| Level | Beginner; no prerequisites |
| Price | US$250 exam only; US$299 with the Certification Pathway learning modules; US$495 with an annual THRIVE-ONE subscription |
| Retake | One retake included |
| Validity | 2 years |
| Eligibility | 12 months to schedule and take the exam |
Read the official PTCA exam page and the PyTorch tutorials.
Domains and weights
| Domain | Weight | Competencies (from the Linux Foundation) |
|---|---|---|
| PyTorch Fundamentals | 38% | Core concepts; tensors; training, testing and using models; device basics (CPU, CUDA, MPS) |
| Performance & Optimization | 26% | Precision and execution optimisation; measuring performance; distributed training |
| Model Development | 20% | PyTorch neural network building blocks |
| Data Handling | 16% | Datasets; DataLoaders; transforms; training data |
Fundamentals is close to 40% of the score. You should be able to write a training loop from memory and predict tensor shapes without running the code.
A complete training example
import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset
device = ("cuda" if torch.cuda.is_available()
else "mps" if torch.backends.mps.is_available() else "cpu")
# Data: 1,000 samples, 20 features, 3 classes
X = torch.randn(1000, 20)
y = torch.randint(0, 3, (1000,))
train_dl = DataLoader(TensorDataset(X, y), batch_size=64, shuffle=True)
class Net(nn.Module):
def __init__(self):
super().__init__()
self.layers = nn.Sequential(
nn.Linear(20, 64), nn.ReLU(), nn.Dropout(0.2),
nn.Linear(64, 3)) # raw logits; no softmax here
def forward(self, x):
return self.layers(x)
model = Net().to(device)
loss_fn = nn.CrossEntropyLoss() # applies log-softmax internally
opt = torch.optim.AdamW(model.parameters(), lr=1e-3)
for epoch in range(5):
model.train() # enables dropout
for xb, yb in train_dl:
xb, yb = xb.to(device), yb.to(device)
opt.zero_grad()
loss = loss_fn(model(xb), yb)
loss.backward() # autograd computes gradients
opt.step()
model.eval() # disables dropout
with torch.no_grad(): # no gradient tracking for inference
preds = model(X[:5].to(device)).argmax(dim=1)
torch.save(model.state_dict(), "net.pt") # save weights, not the whole object
Performance and optimisation basics
| Technique | What it does |
|---|---|
Mixed precision (torch.autocast) | Runs suitable operations in float16 or bfloat16 for speed and memory savings; use a gradient scaler with float16 |
torch.compile(model) | Compiles the model into optimised kernels; the first call is slower, later calls are faster |
DataLoader num_workers and pin_memory | Loads batches in parallel and speeds up copies to the GPU |
| Measuring correctly | GPU calls are asynchronous: call torch.cuda.synchronize() before timing, or use torch.profiler |
| DistributedDataParallel (DDP) | One process per GPU, each with a model copy; gradients are averaged with all-reduce; launch with torchrun |
| FSDP | Shards parameters, gradients and optimiser state across GPUs for models too big for one GPU |
with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
loss = loss_fn(model(xb), yb)
# torchrun --nproc_per_node=4 train.py
5-week study plan
| Week | Focus | Practice |
|---|---|---|
| 1 | Tensors: creation, dtypes, shapes, indexing, broadcasting, reshape vs view, devices | Predict the output shape of 30 tensor operations, then check |
| 2 | Autograd, loss functions, optimisers, training and evaluation loops, saving and loading | Write the training loop above from memory |
| 3 | nn.Module building blocks: Linear, Conv2d, RNN/LSTM basics, embeddings, normalisation, dropout, activations | Train a small CNN on a public image dataset such as FashionMNIST |
| 4 | Data: custom Dataset classes, DataLoader options, transforms, train/validation/test splits | Write a custom Dataset for a CSV file |
| 5 | Performance: autocast, torch.compile, profiling, DDP and FSDP concepts; review | Time an epoch before and after mixed precision; book the exam |
Google Colab and Kaggle notebooks give you free GPU time for the CUDA exercises.
15 practice questions with answers
These are original questions written for this guide, not exam questions.
1. What is the shape of torch.zeros(2, 3) @ torch.zeros(3, 4)?
(2, 4).
2. What is the default dtype of torch.randn?
torch.float32.
3. Why call opt.zero_grad() each step?
PyTorch accumulates gradients by default; without zeroing, gradients from earlier batches add up.
4. What does loss.backward() do?
Computes gradients of the loss for every parameter with requires_grad=True.
5. What does model.eval() change?
Puts layers such as dropout and batch normalisation into inference behaviour.
6. Does model.eval() stop gradient tracking?
No. Use torch.no_grad() or torch.inference_mode() for that.
7. Should you apply softmax before nn.CrossEntropyLoss?
No. It expects raw logits and applies log-softmax itself.
8. Which device string targets Apple-silicon GPUs?
"mps".
9. Two tensors are on different devices. What happens when you add them?
A runtime error; move both to the same device first.
10. What is the recommended way to save a model for later loading?
Save model.state_dict() and load it into a new instance with load_state_dict().
11. What does a DataLoader add to a Dataset?
Batching, shuffling and parallel loading with worker processes.
12. Which two methods must a map-style custom Dataset implement?__len__ and __getitem__.
13. Why might the first call to a torch.compile model be slow?
It traces and compiles the model on the first run; later calls reuse the compiled code.
14. Why call torch.cuda.synchronize() before stopping a timer?
CUDA kernels run asynchronously, so otherwise you time the launch, not the work.
15. In DDP, how are gradients combined across GPUs?
With an all-reduce that averages them, so every model copy stays identical.
Before and after PTCA
- Get strong in Python first with our Python course.
- Take ML to the cloud with AWS ML Engineer Associate, Google Cloud ML Engineer or Databricks ML Associate.
- Learn AI hands-on in our AI, GenAI and Agentic AI course; see live AI and ML jobs.
Cloud Soft Solutions in Ameerpet, Hyderabad teaches Python, machine learning and generative AI with real-time projects. See the APEX program and all courses.
📞 Call +91 96660 19191 · WhatsApp · Flat No. 513, 5th Floor, Nilagiri Block, Aditya Enclave, Ameerpet, Hyderabad
Frequently Asked Questions
What is the PyTorch Certified Associate?
A beginner-level Linux Foundation certification (PTCA) that validates core PyTorch skills.
How long is the PTCA exam?
120 minutes, online proctored, multiple choice.
How much does PTCA cost?
US$250 for the exam only, with one retake included.
Which PTCA domain has the most weight?
PyTorch Fundamentals at 38%.
Are there prerequisites for PTCA?
No, but you should be comfortable with Python.
How long is PTCA valid?
2 years.



