PTCA Practice Test and Syllabus: PyTorch Associate Exam Prep

The PTCA exam, Linux Foundation PyTorch Certified Associate, is an online, proctored, multiple-choice test of core PyTorch skills. It has 60 questions, lasts 120 minutes, needs a 75% passing score and costs USD 250 as of October 2026. Its four domains are PyTorch Fundamentals (38%), Performance and Optimization (26%), Model Development (20%) and Data Handling (16%).

This guide covers each domain in the depth the exam expects, the exam rules that catch candidates out, and a six-week plan for people who already write some Python. When you want to measure your readiness under exam conditions, start the PTCA practice test, which follows the same four domains and the same 120-minute limit.

What is the PTCA certification and who is it for?

The PyTorch Certified Associate is an entry-level credential from the Linux Foundation for people who are starting to use PyTorch in machine learning work. According to the Linux Foundation's exam page, it is designed for early-stage practitioners who have some Python and machine learning experience and are beginning to use PyTorch. The experience level is listed as beginner, and there are no prerequisites to sit the exam.

That positioning matters when you decide whether to take it. PTCA does not expect you to design new model architectures or run large training clusters. It expects you to understand how tensors behave, how a model is built from standard building blocks, how a training loop works, how data reaches the model and which basic levers improve performance. Those are the skills a junior machine learning engineer, a data scientist moving from scikit-learn to deep learning, or a software engineer joining an AI team uses in the first months of the job.

The credential is useful mainly as a signal. A hiring manager reviewing a candidate without production machine learning experience has little to go on; a vendor-neutral certificate from the foundation that hosts PyTorch shows that the candidate has studied the framework systematically. It does not replace a portfolio, but it gives a portfolio context.

PTCA is also a sensible checkpoint for self-taught learners. Many people learn PyTorch from scattered tutorials and end up with gaps, often around devices, data loading or evaluation mode. Working through a domain list with published weights is an efficient way to find and close those gaps.

How is the PTCA exam structured?

PTCA is a 60-question, multiple-choice exam with a 120-minute time limit and a passing score of 75%. It is delivered online with a remote proctor, so you sit it from your own computer under supervision rather than at a test centre.

The Linux Foundation's page lists further terms that are easy to overlook. The purchase includes one retake, you have 12 months from purchase to take the exam, and the certification is valid for two years. Besides the USD 250 exam-only option, the foundation offers a USD 299 bundle that adds its PTCA Certification Pathway learning modules, and a USD 495 bundle with its THRIVE-ONE annual subscription. Prices are as listed in October 2026 and can change, so check before you buy.

Two minutes per question sounds generous, but a 75% pass mark leaves little room for careless errors. Fifteen wrong answers out of 60 is the most you can afford. Many questions describe a short piece of PyTorch behaviour in words and ask what happens, which rewards people who have actually run the code rather than read about it.

The current domain list, policies and candidate handbook are on the Linux Foundation's PTCA certification page, and the full objective breakdown with weights is on the PTCA syllabus page.

What does the PTCA syllabus cover, domain by domain?

The syllabus has four domains with published weights, and their sizes should shape your study time. PyTorch Fundamentals alone is 38% of the exam, more than a third, while Data Handling is the smallest at 16%.

PyTorch Fundamentals (38%)

This domain has four competencies: core concepts, tensors, training, testing and using models, and device basics covering CPU, CUDA, MPS and similar back ends. It is the foundation for every other domain.

Tensors are the centre of it. You should be comfortable creating tensors from Python lists and NumPy arrays, reading their shape, data type and device, and predicting the result of indexing, slicing, reshaping and broadcasting. Know the difference between operations that return a new tensor and in-place operations, conventionally marked with a trailing underscore, and know that some reshaping operations return views that share memory with the original.

Core concepts include automatic differentiation. A tensor created with requires_grad set to true records the operations applied to it, and calling backward on a scalar result fills the grad attribute of the leaf tensors. You should know why gradients accumulate across calls unless they are zeroed, and why inference code is wrapped in torch.no_grad or torch.inference_mode to stop gradient tracking.

Training, testing and using models covers the standard loop: put the model in training mode, run a forward pass, compute the loss, zero the gradients, call backward and step the optimizer. For evaluation the model goes into eval mode, which changes the behaviour of layers such as dropout and batch normalisation. Saving and loading a model's state_dict, and loading it back into a model of the same structure, also belongs here.

Device basics test whether you can move work to the right hardware. Models and tensors must be on the same device before they interact, which is done with the to method. Checks such as torch.cuda.is_available and torch.backends.mps.is_available decide whether a GPU on NVIDIA hardware or an Apple silicon GPU can be used, with the CPU as the fallback.

Model Development (20%)

Model Development has one competency, PyTorch neural network building blocks, but it is broad. A model is a subclass of nn.Module that defines its layers in the constructor and its computation in the forward method. You should recognise common layers such as nn.Linear, nn.Conv2d and nn.Embedding, activation functions such as ReLU, regularisation layers such as dropout, and normalisation layers.

