Instant-NGP & spatial multiresolution hash grids

Same idea, two grids. The coarse grid is small enough that every vertex gets its own table slot — dense, one color per chip, no repeats. The fine grid has 16 vertices but only 8 slots: three vertices, spread all over the grid, are forced to share slot 6 (ringed, same color). Instant-NGP just accepts that — it bets that gradient descent can still learn something useful per location, as long as most vertices land somewhere of their own.

Several grids, coarse to fine, each cover the same space; each vertex owns a learned feature. A resolution-$R$ grid has $R^2$ vertices — too many to store directly once $R$ gets large, so each level keeps a fixed-size hash table of size $T$ instead, and a vertex's feature lives at:

Querying a point bilinearly interpolates the 4 surrounding vertices at each level, then concatenates every level's result into one encoding:

• $R$ — grid resolution (vertices per axis); $T$ — the level's fixed hash table size.
• $(ix, iy)$ — a grid vertex's integer coordinates; $\oplus$ — bitwise XOR.
• $f_x, f_y$ — the query point's fractional position between its 4 surrounding vertices.
• $w_k$ — a corner's bilinear weight; all 4 weights always sum to exactly 1.

1. Coarse level: 2² = 4 vertices, table size 4 — dense

   Query point $(0.3, 0.7)$ sits $f_x=0.3$ of the way across, $f_y=0.7$ up. Each corner's bilinear weight:

   • $(1-f_x)(1-f_y) = (0.7)(0.3) = 0.21$
   • $f_x(1-f_y) = (0.3)(0.3) = 0.09$
   • $(1-f_x)f_y = (0.7)(0.7) = 0.49$
   • $f_xf_y = (0.3)(0.7) = 0.21$

   Against features $1, 2, 3, 4$: value $= 0.21(1) + 0.09(2) + 0.49(3) + 0.21(4) = 2.70$.

2. Fine level: 4² = 16 vertices, table size 8 — hashed

   Same query point, now at $(0.9, 2.1)$ in grid units — that's $f_x=0.9$ across its cell and $f_y=0.1$ up (the fractional part of $2.1$). Each corner's weight:

   • $(1-f_x)(1-f_y) = (0.1)(0.9) = 0.09$
   • $f_x(1-f_y) = (0.9)(0.9) = 0.81$
   • $(1-f_x)f_y = (0.1)(0.1) = 0.01$
   • $f_xf_y = (0.9)(0.1) = 0.09$

   Against hashed features $70, 80, 60, 50$: value $= 0.09(70) + 0.81(80) + 0.01(60) + 0.09(50) = 76.2$.

3. Concatenate

   The full encoding at this point is $[2.70,\ 76.2]$ — one number per level, handed to the (now tiny) MLP as input.

Drag the query point across the fine grid and watch exactly 4 vertices light up at a time — the bilinear stencil never touches a 5th. Push the point right onto a vertex and one weight goes to 1 while the other 3 vanish: the "interpolation" collapses to a plain lookup.

Two more query points on the fine level:

1. q = (0, 0) — exactly on a vertex

   All weight ($1.0$) lands on corner $(0,0)$, which hashes to slot $0$: value $= 10$ exactly, with zero contribution from the other 3 corners.

2. q = (1, 1) — the opposite corner

   All weight lands on vertex $(3,3)$ — the same vertex this chapter's Intuition beat showed colliding into slot 6 with two others. Value $= 70$, same as whatever else shares that slot.