Particle Filters

Introduction

Imagine trying to track a submarine through murky water. You can hear pings — noisy echoes that tell you roughly how far away something is — but the ocean scrambles the signal. You cannot see the submarine. You don't know where it went between pings. Yet Navy sonar operators pin down its position with startling accuracy.

The algorithm behind that trick — and behind the self-locating phone in your pocket, the drones that fly through GPS-denied buildings, and the Mars rovers that navigate on their own — is called the particle filter (also known as Sequential Monte Carlo, or SMC).

The idea is disarmingly simple: instead of tracking a single best guess of where the target is, you maintain thousands of guesses at once — called particles — each representing one plausible position and velocity. Every time a new noisy sensor reading arrives, you ask each particle: "How well does this reading fit if I were here?" Particles that fit well get more copies in the next round; particles that fit poorly get dropped. The cloud of survivors is your running estimate of reality.

This predict-weight-resample loop, invented by Neil Gordon, David Salmond, and Adrian Smith in 1993, transformed state estimation. Kalman filters — the reigning approach since the Apollo missions — could only handle Gaussian noise and linear dynamics. Particle filters handle any distribution, any nonlinear motion model, any weird sensor. The cost is computation: you need enough particles to fill the plausible space, and that number can explode in high dimensions.

Watch It Track

The canvas below shows a target dot moving on a random walk (blue). The particle cloud (small orange dots) starts scattered randomly across the canvas. Every frame the filter runs one full cycle: predict new positions, weight by closeness to the target's noisy sensor reading (the dashed circle), then resample — duplicating good particles and dropping bad ones.

<div class="controls">
  <label>Particles: <span id="nLabel">300</span>
    <input type="range" id="nSlider" min="50" max="800" value="300" step="50">
  </label>
  <label>Noise: <span id="noiseLabel">30</span>
    <input type="range" id="noiseSlider" min="5" max="80" value="30" step="5">
  </label>
  <div class="btns">
    <button id="pauseBtn" type="button">Pause</button>
    <button id="resetBtn" type="button" class="ghost">Reset</button>
  </div>
