PyTorch

import torch

# From Python list
t = torch.tensor([[1, 2], [3, 4]], dtype=torch.float32)

# Filled tensors
zeros = torch.zeros(3, 4)       # all zeros
ones  = torch.ones(3, 4)        # all ones
rand  = torch.rand(3, 4)        # uniform [0, 1)
randn = torch.randn(3, 4)       # standard normal

# Like another tensor (same shape/dtype)
like = torch.zeros_like(t)

# From NumPy (shares memory on CPU)
import numpy as np
arr = np.array([1.0, 2.0])
t2  = torch.from_numpy(arr)

a = torch.tensor([[1., 2.], [3., 4.]])
b = torch.tensor([[5., 6.], [7., 8.]])

# Element-wise
a + b;  a * b;  a ** 2

# Matrix multiply
c = a @ b           # or torch.matmul(a, b)

# Reshape / view
flat = a.view(-1)       # [1, 2, 3, 4]  — shares storage
reshaped = a.reshape(1, 4)  # safe even on non-contiguous

# Indexing & slicing (same as NumPy)
a[0]        # first row
a[:, 1]     # second column
a[a > 2]    # boolean mask

# Reduce
a.sum();  a.mean();  a.max()

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

t = torch.randn(3, 3).to(device)

# Or pass device at creation
t2 = torch.ones(3, 3, device=device)

# Move back to CPU for NumPy conversion
arr = t.cpu().numpy()

x = torch.tensor(3.0, requires_grad=True)
y = x ** 2 + 2 * x + 1   # y = (x+1)^2

y.backward()              # compute dy/dx
print(x.grad)             # tensor(8.) — dy/dx at x=3 is 2x+2=8

# Accumulates! Zero before each step
x.grad.zero_()

# Stop tracking (inference / data preprocessing)
with torch.no_grad():
    val = x ** 2           # no graph built

import torch.nn as nn

class MLP(nn.Module):
    def __init__(self, in_features, hidden, out_features):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_features, hidden),
            nn.ReLU(),
            nn.Linear(hidden, out_features),
        )

    def forward(self, x):
        return self.net(x)

model = MLP(784, 256, 10)
print(model)                  # shows layer tree
print(sum(p.numel() for p in model.parameters()))  # param count

nn.Linear(in, out)              # fully-connected
nn.Conv2d(in_ch, out_ch, kernel) # 2D convolution
nn.MaxPool2d(kernel_size)        # spatial downsampling
nn.BatchNorm2d(num_features)     # batch normalization
nn.Dropout(p=0.5)               # regularization
nn.Embedding(vocab, dim)         # lookup table for NLP
nn.LSTM(input, hidden, layers)   # recurrent
nn.MultiheadAttention(embed, heads)  # transformer block

import torch.optim as optim

model = MLP(784, 256, 10).to(device)
optimizer = optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()

for epoch in range(num_epochs):
    model.train()                    # enables dropout/batchnorm
    for X, y in train_loader:
        X, y = X.to(device), y.to(device)

        optimizer.zero_grad()        # clear accumulated grads
        logits = model(X)            # forward
        loss = criterion(logits, y)  # compute loss
        loss.backward()              # compute gradients
        optimizer.step()             # update weights

    print(f'Epoch {epoch}: loss={loss.item():.4f}')

model.eval()
correct = total = 0

with torch.no_grad():
    for X, y in val_loader:
        X, y = X.to(device), y.to(device)
        logits = model(X)
        preds = logits.argmax(dim=1)
        correct += (preds == y).sum().item()
        total   += y.size(0)

acc = correct / total
print(f'Val accuracy: {acc:.4f}')

from torch.utils.data import Dataset, DataLoader

class MyDataset(Dataset):
    def __init__(self, X, y):
        self.X = torch.tensor(X, dtype=torch.float32)
        self.y = torch.tensor(y, dtype=torch.long)

    def __len__(self):
        return len(self.X)

    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]

train_loader = DataLoader(
    MyDataset(X_train, y_train),
    batch_size=64,
    shuffle=True,
    num_workers=4,     # parallel loading
    pin_memory=True,   # faster CPU→GPU transfer
)

# Save
torch.save({
    'epoch': epoch,
    'model_state': model.state_dict(),
    'optimizer_state': optimizer.state_dict(),
    'loss': loss,
}, 'checkpoint.pt')

# Load
checkpoint = torch.load('checkpoint.pt', map_location=device)
model.load_state_dict(checkpoint['model_state'])
optimizer.load_state_dict(checkpoint['optimizer_state'])
start_epoch = checkpoint['epoch']

# TorchScript — serialize the model
scripted = torch.jit.script(model)
scripted.save('model_scripted.pt')
loaded = torch.jit.load('model_scripted.pt')

# ONNX — interoperable with TensorRT, ONNX Runtime, CoreML
dummy = torch.randn(1, 784, device=device)
torch.onnx.export(
    model, dummy, 'model.onnx',
    input_names=['input'],
    output_names=['output'],
    dynamic_axes={'input': {0: 'batch'}},  # variable batch size
    opset_version=17,
)