Loss functions and optimizers sit alongside the layers. Know which loss suits which task, for example cross-entropy loss for multi-class classification, which expects raw scores rather than probabilities, and mean squared error for regression. Know how an optimizer such as SGD or Adam is created from the model's parameters and a learning rate, and what a learning-rate scheduler adds.

Questions in this domain often show a model description and ask about output shapes or parameter counts. Being able to trace the shape of a batch through each layer by hand is a skill worth practising.

Performance and Optimization (26%)

This domain has three competencies: precision and execution optimisation, performance measurement and distributed training. It is the second-largest domain and the one beginners most often underestimate.

Precision and execution optimisation covers running parts of a model in lower precision, such as float16 or bfloat16, to save memory and time. Automatic mixed precision with torch.autocast chooses a suitable precision per operation, and a gradient scaler protects float16 training from gradients that underflow to zero. Execution optimisation also includes compiling a model with torch.compile, which can speed up training and inference without changing the model code.

Performance measurement is about evidence. The PyTorch profiler shows where time and memory go, and simple timing must account for the fact that GPU work runs asynchronously, so a synchronisation step is needed before reading the clock. Knowing how to find the bottleneck, whether data loading, a single layer or memory transfers, is more valuable than knowing a list of tricks.

Distributed training at associate level means understanding the concepts: data parallelism, where each process holds a copy of the model and works on a different slice of the data, and DistributedDataParallel as the standard way to do it, typically launched with torchrun. You should know why gradients are synchronised across processes and what that implies for batch size and learning rate.

Data Handling (16%)

Data Handling covers datasets, DataLoaders, transforms and training data. A custom dataset implements a length method and an item method that returns one sample, often as an input and label pair. A DataLoader wraps the dataset and handles batching, shuffling and parallel loading through worker processes.

Transforms prepare raw data for the model: converting images to tensors, normalising values, resizing and applying random augmentation to the training set only. Training data questions test sound practice, such as keeping separate training, validation and test sets, shuffling training data but not evaluation data, and avoiding information from the test set leaking into training.

Which PTCA domain is hardest for candidates with a Python background?

For most candidates who already write Python, Performance and Optimization is the hardest domain. At 26% of the exam it is too large to skip, yet topics such as mixed precision, compilation, profiling and distributed training rarely come up in beginner tutorials or small personal projects.

The reason is exposure. A typical self-taught learner trains small models on a laptop, where performance is rarely the problem. They have never needed a gradient scaler, never profiled a training step and never launched more than one process. The exam still expects them to know what these tools do, when to use them and what can go wrong.

The fix is practical, not theoretical. Even on a single machine you can run a training loop with and without autocast and compare memory use, wrap a model in torch.compile and time a few steps, and run the profiler on a small model to read its output. Distributed training can be understood conceptually from the official tutorials, and many of its ideas can be tried with multiple processes on one CPU.

The second most common weak spot is device handling within Fundamentals. Errors from tensors on different devices, or from forgetting that a model's parameters moved but the input batch did not, are exactly the kind of detail that scenario questions test.

What real-world PyTorch tasks does the PTCA exam reflect?

The PTCA domains map closely to the first tasks a new PyTorch user is given at work. Thinking of the exam this way makes the syllabus easier to remember and shows why each domain matters.

A typical first assignment is to fine-tune or train a small image or text classifier. It touches every domain: wrapping a folder of labelled files in a dataset with the right transforms, feeding it through a DataLoader, building or adapting a model from standard layers, writing the training and validation loop, and saving the best weights. When the run is too slow, the next task is to profile it, enable mixed precision and perhaps move it to several GPUs.

A second common task is turning a research notebook into something repeatable. That means separating data preparation, model definition and training into clear pieces, making device selection automatic, switching between training and evaluation modes correctly and making sure results can be reproduced. These are the habits the exam checks when it asks what happens if eval mode is forgotten or gradients are not zeroed.

A third task is serving a trained model for inference. Here the questions are about loading a state_dict, running the model in eval mode without gradient tracking and keeping input preprocessing identical to training. Mistakes in any of these produce results that look plausible but are wrong, which is why the exam treats them as core knowledge.

A worked example: one training run, every domain

Walking through a single small project in order shows how the four domains connect, and it mirrors the reasoning that many exam questions expect. Take a classifier for 28 by 28 pixel greyscale images of handwritten digits, ten classes in total.

1. Data Handling: load the images through a dataset, convert each one to a tensor and normalise it with a transform, and split the data into training and validation sets. Wrap the training set in a DataLoader with shuffling on and the validation set in one with shuffling off.
2. Fundamentals: choose the device once at the start, using a GPU if one is available and the CPU otherwise, and move both the model and every batch to that device.
3. Model Development: define a small nn.Module that flattens each image to 784 values, passes them through two linear layers with a ReLU between them, and outputs ten raw scores. Pair it with cross-entropy loss and the Adam optimizer.
4. Fundamentals again: for each epoch, set training mode, loop over batches, zero the gradients, run the forward pass, compute the loss, call backward and step the optimizer. Then set eval mode and measure validation accuracy inside a no-gradient block.
5. Performance and Optimization: if an epoch is slow, profile one step to see whether data loading or computation dominates. Add DataLoader workers if loading is the bottleneck, or enable mixed precision and torch.compile if computation is.
6. Finish: save the state_dict of the best model by validation accuracy, and reload it into a fresh instance of the same class for inference.

