ML stack reference

model = MyNet().cuda()
optimizer = torch.optim.Adam(
    model.parameters(), lr=1e-3
)

for epoch in range(n_epochs):
    # Forward
    pred = model(x)
    loss = F.mse_loss(pred, target)

    # Backward
    optimizer.zero_grad()   # clear old grads
    loss.backward()         # compute grads
    optimizer.step()        # update params

    if epoch % 10 == 0:
        print(f"{epoch}: {loss.item():.4f}")

scaler = torch.cuda.amp.GradScaler()
for x, y in loader:
    optimizer.zero_grad(set_to_none=True)
    with torch.cuda.amp.autocast():
        loss = model(x, y)
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

#include <torch/torch.h>

# CMakeLists.txt (typical)
find_package(Torch REQUIRED)
target_link_libraries(myapp PRIVATE "${TORCH_LIBRARIES}")
set_property(TARGET myapp PROPERTY CXX_STANDARD 17)

struct Net : torch::nn::Module {
  Net()
    : fc1(register_module("fc1", torch::nn::Linear(3, 64))),
      fc2(register_module("fc2", torch::nn::Linear(64, 1))) {}

  torch::Tensor forward(torch::Tensor x) {
    x = torch::relu(fc1->forward(x));
    return fc2->forward(x);
  }

  torch::nn::Linear fc1{nullptr}, fc2{nullptr};
};

auto net = std::make_shared<Net>();
net->to(torch::kCUDA);

auto net = std::make_shared<Net>();
net->to(torch::kCUDA);
torch::optim::Adam optimizer(
    net->parameters(), torch::optim::AdamOptions(1e-3));

for (int64_t epoch = 0; epoch < 100; ++epoch) {
  optimizer.zero_grad();
  auto pred = net->forward(batch_x);
  auto loss = torch::mse_loss(pred, batch_y);
  loss.backward();
  optimizer.step();
}

class MyNet(nn.Module):
    def __init__(self, in_dim, out_dim):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(in_dim, 128),
            nn.ReLU(),
            nn.Linear(128, out_dim),
        )

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

model = MyNet(3, 1).cuda()
print(sum(p.numel() for p in model.parameters()),
      "parameters")

from torch.utils.data import Dataset, DataLoader

