PaddlePaddle Cheat Sheet

1Install & devicepip / GPU

pip install paddlepaddle # CPU pip install paddlepaddle-gpu # CUDA build★
Pick the wheel matching your CUDA from paddlepaddle.org.cn. Python 3.9+. Import is always import paddle.
import paddle paddle.utils.run_check()★
Verifies the install and GPU availability in one call.
paddle.device.set_device("gpu") # or "cpu", "gpu:0"★
Global device selection. paddle.device.cuda.device_count() to count GPUs. Dygraph (eager) mode is on by default.
paddle.seed(42)
Seed all RNGs for reproducibility.

2Tensorslike NumPy

x = paddle.to_tensor([[1.,2.],[3.,4.]])★
Build from lists/NumPy. dtype=, place= to set type/device. paddle.zeros, ones, randn, arange, linspace.
x.shape · x.dtype · x.numpy() · x.astype("float32")
Interop with NumPy via .numpy(). x.reshape([-1]), x.transpose, x.unsqueeze, x.cast.
z = paddle.matmul(a, b) · paddle.mean(x, axis=0) · x + y★
Full NumPy-style op set: paddle.add/sum/max/concat/stack/where, broadcasting, and operator overloads.
x.stop_gradient = False y = (x**2).sum(); y.backward(); x.grad★
Autograd: set stop_gradient=False (like requires_grad), call .backward(), read .grad.

3nn.Layer modelssubclass it