Each numbered step is a likely question topic. A candidate who can explain why every step is there, and what breaks if it is skipped or done in the wrong order, is well placed for the exam.

Does the Linux Foundation offer an official PTCA practice test or question bank?

The Linux Foundation offers its own PTCA Certification Pathway, a set of learning modules aligned with the exam domains, sold with the exam in the USD 299 bundle. Check the Linux Foundation's PTCA page for the current contents of that pathway and any other preparation material it provides, since only the foundation's own material can be described as official.

Our PTCA practice test is an independent product and is not Linux Foundation material. It contains timed, multiple-choice questions written against the four published domains, with an explanation for every answer. Its job is different from a course: the course teaches PyTorch, and a practice test shows whether you can answer accurately and quickly enough to clear 75% within 120 minutes.

Be cautious with anything sold as real exam questions. Using them breaches the foundation's certification agreement and puts your credential at risk, and memorised answers fail as soon as a question is reworded.

How should you prepare for PTCA in six weeks?

The plan below assumes you can already write basic Python and have met machine learning ideas such as training and test data, and that you can study six to eight hours a week. It follows the domain weights, so the largest domains get the most time.

• Week 1: tensors. Creation, shape, data type, indexing, broadcasting, views and in-place operations, and moving tensors between devices.
• Week 2: autograd and the training loop. requires_grad, backward, gradient accumulation and zeroing, train and eval modes, no_grad, saving and loading a state_dict.
• Week 3: model development. nn.Module, common layers, activations, losses and optimizers, and tracing output shapes through a model by hand.
• Week 4: data handling. A custom dataset, DataLoader options, transforms and augmentation, and correct training, validation and test splits.
• Week 5: performance and optimisation. Mixed precision with autocast and a gradient scaler, torch.compile, the profiler, and the concepts of DistributedDataParallel and torchrun.
• Week 6: two or three full timed practice tests, with every wrong answer traced back to the domain and re-studied.

Write and run code every week. A small project that trains a classifier end to end, then gets profiled and sped up, covers most of the syllabus in one place. Before exam day, read the Linux Foundation certification candidate handbook, which sets out the rules for the online proctored session, from identification to the testing environment.

Common mistakes PTCA candidates make

• Spending most of the time on model architecture, which is only 20% of the exam, and too little on Fundamentals at 38%.
• Skipping Performance and Optimization because personal projects never needed it, and losing much of that 26%.
• Confusing train and eval modes, or forgetting to zero gradients, in questions that describe a training loop.
• Passing probabilities instead of raw scores to cross-entropy loss.
• Applying random augmentation to validation or test data.
• Reading only and never running code, so behaviour questions about shapes and devices become guesses.

When your practice scores are consistently above the 75% pass mark with time to spare, book the exam within your 12-month eligibility window. Keep the included retake as a safety net rather than a plan.

FAQs

How many questions are on the PTCA exam and how long do I get?

The PTCA exam has 60 multiple-choice questions and a 120-minute limit, so you average two minutes per question. Several items describe PyTorch behaviour and ask for the result, which takes longer than recall. Practise under a timer so you finish with minutes left to recheck flagged answers.

What score do I need to pass PTCA?

The passing score is 75%, which means about 45 of the 60 questions must be correct. That is a high bar for an associate exam, so treat every domain seriously. Aim for practice scores comfortably above 75% before booking, rather than scores that only just clear it.

How much does the PyTorch Certified Associate exam cost?

The exam-only price is USD 250 as of October 2026. The Linux Foundation also sells a USD 299 bundle with its PTCA Certification Pathway modules and a USD 495 bundle with a THRIVE-ONE annual subscription. Prices can change, so confirm them on the foundation's checkout page.

Does the PTCA exam include a free retake?

Yes. According to the Linux Foundation's exam page, the purchase includes one retake, and you have 12 months from purchase to use your attempts. Plan to pass on the first sitting and keep the retake in reserve in case illness, connection trouble or a weak domain gets in the way.

How long is the PTCA certification valid?

The Linux Foundation lists the PyTorch Certified Associate as valid for two years from the date you pass. After that you would need to certify again to keep it current. Note the expiry date when you add the digital badge to LinkedIn or other profiles, so it does not lapse unnoticed.

Is the VMExam PTCA practice test made by the Linux Foundation?

No. Our PTCA practice test is independent and is not Linux Foundation material. It uses timed questions mapped to the four published domains, with explanations for each answer. The foundation's own preparation option is its PTCA Certification Pathway, available as a bundle with the exam.

Select ratingPoorOkayGoodGreatAwesome

Rating: 5 / 5 (1 vote)