Differentiable Polyphase Filter Optimization

Overview

This article uses a filtering chain based on Android Kawase V2 throughout. It starts by fitting a single-phase impulse response, examines the phase errors introduced by downsampling, and then introduces the polyphase supervision method from DPF: Differentiable Polyphase Filtering for Large-Kernel Approximation (SIGGRAPH 2026). Finally, it extends the optimization problem to downsampled blur with fixed, shared mipmap kernels, outlining how to solve for scale-dependent final sampling parameters under a fixed sampling budget.

Single-Phase Kawase Optimization

1. Shape Differences Between Kawase and Gaussian Blur

First, compare full-resolution Gaussian blur and Android Kawase V2 on the same $512\times512$ sinc test image, with their blur widths matched to target values of $\sigma=4,8,16,40$. The Dual Kawase implementation preserves high-frequency information by blending the original image with the blurred result. Its blur shape differs substantially from a Gaussian at the same scale.

Method	σ = 4	σ = 8	σ = 16	σ = 40
Gaussian	Image RMSE 0	Image RMSE 0	Image RMSE 0	Image RMSE 0
Android Kawase V2	blurRadius=6 Matched σ≈3.9817 Image RMSE 5.722e-2	blurRadius=17 Matched σ≈8.0894 Image RMSE 6.388e-3	blurRadius=32 Matched σ≈16.0737 Image RMSE 4.239e-3	blurRadius=90 Matched σ≈39.8502 Image RMSE 4.809e-3

2. The Kawase Processing Chain

The following diagram expands the Android Dual Kawase chain for a target of $\sigma=4$: an initial 4× downsample followed by one 2× downsample; on the way back, a 2× reconstruction blended with the saved image at that level, followed by a final 4× reconstruction blended with the original image.

The notation is as follows:

• $f(\mathbf x)$ and $f'(\mathbf x)$ are the full-resolution input and output. $\mathbf x$ denotes spatial coordinates before rearrangement, and $\mathbf k$ denotes discrete pixel indices after rearrangement. Intermediate stages use their respective input pixels as coordinate units.
• $\mathcal U_{K_u(s)}$ performs upsampling reconstruction with a sampling kernel. The Android implementation determines $s$ internally from blurRadius; $\widetilde p_i$ is the reconstructed image before blending.
• $\mathcal M_i$ blends the reconstructed result with the previously saved downsampled image at the same level: $\mathcal M_i(z)=\alpha_i z+(1-\alpha_i)q_i$.
• $\mathcal C_r$ blends in the original image at small radii: $\mathcal C_r(z)=\beta(r)z+(1-\beta(r))f$, where $r$ is the integer blurRadius and $\beta(r)=\min(1,r/10)$.

For blurRadius=6, the intermediate images follow $512^2\to128^2\to64^2\to128^2\to512^2$.

Input

512 × 512

Fixed 4×4 downsampling

128 × 128

2× downsampling 1

64 × 64

2× upsampling 1 · Blend 0.3464

128 × 128

4× enlargement + original blend

512 × 512

At the return to $128^2$, the inter-level blend factor is approximately $0.3464$. The final output contains $60\%$ blurred content and $40\%$ of the original image. Consequently, this small-radius result retains sharp details, and its impulse response contains a spike from the original-image contribution. It is not a strict Gaussian.

3. Single-Phase Impulse-Response Optimization

A common way to quantify the difference between Kawase and a reference blur kernel is to use the response to a single impulse as the equivalent convolution kernel of a complex graphics pipeline.

Input, Output, and Cross-Section

To evaluate a blur chain, construct a discrete impulse $\delta$: an image with a value of $1$ at the center pixel and $0$ everywhere else. Pass it through the complete processing chain $\mathcal P$ and record the output weight distribution:

The resulting $K$ is the impulse response at that input location. Its 2D image and center-row cross-section reveal its spread, peak, and shape. Comparing it with the target Gaussian also gives error metrics for parameter tuning. Below, Android Kawase V2 (blurRadius=90) processes a unit impulse at phase $(0,0)$. The full-resolution Gaussian is the reference, with the target scale still set to $\sigma=40$.

Input

Gaussian

Android Kawase V2

This approach to kernel evaluation is called single-impulse evaluation.

Although the Kawase baseline has a support size similar to the reference Gaussian, its peak is noticeably lower and its shape is flatter. Visually, the result looks somewhat “square.”

Single-Impulse Evaluation and the LSI Condition

The theoretical basis for single-impulse evaluation is the behavior of linear shift-invariant systems (LSI). If $\mathcal P$ is both linear and shift-invariant, one impulse response determines its output for any input:

In that case, optimizing the impulse response is equivalent to optimizing the convolution kernel of the entire chain. Dual Kawase, however, is not an LSI system. This is the central issue explored in this article. For now, we follow the single-impulse approach and fit the Dual Kawase response at one location to a Gaussian as closely as possible. The next section introduces a method that addresses the missing supervision.

Defining the Optimization Variables

The kernels at each stage are shown below. Offsets are measured in input texels of the corresponding pass, and every lookup uses bilinear sampling.