import paddle.nn as nn class Net(nn.Layer): def __init__(self): super().__init__() self.fc = nn.Linear(784, 10) def forward(self, x): return self.fc(x)★
The base class is nn.Layer (Paddle's nn.Module). Define sublayers in __init__, the computation in forward.
model = Net() out = model(x) # calls forward()★
Instances are callable. model.parameters(), model.sublayers(), model.state_dict().
net = nn.Sequential( nn.Linear(784,128), nn.ReLU(), nn.Linear(128,10))★
nn.Sequential for simple stacks; nn.LayerList / nn.LayerDict to hold sublayers dynamically.
paddle.summary(model, (1, 784))
Print a Keras-style layer/parameter summary.

4Layers & functionalbuilding blocks

nn.Linear · nn.Conv2D · nn.MaxPool2D · nn.BatchNorm2D · nn.Dropout★
Note the capital D: Conv2D, BatchNorm2D, MaxPool2D (a common porting gotcha vs PyTorch's Conv2d).
nn.Embedding · nn.LSTM · nn.GRU · nn.MultiHeadAttention · nn.TransformerEncoder
Sequence & attention layers for NLP/transformers are all under paddle.nn.
import paddle.nn.functional as F F.relu(x) · F.softmax(x) · F.cross_entropy(logits, y)★
The functional (stateless) API mirrors PyTorch's torch.nn.functional.
nn.initializer.KaimingNormal() # weight_attr=ParamAttr(initializer=...)
Initializers live in nn.initializer; attach via a layer's weight_attr/bias_attr (paddle.ParamAttr).

5Losses & optimizersthe pieces

loss_fn = nn.CrossEntropyLoss() # or nn.MSELoss(), nn.BCEWithLogitsLoss()★
CrossEntropyLoss takes raw logits + integer labels (softmax is applied internally).
opt = paddle.optimizer.Adam( parameters=model.parameters(), learning_rate=1e-3)★
⚠️ It's parameters= (not params=) and learning_rate= (not lr=). Also SGD, Momentum, AdamW, RMSProp.
sched = paddle.optimizer.lr.CosineAnnealingDecay(1e-3, T_max=50) opt = paddle.optimizer.Adam(learning_rate=sched, parameters=...)
LR schedulers live in paddle.optimizer.lr; pass the scheduler as learning_rate and call sched.step() each epoch.
opt = paddle.optimizer.AdamW(..., weight_decay=0.01, grad_clip=clip)
Weight decay & gradient clipping (paddle.nn.ClipGradByGlobalNorm) are optimizer args.

6The training loopeager mode

model.train() for x, y in loader: logits = model(x) loss = loss_fn(logits, y) loss.backward() opt.step() opt.clear_grad()★
The canonical loop. ⚠️ It's opt.clear_grad() (Paddle's zero_grad). Order: forward → loss → backward → step → clear.
# forgot opt.clear_grad()? gradients accumulate across stepsgotcha
Gradients add up until cleared — clear them every iteration (or intentionally accumulate for large effective batches).
loss.item() · paddle.metric.accuracy(logits, y)
Pull a Python scalar with .item(); built-in metrics under paddle.metric.

7Save, load & evalcheckpoints

paddle.save(model.state_dict(), "model.pdparams") paddle.save(opt.state_dict(), "opt.pdopt")★
Save weights (.pdparams) and optimizer state (.pdopt) separately.
state = paddle.load("model.pdparams") model.set_state_dict(state)★
Reload with set_state_dict (Paddle's load_state_dict).
model.eval() with paddle.no_grad(): preds = model(x_test)★
eval() switches Dropout/BatchNorm to inference; no_grad() skips autograd for speed.

8Datasets & DataLoaderfeeding data

from paddle.io import Dataset, DataLoader class DS(Dataset): def __getitem__(self, i): return self.x[i], self.y[i] def __len__(self): return len(self.x)★
Subclass paddle.io.Dataset with __getitem__/__len__ — identical to PyTorch.
loader = DataLoader(ds, batch_size=64, shuffle=True, num_workers=4)★
Batches, shuffles, and parallel-loads. Iterate directly in the train loop.
import paddle.vision.transforms as T tf = T.Compose([T.Resize(224), T.ToTensor(), T.Normalize(...)])
paddle.vision provides transforms, built-in datasets (paddle.vision.datasets.MNIST), and pretrained models (paddle.vision.models.resnet50).

9paddle.Model (Keras-style)skip the loop

model = paddle.Model(Net())★
Wrap an nn.Layer in paddle.Model for a high-level Keras-like trainer.
model.prepare( paddle.optimizer.Adam(parameters=model.parameters()), nn.CrossEntropyLoss(), paddle.metric.Accuracy())★
prepare = compile: optimizer + loss + metrics.
model.fit(train_ds, eval_ds, epochs=10, batch_size=64)★
One call trains with logging & validation. Then model.evaluate(test_ds), model.predict(...).
model.save("mnist") # mnist.pdparams + mnist.pdopt
paddle.Model.save/load handle the whole trainer state. Callbacks via paddle.callbacks (VisualDL, EarlyStopping).

10Dynamic → static & AMPspeed

@paddle.jit.to_static def forward(self, x): ...★
Decorate (or wrap the model) to trace eager code into a static graph — the "unified dynamic/static" design. Accelerated by the CINN compiler in 3.x.
with paddle.amp.auto_cast(level="O1"): loss = loss_fn(model(x), y) scaler.scale(loss).backward(); scaler.step(opt)★
Mixed precision: paddle.amp.auto_cast + paddle.amp.GradScaler for faster fp16/bf16 training on GPU.
paddle.distributed # launch: python -m paddle.distributed.launch train.py
Data/model parallel training; 3.x adds auto-parallel so one script scales across many chips.

11Inference & deployship it

paddle.jit.save(model, "infer/model", input_spec=[ paddle.static.InputSpec([None,784], "float32")])★
Export a deployable static model (.pdmodel + .pdiparams) with a declared input shape.
# serve with Paddle Inference (C++/Python) or Paddle Serving
The exported model runs under Paddle Inference for high-performance serving; Paddle Lite for mobile/edge; Paddle.js for the browser.
# ONNX: paddle2onnx --model_dir infer --save_file model.onnx
paddle2onnx exports to ONNX for cross-framework runtimes.

12Ecosystemthe model suites

# PaddleOCR — the flagship OCR / doc-parsing toolkit★
PaddleOCR is the most widely used part of the ecosystem — SOTA OCR, layout, and doc-VL models.
# PaddleNLP · PaddleDetection · PaddleSeg · PaddleClas · PaddleSpeech
Task-specific model suites (NLP incl. ERNIE/Wenxin LLMs, detection, segmentation, classification, speech).
# VisualDL — training visualization (TensorBoard equivalent)
VisualDL for logging/curves; PaddleHub for pretrained-model reuse.
# API is close to PyTorch — porting is mostly mechanical
Main renames: Module→Layer, Conv2d→Conv2D, zero_grad→clear_grad, params→parameters, lr→learning_rate, requires_grad→not stop_gradient.

PaddlePaddle cheat sheet