</div>
<canvas id="canvas" width="480" height="300"></canvas>
<div id="info" class="info">Running… watch the cloud converge on the blue dot.</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; background: #fff; }
.controls { display: flex; flex-wrap: wrap; gap: .6rem 1.2rem; align-items: center; margin-bottom: .5rem; font-size: .85rem; }
label { display: flex; align-items: center; gap: .4rem; }
input[type=range] { width: 90px; accent-color: #e07b39; }
.btns { display: flex; gap: .5rem; margin-left: auto; }
button { font: 600 13px system-ui; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
canvas { display: block; border: 1px solid #dde3e8; border-radius: 8px; max-width: 100%; }
.info { font-size: .82rem; color: #555; margin-top: .4rem; min-height: 1.3em; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Particle Filter demo — tracks a random-walking target with noisy range observations.
// Algorithm: predict → weight → resample (SIR / Bootstrap filter).
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');
const W = canvas.width, H = canvas.height;

// ── Parameters (read from sliders) ─────────────────────────────────────
let N = 300;         // number of particles
let SENSOR_NOISE = 30; // std-dev of range sensor (pixels)
const PROCESS_NOISE = 4; // std-dev of random-walk step (pixels)
const TARGET_SPEED = 2;  // pixels per frame for target movement

// ── State ──────────────────────────────────────────────────────────────
let target = { x: W/2, y: H/2, vx: TARGET_SPEED, vy: TARGET_SPEED };
let particles = [];  // [{x, y, w}]
let paused = false;
let animId = null;
let frame = 0;

// ── Gaussian random (Box-Muller) ────────────────────────────────────────
function randn() {
  let u, v;
  do { u = Math.random(); } while (u === 0);
  do { v = Math.random(); } while (v === 0);
  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
}

// ── Initialise particles uniformly across canvas ────────────────────────
function initParticles() {
  particles = [];
  for (let i = 0; i < N; i++) {
    particles.push({ x: Math.random() * W, y: Math.random() * H, w: 1 / N });
  }
}

// ── Move target (bounce off walls) ─────────────────────────────────────
function stepTarget() {
  // Small random turn
  target.vx += randn() * 0.5;
  target.vy += randn() * 0.5;
  // Clamp speed
  const spd = Math.hypot(target.vx, target.vy);
  if (spd > TARGET_SPEED * 1.5) { target.vx *= TARGET_SPEED / spd; target.vy *= TARGET_SPEED / spd; }
  target.x += target.vx;
  target.y += target.vy;
  // Bounce
  if (target.x < 8)  { target.x = 8;  target.vx *= -1; }
  if (target.x > W-8){ target.x = W-8; target.vx *= -1; }
  if (target.y < 8)  { target.y = 8;  target.vy *= -1; }
  if (target.y > H-8){ target.y = H-8; target.vy *= -1; }
}

// ── Sensor: noisy range from a fixed corner beacon ──────────────────────
const BEACON = { x: 0, y: 0 }; // top-left corner
function trueRange() {
  return Math.hypot(target.x - BEACON.x, target.y - BEACON.y);
}
function noisyObs() {
  return trueRange() + randn() * SENSOR_NOISE;
}
function likelihood(px, py, obs) {
  const d = Math.hypot(px - BEACON.x, py - BEACON.y);
  const diff = d - obs;
  return Math.exp(-0.5 * diff * diff / (SENSOR_NOISE * SENSOR_NOISE));
}

// ── Predict: jitter each particle by process noise ──────────────────────
function predict() {
  for (const p of particles) {
    p.x += randn() * PROCESS_NOISE;
    p.y += randn() * PROCESS_NOISE;
    p.x = Math.max(0, Math.min(W, p.x));
    p.y = Math.max(0, Math.min(H, p.y));
  }
}

// ── Weight: Gaussian likelihood of the observation ──────────────────────
function weight(obs) {
  let total = 0;
  for (const p of particles) {
    p.w = likelihood(p.x, p.y, obs);
    total += p.w;
  }
  if (total === 0) { for (const p of particles) p.w = 1 / N; return; }
  for (const p of particles) p.w /= total;
}

// ── Resample: systematic resampling ────────────────────────────────────
function resample() {
  const newP = [];
  const step = 1 / N;
  let r = Math.random() * step;
  let cumW = particles[0].w;
  let j = 0;
  for (let i = 0; i < N; i++) {
    while (r > cumW && j < N - 1) { j++; cumW += particles[j].w; }
    newP.push({ x: particles[j].x, y: particles[j].y, w: 1 / N });
    r += step;
  }
  particles = newP;
}

// ── Estimate: weighted mean position ───────────────────────────────────
function estimate() {
  let ex = 0, ey = 0;
  for (const p of particles) { ex += p.x * p.w; ey += p.y * p.w; }
  return { x: ex * N, y: ey * N }; // weights already normalised to 1/N after resample
}

// ── Draw ──────────────────────────────────────────────────────────────
function draw(obs) {
  ctx.clearRect(0, 0, W, H);

  // Background grid
  ctx.strokeStyle = '#f0f3f6';
  ctx.lineWidth = 1;
  for (let x = 0; x <= W; x += 40) { ctx.beginPath(); ctx.moveTo(x, 0); ctx.lineTo(x, H); ctx.stroke(); }
  for (let y = 0; y <= H; y += 40) { ctx.beginPath(); ctx.moveTo(0, y); ctx.lineTo(W, y); ctx.stroke(); }

  // Sensor range ring (noisy observation)
  ctx.strokeStyle = 'rgba(100,120,180,0.35)';
  ctx.setLineDash([5, 5]);
  ctx.lineWidth = 1.5;
  ctx.beginPath();
  ctx.arc(BEACON.x, BEACON.y, obs, 0, 2 * Math.PI);
  ctx.stroke();
  ctx.setLineDash([]);

  // Beacon
  ctx.fillStyle = '#8899bb';
  ctx.beginPath();
  ctx.arc(BEACON.x, BEACON.y, 5, 0, 2 * Math.PI);
  ctx.fill();

  // Particles
  for (const p of particles) {
    ctx.globalAlpha = 0.55;
    ctx.fillStyle = '#e07b39';
    ctx.beginPath();
    ctx.arc(p.x, p.y, 2.5, 0, 2 * Math.PI);
    ctx.fill();
  }
  ctx.globalAlpha = 1;

  // Estimated position (weighted mean)
  const est = estimate();
  ctx.strokeStyle = '#e07b39';
  ctx.lineWidth = 2;
  ctx.beginPath();
  ctx.arc(est.x, est.y, 8, 0, 2 * Math.PI);
  ctx.stroke();

  // True target
  ctx.fillStyle = '#1d6fb8';
  ctx.beginPath();
  ctx.arc(target.x, target.y, 7, 0, 2 * Math.PI);
  ctx.fill();
  ctx.fillStyle = '#fff';
  ctx.beginPath();
  ctx.arc(target.x, target.y, 3, 0, 2 * Math.PI);
  ctx.fill();

  // Legend
  ctx.font = '11px system-ui';
  ctx.fillStyle = '#1d6fb8';
  ctx.fillText('● Target', W - 90, 16);
  ctx.fillStyle = '#e07b39';
  ctx.fillText('● Particles / estimate', W - 150, 30);
  ctx.fillStyle = '#8899bb';
  ctx.fillText('○ Sensor beacon', W - 150, 44);

  // Error
  const err = Math.hypot(est.x - target.x, est.y - target.y).toFixed(1);
  document.getElementById('info').textContent =
    fmt('Frame %frame% | Sensor noise σ=%SENSOR_NOISE%px | Estimate error: %err%px | %N% particles', { frame: frame, SENSOR_NOISE: SENSOR_NOISE, err: err, N: N });
}

// ── Main loop ──────────────────────────────────────────────────────────
function loop() {
  if (!paused) {
    stepTarget();
    const obs = noisyObs();
    predict();
    weight(obs);
    resample();
    frame++;
    draw(obs);
  }
  animId = requestAnimationFrame(loop);
}

function reset() {
  frame = 0;
  target = { x: W/2, y: H/2, vx: TARGET_SPEED, vy: 0.5 };
  N = parseInt(document.getElementById('nSlider').value);
  SENSOR_NOISE = parseInt(document.getElementById('noiseSlider').value);
  initParticles();
}

// ── Controls ───────────────────────────────────────────────────────────
document.getElementById('pauseBtn').addEventListener('click', function() {
  paused = !paused;
  this.textContent = paused ? 'Resume' : 'Pause';
});
document.getElementById('resetBtn').addEventListener('click', function() {
  reset();
  if (paused) { paused = false; document.getElementById('pauseBtn').textContent = 'Pause'; }
});
document.getElementById('nSlider').addEventListener('input', function() {
  N = parseInt(this.value);
  document.getElementById('nLabel').textContent = N;
  initParticles();
});
document.getElementById('noiseSlider').addEventListener('input', function() {
  SENSOR_NOISE = parseInt(this.value);
  document.getElementById('noiseLabel').textContent = SENSOR_NOISE;
});

// ── Start ──────────────────────────────────────────────────────────────
reset();
loop();

<div class="controls">
  <label>Particles: <span id="nLabel">300</span>
    <input type="range" id="nSlider" min="50" max="800" value="300" step="50">
  </label>
  <label>Noise: <span id="noiseLabel">30</span>
    <input type="range" id="noiseSlider" min="5" max="80" value="30" step="5">
  </label>
  <div class="btns">
    <button id="pauseBtn" type="button">Pause</button>
    <button id="resetBtn" type="button" class="ghost">Reset</button>
  </div>
</div>
<canvas id="canvas" width="480" height="300"></canvas>
<div id="info" class="info">Running… watch the cloud converge on the blue dot.</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; background: #fff; }
.controls { display: flex; flex-wrap: wrap; gap: .6rem 1.2rem; align-items: center; margin-bottom: .5rem; font-size: .85rem; }
label { display: flex; align-items: center; gap: .4rem; }
input[type=range] { width: 90px; accent-color: #e07b39; }
.btns { display: flex; gap: .5rem; margin-left: auto; }
button { font: 600 13px system-ui; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
canvas { display: block; border: 1px solid #dde3e8; border-radius: 8px; max-width: 100%; }
.info { font-size: .82rem; color: #555; margin-top: .4rem; min-height: 1.3em; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Particle Filter demo — tracks a random-walking target with noisy range observations.
// Algorithm: predict → weight → resample (SIR / Bootstrap filter).
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');
const W = canvas.width, H = canvas.height;

// ── Parameters (read from sliders) ─────────────────────────────────────
let N = 300;         // number of particles
let SENSOR_NOISE = 30; // std-dev of range sensor (pixels)
const PROCESS_NOISE = 4; // std-dev of random-walk step (pixels)
const TARGET_SPEED = 2;  // pixels per frame for target movement

// ── State ──────────────────────────────────────────────────────────────
let target = { x: W/2, y: H/2, vx: TARGET_SPEED, vy: TARGET_SPEED };
let particles = [];  // [{x, y, w}]
let paused = false;
let animId = null;
let frame = 0;

// ── Gaussian random (Box-Muller) ────────────────────────────────────────
function randn() {
  let u, v;
  do { u = Math.random(); } while (u === 0);
  do { v = Math.random(); } while (v === 0);
  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
}

// ── Initialise particles uniformly across canvas ────────────────────────
function initParticles() {
  particles = [];
  for (let i = 0; i < N; i++) {
    particles.push({ x: Math.random() * W, y: Math.random() * H, w: 1 / N });
  }
}

// ── Move target (bounce off walls) ─────────────────────────────────────
function stepTarget() {
  // Small random turn
  target.vx += randn() * 0.5;
  target.vy += randn() * 0.5;
  // Clamp speed
  const spd = Math.hypot(target.vx, target.vy);
  if (spd > TARGET_SPEED * 1.5) { target.vx *= TARGET_SPEED / spd; target.vy *= TARGET_SPEED / spd; }
  target.x += target.vx;
  target.y += target.vy;
  // Bounce
  if (target.x < 8)  { target.x = 8;  target.vx *= -1; }
  if (target.x > W-8){ target.x = W-8; target.vx *= -1; }
  if (target.y < 8)  { target.y = 8;  target.vy *= -1; }
  if (target.y > H-8){ target.y = H-8; target.vy *= -1; }
}

// ── Sensor: noisy range from a fixed corner beacon ──────────────────────
const BEACON = { x: 0, y: 0 }; // top-left corner
function trueRange() {
  return Math.hypot(target.x - BEACON.x, target.y - BEACON.y);
}
function noisyObs() {
  return trueRange() + randn() * SENSOR_NOISE;
}
function likelihood(px, py, obs) {
  const d = Math.hypot(px - BEACON.x, py - BEACON.y);
  const diff = d - obs;
  return Math.exp(-0.5 * diff * diff / (SENSOR_NOISE * SENSOR_NOISE));
}

// ── Predict: jitter each particle by process noise ──────────────────────
function predict() {
  for (const p of particles) {
    p.x += randn() * PROCESS_NOISE;
    p.y += randn() * PROCESS_NOISE;
    p.x = Math.max(0, Math.min(W, p.x));
    p.y = Math.max(0, Math.min(H, p.y));
  }
}

// ── Weight: Gaussian likelihood of the observation ──────────────────────
function weight(obs) {
  let total = 0;
  for (const p of particles) {
    p.w = likelihood(p.x, p.y, obs);
    total += p.w;
  }
  if (total === 0) { for (const p of particles) p.w = 1 / N; return; }
  for (const p of particles) p.w /= total;
}

// ── Resample: systematic resampling ────────────────────────────────────
function resample() {
  const newP = [];
  const step = 1 / N;
  let r = Math.random() * step;
  let cumW = particles[0].w;
  let j = 0;
  for (let i = 0; i < N; i++) {
    while (r > cumW && j < N - 1) { j++; cumW += particles[j].w; }
    newP.push({ x: particles[j].x, y: particles[j].y, w: 1 / N });
    r += step;
  }
  particles = newP;
}

// ── Estimate: weighted mean position ───────────────────────────────────
function estimate() {
  let ex = 0, ey = 0;
  for (const p of particles) { ex += p.x * p.w; ey += p.y * p.w; }
  return { x: ex * N, y: ey * N }; // weights already normalised to 1/N after resample
}

// ── Draw ──────────────────────────────────────────────────────────────
function draw(obs) {
  ctx.clearRect(0, 0, W, H);

  // Background grid
  ctx.strokeStyle = '#f0f3f6';
  ctx.lineWidth = 1;
  for (let x = 0; x <= W; x += 40) { ctx.beginPath(); ctx.moveTo(x, 0); ctx.lineTo(x, H); ctx.stroke(); }
  for (let y = 0; y <= H; y += 40) { ctx.beginPath(); ctx.moveTo(0, y); ctx.lineTo(W, y); ctx.stroke(); }

  // Sensor range ring (noisy observation)
  ctx.strokeStyle = 'rgba(100,120,180,0.35)';
  ctx.setLineDash([5, 5]);
  ctx.lineWidth = 1.5;
  ctx.beginPath();
  ctx.arc(BEACON.x, BEACON.y, obs, 0, 2 * Math.PI);
  ctx.stroke();
  ctx.setLineDash([]);

  // Beacon
  ctx.fillStyle = '#8899bb';
  ctx.beginPath();
  ctx.arc(BEACON.x, BEACON.y, 5, 0, 2 * Math.PI);
  ctx.fill();

  // Particles
  for (const p of particles) {
    ctx.globalAlpha = 0.55;
    ctx.fillStyle = '#e07b39';
    ctx.beginPath();
    ctx.arc(p.x, p.y, 2.5, 0, 2 * Math.PI);
    ctx.fill();
  }
  ctx.globalAlpha = 1;

  // Estimated position (weighted mean)
  const est = estimate();
  ctx.strokeStyle = '#e07b39';
  ctx.lineWidth = 2;
  ctx.beginPath();
  ctx.arc(est.x, est.y, 8, 0, 2 * Math.PI);
  ctx.stroke();

  // True target
  ctx.fillStyle = '#1d6fb8';
  ctx.beginPath();
  ctx.arc(target.x, target.y, 7, 0, 2 * Math.PI);
  ctx.fill();
  ctx.fillStyle = '#fff';
  ctx.beginPath();
  ctx.arc(target.x, target.y, 3, 0, 2 * Math.PI);
  ctx.fill();

  // Legend
  ctx.font = '11px system-ui';
  ctx.fillStyle = '#1d6fb8';
  ctx.fillText('● Target', W - 90, 16);
  ctx.fillStyle = '#e07b39';
  ctx.fillText('● Particles / estimate', W - 150, 30);
  ctx.fillStyle = '#8899bb';
  ctx.fillText('○ Sensor beacon', W - 150, 44);

  // Error
  const err = Math.hypot(est.x - target.x, est.y - target.y).toFixed(1);
  document.getElementById('info').textContent =
    fmt('Frame %frame% | Sensor noise σ=%SENSOR_NOISE%px | Estimate error: %err%px | %N% particles', { frame: frame, SENSOR_NOISE: SENSOR_NOISE, err: err, N: N });
}

// ── Main loop ──────────────────────────────────────────────────────────
function loop() {
  if (!paused) {
    stepTarget();
    const obs = noisyObs();
    predict();
    weight(obs);
    resample();
    frame++;
    draw(obs);
  }
  animId = requestAnimationFrame(loop);
}

function reset() {
  frame = 0;
  target = { x: W/2, y: H/2, vx: TARGET_SPEED, vy: 0.5 };
  N = parseInt(document.getElementById('nSlider').value);
  SENSOR_NOISE = parseInt(document.getElementById('noiseSlider').value);
  initParticles();
}

// ── Controls ───────────────────────────────────────────────────────────
document.getElementById('pauseBtn').addEventListener('click', function() {
  paused = !paused;
  this.textContent = paused ? 'Resume' : 'Pause';
});
document.getElementById('resetBtn').addEventListener('click', function() {
  reset();
  if (paused) { paused = false; document.getElementById('pauseBtn').textContent = 'Pause'; }
});
document.getElementById('nSlider').addEventListener('input', function() {
  N = parseInt(this.value);
  document.getElementById('nLabel').textContent = N;
  initParticles();
});
document.getElementById('noiseSlider').addEventListener('input', function() {
  SENSOR_NOISE = parseInt(this.value);
  document.getElementById('noiseLabel').textContent = SENSOR_NOISE;
});

// ── Start ──────────────────────────────────────────────────────────────
reset();
loop();

Result

Console

Notice how the cloud collapses around the target after a few seconds, then stretches to follow it as it wanders. Hit Pause to freeze a frame and inspect the spread; hit Reset to scatter the particles again from scratch. Crank up the noise slider to simulate a less accurate sensor and watch the cloud widen.

The key insight: no single particle is "the answer." The answer is the weighted average of the whole cloud — and the cloud's spread tells you how confident the algorithm is.

The Real Complexity

Particle filters are a solved tool in low dimensions and an open research frontier in high ones.

What is proven:

Convergence: as the number of particles N → ∞, the particle distribution converges to the true posterior — a theorem proved by Pierre Del Moral in the late 1990s.
Consistency: the estimated mean and variance approach the truth; error decreases roughly as 1/√N.
Flexibility: no assumptions on the noise distribution or the dynamics model — the particles carry the distribution implicitly.

The hard part — the curse of dimensionality: To cover a d-dimensional state space with enough particles that at least one sits near the true state, you need roughly N ∝ εᵈ particles for precision ε. In a 3D navigation problem a few thousand particles suffice. In a 50-dimensional robot arm, you would need more particles than atoms in the observable universe. This is not a limitation of particle filters specifically — it is a fundamental barrier for any sample-based method.

Practical mitigations:

Rao-Blackwellization: analytically marginalize out the linear-Gaussian part of the state, leaving only the nonlinear residual for particles. Used in FastSLAM.
Auxiliary particle filters (Pitt & Shephard, 1999): look one step ahead when resampling to avoid wasting particles on bad predictions.
Sequential importance resampling (SIR) tuning: choose the right resampling schedule — too often and you lose diversity (sample impoverishment); too rarely and weights degenerate.

Unlike Bayesian inference, which is generally intractable and only approximately solved, particle filters are exact in the limit — they just need a lot of samples to get there. The bottleneck is entirely computational, not theoretical.

Where It Matters

Anywhere a system moves through an uncertain state space and receives noisy sensor data, a particle filter is a natural fit:

Robot localization and SLAM: a robot scatters particles across a map; each particle carries a full hypothesis about the robot's pose. As it drives, particles that match laser-scan readings survive. This is how the Mars rovers Spirit and Opportunity navigated without GPS, and how warehouse robots map unknown floors in real time.
Autonomous vehicles: fusing lidar, radar, camera, and IMU data to track every nearby car's position and velocity — even when one sensor goes dark — is a particle filter job. Tesla and Waymo both use variants under the hood.
Computer vision: tracking a human face or hand through occlusions, changes in lighting, and rapid motion. The particle filter's ability to maintain multiple hypotheses prevents it from locking onto a ghost when the target briefly disappears.
Weather and climate: ensemble weather models are particle filters at planetary scale — thousands of model runs ("particles") are weighted against real observations and resampled to produce the probabilistic forecast you see as "40% chance of rain."
Finance: stochastic volatility models (e.g., Heston model) have a hidden state (instantaneous volatility) that cannot be observed. Particle filters estimate it from options prices in real time, helping traders price derivatives more accurately.
Medical monitoring: tracking a patient's hidden physiological state (drug concentration, tumour dynamics) from sparse, noisy blood-test readings.

The common thread: a hidden state evolving over time, noisy partial observations, and a need for uncertainty quantification — not just a point estimate, but a full distribution. See also Bayesian inference and Kalman filter for the Gaussian-linear special case that particle filters generalize.

Conclusion

The particle filter encodes a profound shift in thinking: a distribution is more honest than a point estimate. Rather than pretending you know where the target is, you carry all plausible positions simultaneously and let the evidence sort them out. The predict-weight-resample loop is just Bayes' theorem unrolled through time, approximated by a finite swarm.

That swarm tracks submarines, guides rovers across Mars, keeps autonomous cars from drifting into oncoming lanes, and updates the probability cloud on your weather app. Every application shares the same three-step heartbeat — predict, weight, resample — repeated until the cloud converges on truth.

The catch is dimension. Add enough unknowns and no computer can field enough particles to cover the space. That boundary is where active research lives: smarter proposals, analytical marginalization, neural approximations. The particle filter is not the last word — but it was the first algorithm that made Bayesian tracking practical, and decades later it remains the workhorse of state estimation.

Comments

Loading comments...

https://www.kipuhub.com/en/article/particle-filter/Content licensed under CC BY-NC 4.0.

Cookies & privacy

When probability clouds close in on reality