These three kernels can be described by four variables: starting angle $\theta$, number of outer samples $n$, center weight $w_c$, and ring radius $a$.

For the three Kawase downsampling and upsampling kernels above:

There are also the inter-level blend factor $\alpha$ and the final blurred-image fraction $\beta$. For the $\sigma=4$ chain below, the three kernels have four parameters each. With the two blend factors, this gives $3\times4+2=14$ parameters. The three sample counts $n$ are discrete integers, fixed here to $4,4,7$. The continuous optimization therefore uses $(\theta,w_c,a)$ for each kernel, plus $\alpha,\beta$: $3\times3+2=11$ variables. For convenience, write each kernel's parameter group as $\Omega_k=(\theta_k,n_k,w_{c,k},a_k)$, with $k$ taking the values $d,4$, $d,2$, and $u$. A complete solution is $\Omega=(\Omega_{d,4},\Omega_{d,2},\Omega_u,\alpha,\beta)$.

Defining the Single-Phase Loss and Solving with Gradients

Let $G_\sigma$ be the full-resolution discrete Gaussian kernel with target standard deviation $\sigma$, and let $\mathcal F_\Omega$ denote the complete Kawase chain. Place a unit impulse $\delta_0$ at the fixed center location, phase $(0,0)$, and minimize the squared error against the target response:

Let $\mathcal D_{K_{d,4},4}$ and $\mathcal D_{K_{d,2},2}$ denote 4× and 2× downsampling with their respective kernels, $\mathcal U_{K_u,2}$ denote 2× upsampling with its kernel, and $\mathcal R_4$ denote fixed 4× bilinear reconstruction. For input $f$, the intermediate images and two blends are

$\widetilde p_0$ is the reconstructed, pre-blend image described in the processing-chain section. When $f=\delta_0$, the output $f'$ is the $\mathcal F_\Omega(\delta_0)$ used in the loss.

The interactive demo below defaults to Levenberg–Marquardt (LM). It uses each output pixel's derivatives with respect to the parameters to estimate parameter sensitivities and interactions, then solves for a joint update direction. For background, see Ceres's explanation of LM.

This approach can be extended to all target values of $\sigma$, fitting Gaussian blur at arbitrary radii.

Comparing the Single-Phase Results

Drag the slider to compare the reference Gaussian, corrected Android Kawase V2, and single-phase impulse fits for target values $\sigma=0\ldots40$. The 80 settings $\sigma=0.5,1,\ldots,40$ are solved independently. At $\sigma=0$, the original image passes through unchanged, giving 81 slider positions in total.

The Android baseline retains the level count, sampling kernels, and blend schedule determined by integer blurRadius, corrects the signs of the upsampling heptagon's STEP_4.x and STEP_6.x, and uses a fixed phase-zero registration. For each target $\sigma$, it selects the integer radius whose mean-response width is closest to the target, so its actual width need not match exactly. The optimized chain uses the level count for that setting, fixes the outer sample counts at $4,4,7$, and fits each kernel's angle, center weight, and radius, together with the per-level and original-image blend factors.

Each setting supervises only a unit impulse at phase $(0,0)$, using the full 2D squared error. L-BFGS-B starts from four fixed initializations and solutions at nearby scales; at $\sigma=4,40$, the single-phase parameters in Appendix D are added as initializations. A further refinement round uses the neighboring settings with the same level count, retaining the solution with the lowest error. “Best result” means the lowest-error numerical solution among these candidates, not a proven global optimum. Moving the slider loads the independently solved parameters for that setting and runs the full filtering chain on the GPU in real time. Cross-sections and errors are precomputed from the same parameters' float64 reference responses and cached, avoiding a GPU readback every frame. The Gaussian is sampled discretely at full resolution, truncated at $5\sigma$, and normalized.

Each canvas has a width-to-height ratio of $1:2$: the upper half shows the blurred full sinc image, and the lower half shows a single impulse. Each half is computed separately at $512\times512$. At every sampling stage, out-of-bounds coordinates are mirrored back into their own region before pixel lookup, so the two halves never mix across their boundary. Both Gaussian and Kawase use these mirror boundaries in the interactive figure. Its sinc-image edges therefore differ from the earlier static comparisons, which use clamp boundaries there.

The sinc image in the upper half is always displayed at $1\times$. The “Enhanced impulse grayscale” toggle controls the lower half of all three images. When enabled, it uses the target Gaussian peak as a shared exposure reference, amplifying weak responses to reveal their shape. When disabled, it displays the raw unit-impulse amplitudes without exposure or peak normalization. This toggle does not change the sinc image, impulse cross-section, or impulse error.

5. Shifting the Input to Check Phase Error

Keep the single-phase optimized parameters for $\sigma=40$ fixed. Call the resulting chain $\mathcal F_B$, the sinc test image $I$, and a one-pixel rightward translation $T_1$. If the chain is shift-invariant, shifting the input before blurring should equal shifting the blurred output:

The comparison must therefore use these two spatially corresponding outputs and inspect their difference:

The evaluation should avoid finite-image boundary effects, and the cross-sections must use consistent spatial coordinates. The actual shifted-image comparison is not yet included.