class MyDataset(Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels

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

    def __getitem__(self, idx):
        return self.data[idx], self.labels[idx]

dataset = MyDataset(X, y)
loader = DataLoader(
    dataset,
    batch_size=32,
    shuffle=True,
    num_workers=4,
)

for batch_x, batch_y in loader:
    loss = train_step(batch_x, batch_y)

model.eval()           # disable dropout/BN

with torch.no_grad():  # disable gradients
    x = preprocess(input).cuda()
    pred = model(x)
    result = postprocess(pred.cpu())

model.train()          # back to training mode

# Always check these when something breaks
print(x.shape)         # shape
print(x.dtype)         # float32 / int64 etc.
print(x.device)        # cpu / cuda:0
print(x.min(), x.max()) # value range
print(x.isnan().any()) # NaN check
print(x.isinf().any()) # Inf check

# Visualize a batch
import matplotlib.pyplot as plt
img = renders[0].cpu().numpy()
plt.imshow(img); plt.savefig("debug.png")

from dataclasses import dataclass, field

@dataclass
class Config:
    lr: float = 1e-3
    batch_size: int = 32
    device: str = "cuda"
    tags: list = field(default_factory=list)

cfg = Config(lr=1e-4)
print(cfg.lr, cfg.device)

from pathlib import Path

root = Path("/workspace/datasets")
ply = root / "garden" / "point_cloud.ply"

print(ply.exists())     # True/False
print(ply.suffix)       # .ply
print(ply.stem)         # point_cloud
print(ply.parent)       # /workspace/datasets/garden

# Glob
plys = list(root.glob("**/*.ply"))
for p in plys:
    print(p)

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--ply",    required=True)
parser.add_argument("--output", default="out.png")
parser.add_argument("--width",  type=int, default=1280)
parser.add_argument("--fov",    type=float, default=60.0)
parser.add_argument("--verbose",action="store_true")
args = parser.parse_args()

print(args.ply, args.width)

# Basic
squares = [x**2 for x in range(10)]

# With filter
big = [x for x in values if x > threshold]

# Nested
flat = [item for row in matrix for item in row]

# Dict comprehension
d = {k: v for k, v in zip(keys, values)}

# Generator (memory efficient, no [])
gen = (x**2 for x in range(1_000_000))

# File I/O
with open("log.txt", "w") as f:
    f.write("done\n")

# PyTorch no_grad (most common in ML)
with torch.no_grad():
    pred = model(x)

# Timing
import time
t = time.time()
result = expensive_op()
print(f"{(time.time()-t)*1000:.1f}ms")

n = 5_834_784
t = 0.133

# Basic
print(f"Gaussians: {n:,}")       # 5,834,784
print(f"Time: {t*1000:.1f}ms")   # 133.0ms
print(f"FPS: {1/t:.1f}")         # 7.5

# Width padding
print("%-10s %8s" % ("loss", "value"))
for k,v in stats.items():
    print("%-10s %8.4f" % (k, v))

from plyfile import PlyData
import numpy as np, torch

ply = PlyData.read("point_cloud.ply")
v = ply['vertex']

means    = torch.tensor(
    np.stack([v['x'], v['y'], v['z']], axis=1),
    dtype=torch.float32, device='cuda')

# Scales stored as log → exp()
scales   = torch.tensor(
    np.exp(np.stack([
        v['scale_0'], v['scale_1'], v['scale_2']
    ], axis=1)), dtype=torch.float32, device='cuda')

# Opacity stored as logit → sigmoid()
opacities = torch.sigmoid(torch.tensor(
    np.array(v['opacity']),
    dtype=torch.float32, device='cuda'))

# SH DC → RGB: 0.5 + 0.28209 * f_dc
colors = (0.5 + 0.28209 * torch.tensor(
    np.stack([v['f_dc_0'], v['f_dc_1'], v['f_dc_2']], axis=1),
    dtype=torch.float32, device='cuda')).clamp(0, 1)

from gsplat import rasterization

renders, alphas, info = rasterization(
    means=means,      # [N, 3]
    quats=quats,      # [N, 4] wxyz normalized
    scales=scales,    # [N, 3] after exp()
    opacities=opacities, # [N] after sigmoid()
    colors=colors,    # [N, 3] RGB [0,1]
    viewmats=viewmat, # [C, 4, 4] world→cam
    Ks=K,             # [C, 3, 3] intrinsics
    width=W,
    height=H,
)
# renders: [C, H, W, 3]
# alphas:  [C, H, W, 1]

import math

def make_K(W, H, fov_deg=60.0, device='cuda'):
    fov = math.radians(fov_deg)
    fx = (W / 2) / math.tan(fov / 2)
    K = torch.tensor([[
        [fx,  0, W/2],
        [ 0, fx, H/2],
        [ 0,  0,   1],
    ]], dtype=torch.float32, device=device)
    return K  # [1, 3, 3]

# gsplat returns raw render + alpha
# Composite manually over background:
# out = render * alpha + bg * (1 - alpha)

bg = torch.ones(3, device='cuda')  # white
alpha = alphas[0]                   # [H, W, 1]
composited = (renders[0] * alpha
    + bg.view(1,1,3) * (1 - alpha)) # [H, W, 3]

# Save to PNG
img = (composited.clamp(0,1).cpu().numpy()
       * 255).astype(np.uint8)
imageio.imwrite("out.png", img)

# Find scene center (median is robust to outliers)
center = means.median(dim=0).values

# Scene spread
spread = (means - center).norm(dim=-1).mean()

# High opacity core
core = means[opacities > 0.5]
core_center = core.mean(dim=0)

# Orbit radius
radius = spread * 2.0

print(f"Gaussians: {len(means):,}")
print(f"Center:    {center.cpu().numpy().round(2)}")
print(f"Spread:    {spread:.2f}")
print(f"Radius:    {radius:.2f}")