PyTorch and AI Application Development

What it is

PyTorch is an open source deep learning framework in Python, created by Meta and now hosted by the PyTorch Foundation. It uses dynamic computational graphs and is the framework used throughout the HCIA-AI V4.0 course.

The AI application development process is the sequence of steps that turns a business need into a working model: define the problem, prepare data, build and train a model, evaluate it, deploy it and keep improving it.

How it works

Main PyTorch modules

Every model is a class that inherits from nn.Module. Layers are created in __init__, and the computation is written in forward(). You normally do not call forward() directly; you call the model, model(x), which also runs any registered hooks.

A complete training loop

This network classifies 28 x 28 handwritten digits (flattened to 784 values) into 10 classes.

import torch
from torch import nn
from torch.utils.data import DataLoader

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        return self.fc2(torch.relu(self.fc1(x)))

model = Net()
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
loader = DataLoader(train_set, batch_size=64, shuffle=True)

model.train()
for images, labels in loader:
    optimizer.zero_grad()                        # clear old gradients
    loss = loss_fn(model(images.view(-1, 784)), labels)
    loss.backward()                              # compute gradients
    optimizer.step()                             # update weights

train_set is any Dataset; the DataLoader splits it into shuffled batches of 64. One full pass over the data is an epoch, and real training repeats this loop for several epochs.

Why the order matters

PyTorch accumulates gradients: each backward() adds to the existing .grad values. If you skip optimizer.zero_grad(), the gradients of earlier batches pile up and the updates are wrong.

backward() must come before step(), because the optimizer needs gradients to update the weights.

Evaluation, devices and saving

model.eval()
with torch.no_grad():
    preds = model(test_images.view(-1, 784)).argmax(dim=1)

On Huawei Ascend NPUs, PyTorch runs through the torch_npu adapter (Ascend Extension for PyTorch), so the same training code can target Ascend hardware.

The AI application development process

The process is a loop, not a straight line. Poor evaluation results send you back to the data or the model.

A worked example

Count the trainable parameters of Net above. An nn.Linear(in, out) layer has in x out weights plus out biases.

• fc1: 784 x 128 + 128 = 100,352 + 128 = 100,480
• fc2: 128 x 10 + 10 = 1,280 + 10 = 1,290
• Total: 100,480 + 1,290 = 101,770

PyTorch confirms it with sum(p.numel() for p in model.parameters()).

How the exam asks about this

• "Which base class must a custom PyTorch model inherit from?" → torch.nn.Module.
• "Which call clears the gradients left by the previous batch?" → optimizer.zero_grad().
• "Which dataset is used for the final, unbiased estimate of model performance?" → The test set.