The input's position relative to the fixed downsampling grid is its phase here. Moving the same local signal changes the weights that enter the sampling grid; subsequent reconstruction spreads those samples back to full resolution.

Dual Kawase repeatedly downsamples and reconstructs on fixed grids. Although it remains linear, it is generally not shift-invariant under single-pixel translations. An impulse response at one phase cannot simply be treated as a convolution kernel shared by every location. A symmetric sampling stencil in an individual pass does not guarantee that the complete response at every input location is symmetric about that input point.

This exposes the omission in the single-impulse loss: even if the supervised response closely matches the Gaussian, responses at other phases remain unconstrained. Further reducing the loss at that one location cannot reveal errors at the others.

The limitation of the single-impulse objective is incomplete supervision. Even if $\mathcal L_{\mathrm{single}}$ reached zero, it would determine the response at only one location. Moving the impulse to another phase could still produce shape errors. The next step is to enumerate all phases, optimize them jointly, and test whether the same sampling budget allows further improvement.

Polyphase Kawase Optimization

1. Polyphase Impulse Responses

The Polyphase Supervision Framework

Section 4.2 of the DPF paper models fixed-grid multiresolution filtering chains as linear periodically shift-varying systems (LPSV). Away from boundaries, a one-pixel translation may change the response shape, but the response pattern repeats after a full sampling period.

The paper extends single-impulse supervision to polyphase impulse supervision. Offline, unit impulses are placed at different locations within one period and processed by the same chain. The target kernel is translated to each corresponding input location. The squared errors of all responses against their targets are summed, and differentiable filtering operations are used to optimize sparse sample positions and weights. At runtime, images are processed directly with the solved kernels; the multiple impulses are needed only for offline optimization.

The full DPF method also includes Spatial-to-Depth, asymmetric sampling of luminance and chrominance, and hierarchical selection for variable kernels. Here, only its polyphase supervision method is applied to the previously defined shared $K_{d,4},K_{d,2},K_u$ kernels and blend-parameter family, to test the effect of completing the supervised phase set. Sample counts, level counts, and parameter constraints remain the same as in B.

σ=4: Enumerating Every Input Phase

To show every phase explicitly, this section uses $\sigma=4$, with an initial 4× downsample followed by one 2× downsample. Single-phase fitting is repeated for this target to obtain B at this scale. The subsequent polyphase optimization also fixes $\sigma=4$, with the same level count and parameter bounds. First, inspect the single-phase fit at this scale:

σ=4 · Input phase (0,0) · Shared display gain 2×, no clipping. A—A marks the center row; the overlaid curve below shows its raw values, with Gaussian as a gray dashed reference.

Gaussian

2D RMSE 0

Android Kawase V2

2D RMSE 3.262e-3

B · Single-impulse fit

2D RMSE 3.803e-5

Keep B's kernels unchanged and vary only the impulse location. For a chain with an initial 4× downsample, followed by $N$ levels of 2× downsampling and corresponding reconstruction, the per-axis phase period can be taken as

$N$ excludes the initial 4× downsample. At $\sigma=4$, $N=1$, requiring $8\times8=64$ input phases; at $\sigma=40$, $N=3$, requiring $32\times32=1024$. At a given scale, A, B, and C use the same chain structure and phase set.

Choose a reference location $\mathbf n_0$ far from the boundaries, with both coordinates divisible by $P$, and place the unit impulse $\delta_{\boldsymbol\phi}$ at $\mathbf n_0+\boldsymbol\phi$. Define the response relative to its own input location:

The center location supervised by single-phase fitting corresponds to $(0,0)$. The figure below defaults to all 64 responses of B at $\sigma=4$; Gaussian and A are also available. Each card identifies its phase coordinates. All plots for one method share a display gain and coordinate range; switching methods resets the gain and vertical axis as indicated. The curve's origin always corresponds to the input location. At small radii, A contains a spike from the original-image passthrough and therefore uses a lower display gain.

GaussianAndroid Kawase V2B · Single-impulse fit

B · Single-impulse fit · All 64 input phases at σ=4, period 8 per axis. These 64 plots share 20× gain and a vertical range, reset when switching methods. Curves retain raw response values; gray dashed curves are Gaussian. Zero marks the input location.

φ=(0, 0)

2D RMSE 3.803e-5

φ=(1, 0)

2D RMSE 5.485e-4

φ=(2, 0)

2D RMSE 3.775e-4

φ=(3, 0)

2D RMSE 2.833e-4

φ=(4, 0)

2D RMSE 3.552e-4

φ=(5, 0)

2D RMSE 5.493e-4

φ=(6, 0)

2D RMSE 6.825e-4

φ=(7, 0)

2D RMSE 5.571e-4

φ=(0, 1)

2D RMSE 3.159e-4

φ=(1, 1)

2D RMSE 3.177e-4

φ=(2, 1)

2D RMSE 3.750e-4

φ=(3, 1)

2D RMSE 5.453e-4

φ=(4, 1)

2D RMSE 5.341e-4

φ=(5, 1)

2D RMSE 5.977e-4

φ=(6, 1)

2D RMSE 6.720e-4

φ=(7, 1)

2D RMSE 5.445e-4

φ=(0, 2)

