Skip to main content
Ameerpet, Hyderabad · Classroom & live online
Cloud Soft Solutions

PyTorch Certified Associate (PTCA) Exam Guide 2026: 4 Domains, Tensors, Training Loops, Mixed Precision, DDP, 5-Week Plan and 15 Questions

PyTorch Certified Associate (PTCA) from the Linux Foundation: 120 minutes, multiple choice, beginner level, US$250 with one retake, valid 2 years. The four domains with weights, a complete training loop, mixed precision, torch.compile, profiling and DDP basics, a 5-week plan and 15 practice questions.

PyTorch Certified Associate PTCA exam guide 2026, Cloud Soft Solutions
Last updated · 5 min read · 1,089 words

PyTorch Certified Associate PTCA exam guide 2026, Cloud Soft Solutions

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)

ItemDetail
FormatOnline, proctored, multiple choice
Duration120 minutes
LevelBeginner; no prerequisites
PriceUS$250 exam only; US$299 with the Certification Pathway learning modules; US$495 with an annual THRIVE-ONE subscription
RetakeOne retake included
Validity2 years
Eligibility12 months to schedule and take the exam

Read the official PTCA exam page and the PyTorch tutorials.

Domains and weights

DomainWeightCompetencies (from the Linux Foundation)
PyTorch Fundamentals38%Core concepts; tensors; training, testing and using models; device basics (CPU, CUDA, MPS)
Performance & Optimization26%Precision and execution optimisation; measuring performance; distributed training
Model Development20%PyTorch neural network building blocks
Data Handling16%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

TechniqueWhat 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_memoryLoads batches in parallel and speeds up copies to the GPU
Measuring correctlyGPU 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
FSDPShards 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

WeekFocusPractice
1Tensors: creation, dtypes, shapes, indexing, broadcasting, reshape vs view, devicesPredict the output shape of 30 tensor operations, then check
2Autograd, loss functions, optimisers, training and evaluation loops, saving and loadingWrite the training loop above from memory
3nn.Module building blocks: Linear, Conv2d, RNN/LSTM basics, embeddings, normalisation, dropout, activationsTrain a small CNN on a public image dataset such as FashionMNIST
4Data: custom Dataset classes, DataLoader options, transforms, train/validation/test splitsWrite a custom Dataset for a CSV file
5Performance: autocast, torch.compile, profiling, DDP and FSDP concepts; reviewTime 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

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.

Share𝕏inf✉
EnrollWhatsAppCall us