LightGP
  • Installation
    • From PyPI
    • From source
    • Verify
    • Requirements
    • Build flags
  • Quick Start
    • Plotting the result
    • What’s happening under the hood
  • Tutorials
    • Basic GP Regression
      • Generate noisy data
      • Fit a GP
      • Optimize the hyperparameters
      • Plot before vs after
      • Different kernel smoothnesses
      • When to use exact GP
    • Kernel Composition
      • Generate synthetic data
      • Baseline: a single RBF
      • Composed kernel
      • Compare side-by-side
      • What to compose, when?
    • Sparse GP — Inducing Points
      • A larger dataset
      • Sweep the number of inducing points M
      • Picking M
      • Timing scaling — fit time at fixed M=100
      • When to use sparse vs CG vs SKI
    • Large-Scale GP with SKI
      • Fit 50,000 points
      • Predict and plot a slice
      • How SKI works (one-paragraph intuition)
      • Decision flowchart
    • Choosing a Backend
      • Available backends
      • Forcing a specific backend
      • Quick wall-time comparison
      • How Backend.Auto chooses
      • Cross-platform code
    • Using LightGP from C++
      • Building the C++ library
      • Basic regression
      • Kernel composition
      • Backend selection
      • iOS embedding (sketch)
      • CMake integration
  • API Reference
    • Kernels
      • Base class
      • Concrete kernels
      • Composition
      • Example
    • Mean functions
      • lightgp.Mean
      • lightgp.ZeroMean
      • lightgp.ConstantMean
      • lightgp.LinearMean
    • Models
      • GPExact
      • GPSparse
    • Backends
      • lightgp.Backend
      • Auto dispatch rules
    • Solvers
      • lightgp.Solver
      • Picking a solver
  • Benchmarks
    • Methodology
    • Inference scaling
    • End-to-end vs GPyTorch
    • Component micro-benchmarks
    • Reproducing the numbers
  • Theory
    • GP Regression Basics
      • Regression posterior
      • Log marginal likelihood
      • Why O(N³)?
    • Sparse GP (Titsias VFE)
      • Kernel approximation
      • VFE bound
      • Cost
      • When to use a sparse GP
    • SKI (KISS-GP)
      • The approximation
      • Fast matrix-vector products
      • Inference
      • Where the FFT happens
      • When SKI works (and when it doesn’t)
    • Matrix-Free Conjugate Gradients
      • The CG algorithm
      • The matrix-free \(K_y v\) shader
      • Hutchinson variance estimation
      • Log-marginal-likelihood via SLQ
      • When CG (and matrix-free) wins
  • Development
    • Contributing
      • Repo at a glance
      • Dev loop
      • Style
      • Reporting an issue
    • Architecture
      • Tensor
      • Kernel hierarchy
      • Dispatch
      • Solvers
      • Inference
      • Python bindings
    • Adding a Kernel
      • 1. Pick the math
      • 2. Implement the C++ kernel
      • 3. Wire it into the build
      • 4. Test against the reference
      • 5. Add the GPU kernel (optional)
      • 6. Bind to Python
      • 7. Add a Python test
      • 8. Document it
LightGP
  • Search

© Copyright 2026, YuHsueh Fang.

Built with Sphinx using a theme provided by Read the Docs.