2D RMSE 5.486e-4

φ=(1, 2)

2D RMSE 3.732e-4

φ=(2, 2)

2D RMSE 4.210e-4

φ=(3, 2)

2D RMSE 5.031e-4

φ=(4, 2)

2D RMSE 5.461e-4

φ=(5, 2)

2D RMSE 6.199e-4

φ=(6, 2)

2D RMSE 6.889e-4

φ=(7, 2)

2D RMSE 7.673e-4

φ=(0, 3)

2D RMSE 2.782e-4

φ=(1, 3)

2D RMSE 4.646e-4

φ=(2, 3)

2D RMSE 5.455e-4

φ=(3, 3)

2D RMSE 3.830e-4

φ=(4, 3)

2D RMSE 4.328e-4

φ=(5, 3)

2D RMSE 6.696e-4

φ=(6, 3)

2D RMSE 5.476e-4

φ=(7, 3)

2D RMSE 5.937e-4

φ=(0, 4)

2D RMSE 3.521e-4

φ=(1, 4)

2D RMSE 5.459e-4

φ=(2, 4)

2D RMSE 5.613e-4

φ=(3, 4)

2D RMSE 4.321e-4

φ=(4, 4)

2D RMSE 4.727e-4

φ=(5, 4)

2D RMSE 5.474e-4

φ=(6, 4)

2D RMSE 7.558e-4

φ=(7, 4)

2D RMSE 6.066e-4

φ=(0, 5)

2D RMSE 6.024e-4

φ=(1, 5)

2D RMSE 5.947e-4

φ=(2, 5)

2D RMSE 6.180e-4

φ=(3, 5)

2D RMSE 5.470e-4

φ=(4, 5)

2D RMSE 7.020e-4

φ=(5, 5)

2D RMSE 7.300e-4

φ=(6, 5)

2D RMSE 7.740e-4

φ=(7, 5)

2D RMSE 5.465e-4

φ=(0, 6)

2D RMSE 5.495e-4

φ=(1, 6)

2D RMSE 6.692e-4

φ=(2, 6)

2D RMSE 6.869e-4

φ=(3, 6)

2D RMSE 7.297e-4

φ=(4, 6)

2D RMSE 5.480e-4

φ=(5, 6)

2D RMSE 7.737e-4

φ=(6, 6)

2D RMSE 8.091e-4

φ=(7, 6)

2D RMSE 8.595e-4

φ=(0, 7)

2D RMSE 5.577e-4

φ=(1, 7)

2D RMSE 7.521e-4

φ=(2, 7)

2D RMSE 5.449e-4

φ=(3, 7)

2D RMSE 5.884e-4

φ=(4, 7)

2D RMSE 6.099e-4

φ=(5, 7)

2D RMSE 8.314e-4

φ=(6, 7)

2D RMSE 5.472e-4

φ=(7, 7)

2D RMSE 6.772e-4

Gaussian responses are identical across phases; A and B vary with phase. Response mass, centroid, and width statistics are provided in Appendix C.

Together, these responses determine the chain's behavior for any input. Away from boundaries, linear superposition gives

A universal convolution kernel can replace the chain only if all input-aligned $R_{\boldsymbol\phi}$ are identical. B optimizes only one of them, so the next step is to include the entire response family in the loss.

Reevaluating the Single-Phase Fit with a Polyphase Loss

Following Equations (5) and (6) of the paper, translate the target Gaussian to each impulse location. For the complete B/C parameter set $(K_{d,4},K_{d,2},K_u,\boldsymbol\alpha,\beta)$, define

$\mathcal S_{\boldsymbol\phi}$ translates the centered target kernel to $\mathbf n_0+\boldsymbol\phi$. The right-hand side instead uses coordinates relative to each input point. The target moves with the input, while phase-dependent shape differences remain in the residuals.

Reevaluating all phases gives

where $M$ is the side length of one response image. The $\sigma=4$ experiment in this section uses $M=128$. Worst-phase RMSE is the largest per-phase RMSE. All-phase RMSE aggregates squared errors before taking the square root; it is not the arithmetic mean of the per-phase RMSE values.

Single-phase RMSE evaluates only the directly supervised location, whereas all-phase RMSE aggregates all 64 input phases. They are not interchangeable; numerical values appear in the error table below.

2. Polyphase Optimization at a Single σ

Keeping the Same Optimization Variables

Call the polyphase optimized method C. It retains B's three ring kernels, all blend factors, nonnegative unit-sum weights, radius bounds, and cross-level sharing. It also uses the same four initializations and L-BFGS-B solver. Only the supervised set changes: B uses $(0,0)$, while C uses all phases.

Minimizing the Polyphase Loss

Minimizing the loss gives the polyphase optimized method C:

Computing Gradients of Weights and Sampling Offsets

Bilinear interpolation is piecewise differentiable with respect to sample positions, and a weighted sum is differentiable with respect to its weights. Both the single-phase and polyphase least-squares objectives can therefore propagate gradients through the complete chain. The first part uses the same gradient-based approach; this section adds input phases to the loss.

Updating Parameters and Comparing Results

At a fixed $\sigma=4$, compare the impulse and sinc outputs of Gaussian, single-phase B, and polyphase C. B and C each contain one $K_{d,4}$, one $K_{d,2}$, a cross-level shared $K_u$, and per-level blend factors. At runtime, the same chain processes the entire image. Complete parameter tables for each scale are in Appendix D.

σ=4 · Input phase (0,0) · Shared display gain 20×, no clipping. A—A marks the center row; the overlaid curve below shows its raw values, with Gaussian as a gray dashed reference.

Gaussian

2D RMSE 0

B · Single-impulse fit

2D RMSE 3.803e-5

C · Polyphase optimization

2D RMSE 1.956e-4

σ=4 · B/C: initial 4× downsample, 1 levels of 2× down/up · Outputs at 1×

Gaussian

Image RMSE 0

B · Single-impulse fit

Image RMSE 3.486e-2

C · Polyphase optimization

Image RMSE 1.531e-2

Gaussian · AE ×1

max 0 · No clipping

B · AE ×1

max 3.066e-1 · No clipping

C · AE ×1

max 2.209e-1 · No clipping

At this scale, all-phase RMSE decreases by approximately 59.34%, and sinc-image RMSE by approximately 56.07%. These metrics evaluate the full impulse-response family and this particular test image, respectively.

C has a larger error than B at $(0,0)$, but a lower total squared error across all phases. Thus, B's single-location fit still leaves room for improvement: the same parameter family and sampling budget can produce another set of kernels and blend factors that better approximates Gaussian responses across all phases. C is still constrained by the finite sampling stencils, however, and does not guarantee identical responses at every phase.

3. Polyphase Optimization Across Multiple σ Values

Solving Each σ Independently

Each target scale requires its own level count and kernel parameters. The table below retains two independently solved scales. They establish results only for those two targets, not a continuous mapping from σ to parameters.

Fitting Parameters as Functions of σ

Rerunning the Complete Chain with Fitted Parameters

Polyphase Optimization of Downsampled Blur

1. A Downsampled Blur Chain with Fixed Mipmaps

This section applies polyphase supervision to a shared mipmap-pyramid blur method: first build a shared mipmap pyramid with fixed box kernels, then use a small kernel to sample a selected mip level for each final-resolution output pixel. Blur coverage comes from the combination of the mip level and the final sampling kernel.

This method samples the mipmap directly at the final resolution, rather than following Kawase's level-by-level upsampling chain. The constraints and solution procedure are outlined below; optimization results are not yet included.

2. Optimization Variables and Runtime Constraints

• Fixed, shared mipmap kernels. All σ values use the same fixed downsampling results. Only the final sampling weights and offsets are solved for each σ.
• Fixed sampling budget. Specify the sample count of the final pass and use the same budget for the original and optimized methods. Record the shared mipmap construction cost separately.
• Continuous blur radius. After parameter fitting, inspect outputs at neighboring σ values and around mip-level transitions.
• Retain the original mip-level selection rule. Level selection is not a variable in this round of continuous parameter optimization.

3. Polyphase Optimization Across Multiple σ Values

Solving Each σ Independently

With the shared mipmap and the level for that σ fixed, enumerate input phases and build a polyphase squared-error objective for the final sampling parameters.

Fitting the Final Sampling Parameters

Rerunning the Complete Chain with Fitted Parameters

4. Comparing the Original and Polyphase Optimized Methods

Appendix: Derivations, Additional Comparisons, and Reproduction

A. Revisions to the Android Baseline

A, B, C, and the interactive demos use the same Android-derived implementation. It retains V2's initial 4× scaling, subsequent 2× scaling, inter-level blending, and original-image blending, with the following two revisions. These describe the version used in this article; they do not imply that AOSP has incorporated the changes.

Two Signs in the Direction Constants

The pinned AOSP revision describes the upsampling directions as a regular heptagon, but the signs of STEP_4.x and STEP_6.x do not match the corresponding vertices:

A retains the decimal precision of those constants. B/C and the interactive demo generate directions with the trigonometric functions of a regular heptagon. The heptagon's sample positions have a zero centroid, but are not symmetric about both the x and y axes. Nor does this guarantee that the discrete response's peak lies at its centroid.

Reference-Coordinate Compensation for Downsampling and Upsampling

This article uses input phase $(0,0)$ as its registration reference. With integer pixel indices, the original implementation's first 4× downsample is equivalent to averaging nonoverlapping $4\times4$ input blocks. An impulse at $(256,256)$ falls into the block indexed $256\sim259$, corresponding to low-resolution pixel $(64,64)$. The original 4× reconstruction maps its center back to $(257.5,257.5)$, adding a displacement of $1.5$ original-image pixels per axis to the blurred branch.

Compensation must be applied inside the sampling coordinates of every upsampling pass, before blending with a saved same-level image or the original image. For the current kernel parameters, first generate the downsampling pyramid from a fixed phase-$(0,0)$ impulse. Let $\boldsymbol\mu_i$ be the centroid of level $i$ relative to its reference position, measured in that level's texels. Uncompensated 2× reconstruction maps the child centroid to $2\boldsymbol\mu_{i+1}+\tfrac12\mathbf1$, so the output displacement to subtract is

$\mathbf o_i$ is the offset, in input texels, added to that pass's sampling coordinates. It gives the reconstructed branch the same reference centroid as the saved level-$i$ image; only then are they blended. The final 4× reconstruction uses $\mathbf o_f=\boldsymbol\mu_0+\tfrac38\mathbf1$, returning the blurred branch to the original-image reference position before the final blend.

These offsets are determined by the kernel parameters and the fixed reference impulse; they are not extra optimization variables. One parameter set uses the same offsets for the entire image and every phase, without repositioning based on the image being processed. Optimization also propagates the offsets' derivatives with respect to the kernel parameters. A zero reference response has no centroid, so a finite neutral fallback is used while retaining the zero response and its loss.

For A's original stencils, $\boldsymbol\mu_0=0$. The 2× downsampling weights give exactly $\mathbf d_i=0$, and the final 4× reconstruction requires an output correction of $1.5$ pixels per axis. The original and article sampling positions are then

This simplification does not extend to arbitrary optimized parameters. For example, if both $K_{d,2}$ and $K_u$ collapse to center-only sampling, the child response lies at index $32$. Uncompensated 2× reconstruction centers it at parent index $64.5$, whereas the saved parent response lies at $64$. That 2× upsampling pass therefore needs an extra $0.25$ input texels per axis, correcting half a parent pixel to the left and up. Correcting only the final 4× reconstruction would still blend two internally misaligned branches first.

This procedure retains the downsampling and upsampling stencils and changes only a common coordinate offset for each group of samples. It adds neither prefiltering nor an extra image-translation pass. Once the kernel parameters are fixed, the reference probes and offsets can be precomputed; actual images run only the existing sampling and blending chain.

For blurRadius=6, the uncompensated phase-$(0,0)$ blurred branch is displaced by $1.5$ pixels per axis, or $0.9$ pixels after blending with the original image. Compensation returns both centroids to the input centroid within numerical error. This is coordinate compensation for a designated reference phase, not per-phase alignment. Other input locations within the same block still share the first-level samples. Moving the impulse diagonally to phases $(1,1),(2,2),(3,3)$ yields complete-output displacements of $-0.6,-1.2,-1.8$ pixels per axis. These genuine phase differences enter the main polyphase loss unchanged.

The original per-pass audit is saved in android-coordinate-audit.json. The article's version of A is checked with verify_aosp_kawase_v2_skia --registered. Its original stencils have zero internal offsets; in the independent Skia execution, the final blur shader's matrix translation is set to $(-1.5,-1.5)$ original-image pixels before comparison with the float64 implementation. CPU F32 validation covers all 64 phases at $\sigma=4,8$, eight distributed phases each at $\sigma=16,40$, the sinc image, and odd-sized image boundaries. Results are recorded in android-registered-skia-validation.json.

For variable kernels, test_android_kawase_core.py additionally covers center-only and general kernels at $N=1,2,3$. It compares per-level centroids before and after blending and checks final reference registration, other-phase differences, direct rendering against frequency-domain evaluation, and full gradients including offset derivatives. The interactive demo has corresponding TypeScript checks.

B. Gaussian5x5 Single-Stage Impulse Experiment

Centered Impulse

This single-stage chain illustrates impulse evaluation: Gaussian5x5 prefiltering, 2× decimation on the even grid, a $7\times7$ Gaussian with $\sigma=1.5$ at low resolution, and reconstruction with a triangle kernel. It isolates the decimation grid's effect on the impulse response. The main Kawase fits use a different, complete chain. Here, the processing chain is again denoted by $\mathcal P$, with centered impulse response $K=\mathcal P(\delta)$.

Input

Discrete impulse $\delta$ (enlarged center)

Downsampled Rearrangement

$d[\mathbf k]$

Output

Gaussian5x5 single-stage equivalent kernel $K=\mathcal P(\delta)$

Cross-Section

Center-row cross-section of equivalent kernel $K$

Impulse Shifted One Pixel to the Right

Keep the chain and kernel parameters fixed, and move only the input impulse one pixel to the right. If the system is shift-invariant, the new output must be exactly the original response shifted right:

Using the same Gaussian5x5 single-stage demo chain and changing only the input position gives:

Input

Discrete impulse $\delta(x-1)$ (enlarged center)

Downsampled Rearrangement

$d[\mathbf k]$

Output

Gaussian5x5 single-stage equivalent kernel $K_1=\mathcal P(\delta(x-1))$

Cross-Section

Center-row cross-section of equivalent kernel $K_1$

Compared with the centered response, the output changes shape as well as position:

The decimation grid remains fixed. An impulse at an even location and one at an odd location place prefiltered weights on different sample positions, changing the values that enter the low-resolution image. Reconstruction then spreads those samples back to high resolution. The input's position relative to this fixed grid is its phase.

C. Per-Phase Response Statistics

Gaussian responses are identical across phases; Kawase-chain responses can still vary with phase. A, B, and C all use period $P=4\cdot2^N$, giving 64 phases at $\sigma=4$ and 1024 at $\sigma=40$. The metrics enumerate every phase.

Response mass is the sum of the weights. Centroid displacement uses the input point as the origin, and per-axis $\sigma$ is calculated from the second moment about the response's own centroid. Equal mass and centroid do not imply equal width, peak, or shape. The upsampling kernel is a heptagon, so responses must not be additionally averaged with their reflections about both axes. The mean-response width used for radius calibration also differs from the range of single-phase widths.

D. Complete Parameters, Additional Comparisons, and Error Analysis

Kernel Parameters and Fit Metrics at Two Target Scales

A uses the Kawase baseline parameters described above. B and C are solved with single-phase and polyphase objectives, respectively. The tables below summarize parameters and impulse errors at $\sigma=4$ and $\sigma=40$. Each scale uses its own parameters; B and C share the same sampling budget and parameter bounds.

σ=4: phase-(0,0) RMSE is 3.803e-5 for B and 1.956e-4 for C. All-phase RMSE changes from 5.795e-4 (B) to 2.357e-4 (C), a 59.34% reduction.

σ=40: phase-(0,0) RMSE is 2.063e-7 for B and 3.026e-7 for C. All-phase RMSE changes from 8.268e-7 (B) to 5.494e-7 (C), a 33.55% reduction.

Additional Sinc-Image Comparisons

First, compare Gaussian, Kawase baseline A, and single-phase B at $\sigma=4$; then compare Gaussian, B, and C at $\sigma=40$. Image computation and AE display conventions are given in Appendix E.

σ=4 · A: Android blurRadius=6; B: initial 4× downsample, 1 levels of 2× down/up · Outputs at 1×

Gaussian

Image RMSE 0

Android Kawase V2

Image RMSE 5.722e-2

B · Single-impulse fit

Image RMSE 3.486e-2

Gaussian · AE ×1

max 0 · No clipping

A · AE ×1

max 4.984e-1 · No clipping

B · AE ×1

max 3.066e-1 · No clipping

σ=40 · B/C: initial 4× downsample, 3 levels of 2× down/up · Outputs at 1×

Gaussian

Image RMSE 0

B · Single-impulse fit

Image RMSE 4.631e-3

C · Polyphase optimization

Image RMSE 4.596e-3

Gaussian · AE ×20

max 0 · No clipping

B · AE ×20

max 3.029e-2 · No clipping

C · AE ×20

max 3.055e-2 · No clipping

σ=4: sinc-image RMSE is 3.486e-2 for B and 1.531e-2 for C, a 56.07% decrease. This percentage compares only B/C, with identical sampling budgets, parameter families, and boundary rules.

σ=40: sinc-image RMSE is 4.631e-3 for B and 4.596e-3 for C, a 0.75% decrease. This percentage compares only B/C, with identical sampling budgets, parameter families, and boundary rules.

The tables report all-phase impulse errors and sinc-image errors separately. All-phase supervision improves the response objective over the full kernel support. Finite images also involve per-level clamp boundaries and the structure of the particular input. These two metrics are not interchangeable.

Mean-Kernel Shape Error and Phase Variation

To distinguish mean-shape approximation error from phase variation, take the mean of the input-aligned responses:

The squared error has the exact decomposition

The cross term vanishes because $\sum_{\boldsymbol\phi}(R_{\boldsymbol\phi}-\bar R)=0$. Even if the mean response closely matches a Gaussian, the total error remains nonzero while the phases differ. The last two table columns divide these two terms by the response pixel count and take their square roots. The sum of their squares therefore equals the square of the all-phase RMSE.

“Interior RMSE” excludes a 32-pixel border on all four sides of the original image. For the large-support $\sigma=40$ kernel, that region may still be affected by boundaries; it is not a fully boundary-free experiment.

B's single-impulse objective constrains one designated response; moving from B to C fills in the missing phase supervision. A, B, and C use the same chain structure. A only matches an integer radius, whereas B/C optimize kernel and blend parameters. The polyphase loss does not separately guarantee reductions in centroid error, worst-phase error, or error on every image.

Impulse Metrics and Actual Image Error

For input noise with independent, zero-mean, equal-variance pixels, expected output-error energy is proportional to the summed squared response errors. Real images have spatial correlations, so response errors from different locations can cancel or reinforce one another. Downsampled blur should therefore be evaluated using both the complete polyphase impulse responses and actual images: the former measures approximation across input locations; the latter tests the result for specific images and boundary conditions.

E. Numerical Configuration and Reproduction

Matching the Android Radius to the Target σ

A uses the baseline defined in Appendix A. Its stencil weights, level schedule, sampling distances, and blend factors are determined by integer blurRadius. This radius is not the Gaussian standard deviation, and the width at one phase cannot represent the whole chain.

For every candidate radius $r$, align all $P(r)^2$ responses in its full period to their respective input locations and average them, producing unit-mass $\bar R_r$. Let its centroid be $\boldsymbol\mu_r$. The matching scale is the mean of the two central variances:

This step matches spread only; it does not fit weights or offsets using Gaussian response-shape error. The numerical implementation propagates moments through every sample and interpolation, and is verified by explicitly enumerating all phases. It includes the initial downsample, progressive reconstruction, inter-level blending, final 4× enlargement, and small-radius blend. Measuring width with central moments does not shift the output: images and losses still use the input point as their origin.

Targets $\sigma=4,8,16,40$ select integer radii $6,17,32,90$, with mean-response standard deviations of approximately $3.9817,8.0894,16.0737,39.8502$. Integer steps are coarse at small radii, so width matching itself has a residual; see the table above.

To reproduce Android's internal radius schedule, the numerical port follows the source directly: $\rho=0.57735r$, continuous depth $d=\min(3,\rho/10)$, $N=\lceil d\rceil$, and $\alpha_i=\min(1,d-i)$. The source's step, denoted by $s$, is uniquely determined by these quantities; radius matching searches only over $r$. In shader coordinates,

When $N=0$, set $s=0$. In an exactly 2× upsampling pass, $s$ shader pixels correspond to $s/2$ input texels.

Static figures and numerical metrics use float64 linear luminance; the interactive σ-slider images use float32 shaders. The scope of the independent Skia checks is described in Appendix A. These are neither Android-device screenshots nor performance measurements.

Impulse Responses and Solver Configuration

$G_\sigma$ is centered on the input impulse. The loss sums every pixel of the full 2D response; cross-sections are only a visualization. Fitting retains raw response values without peak or mass normalization, and evaluation does not separately recenter output centroids. The Gaussian target is truncated at $5\sigma$ per axis and normalized. The fixed-parameter B/C comparisons use $N=1$ with $128\times128$ response canvases at $\sigma=4$, and $N=3$ with $512\times512$ canvases at $\sigma=40$. The final figures cover the complete kernel support. During search, if a candidate exceeds that support, the evaluation canvas expands automatically to avoid circular-convolution aliasing. Impulse rendering uses a larger zero background to isolate boundaries.

Although the residuals form a least-squares objective, the full multilevel chain depends nonlinearly on sample distances and weights. The fixed-parameter B/C comparison uses L-BFGS-B with analytic gradients and parameter bounds. It solves from four initializations for at most 180 iterations each, then retains the lowest-loss result. The solver scales the loss only by a fixed target energy, which does not change the optimum. “Optimized result” means the best result found within these bounds and initializations, not a proven global optimum.

The σ slider's 80 single-phase fits allow up to 250 iterations per initialization, with nearby-scale solutions and the same-scale single-phase parameters from Appendix D as additional starts. This parameter table is stored independently; the later all-phase statistics for B/C still correspond to the fixed parameters in Appendix D. Slider rendering and RMSE computation use $512\times512$, while fitting adapts the canvas to kernel support. Both contain the complete response, so the ratio of squared error to target energy is unaffected by the amount of zero background.

The large-scale chain has 1024 phases. To avoid retaining 1024 large response images during optimization, the numerical implementation uses correlation operations on the cascaded filters to compute the exact all-phase squared error and its gradient. This is equivalent to summing the objectives for every phase individually. The final kernels are also checked against an independent per-pixel sampling and blending chain, and evaluation explicitly enumerates all phases.

Image and Error Display Conventions

Each comparison identifies its participating methods in the headings. Static images are computed in float64 linear luminance. A/B/C use clamp boundaries inside the pyramid and mirror boundaries for final reconstruction; Gaussian uses clamp. In comparisons with AE, each column shows the actual output above its absolute error relative to Gaussian: $\mathrm{AE}=|I_{\mathrm{method}}-I_G|$.

All static outputs are displayed at $1\times$. Within one scale, AE uses the fixed gain indicated in the figure, with white representing zero error and no display clipping. The two scales use different gains, so error magnitudes cannot be compared across scales by darkness alone. Gaussian's error against itself is entirely white. The σ slider's raw mode displays response $h$ on white as $1-h$; enhanced mode uses $\exp(-2.5h/G_\sigma(0,0))$. Display values are clamped to $[0,1]$; raw curves and metrics do not use this mapping.

Reproduction Commands and Validation Scope

The four opening Gaussian / Android V2 comparisons can be generated separately with python3 -m scripts.generate_android_sinc_comparison. Radii, image errors, and the source-image hash are recorded in content/blog/differentiable-polyphase-filtering/android-sinc-comparison-data.json.

Regenerate σ-slider parameters with python3 -m scripts.fit_single_phase_sweep, which requires NumPy, SciPy, and Numba. --resume continues from saved settings, and --workers 1 uses one process. After the first round, run python3 -m scripts.fit_single_phase_sweep --polish to add neighboring same-level settings as initializations. single-phase-sweep-data.json stores each setting's parameters, coordinate compensation, integer radius, initializations, and final losses. Then run bun scripts/generate_single_phase_cache.ts to package shader parameters, float64 cross-sections, and errors into one compressed cache, without storing images for every setting. python3 -m unittest scripts.test_single_phase_sweep checks full spatial rendering, frequency-domain loss, and gradients. bun test content/blog/differentiable-polyphase-filtering/single-phase-response.test.ts checks all 80 reference responses, zero-scale passthrough, and agreement between the cache, source parameters, center-row samples, and errors. single-phase-image.test.ts separately checks software mirror extension, Gaussian agreement with direct 2D convolution, and preservation of the existing impulse responses and constant inputs under mirror boundaries.