Local Pixel Dependencies (LPD)

• Local Pixel Dependencies (LPD) are defined as spatially local relationships among pixels, modeled through conditional probabilities, differential structures, or residual mappings.
• They are crucial across applications such as dense prediction, segmentation, generative modeling, dynamic texture analysis, and forensic detection by preserving fine image details.
• Recent research integrates LPD with hybrid CNN-transformer architectures and state-space models to dynamically adapt receptive fields and improve both accuracy and computational efficiency.

Local pixel dependencies (LPD) denote the spatially local relationships among neighboring pixels or small regions, and they are treated as a central modeling primitive in dense prediction, segmentation, generative modeling, dynamic texture analysis, and pixel-level distributed inference. Recent work consistently frames LPD against the complementary problem of long-range dependency modeling: CNNs preserve local pixel correlations through localized convolutional operations, local receptive fields, and weight sharing, whereas transformers and state-space models are introduced to capture broader semantic or geometric context and therefore require explicit mechanisms to prevent loss of local detail (Yang et al., 2021, Qiu et al., 2024, Ma et al., 6 Jan 2025).

1. Formal definitions and mathematical viewpoints

One explicit probabilistic definition appears in synthetic image detection, where LPD is grounded in the Markov Random Field assumption that a pixel’s value depends only on its local neighborhood. For a pixel at position $(i,j)$,

$$P(x_{i,j} \mid x_{k,l}, (k,l) \neq (i,j)) = P(x_{i,j} \mid x_{k,l}, (k,l) \in \mathcal{N}_{i,j}),$$

with $\mathcal{N}_{i,j}$ defined within an $n \times n$ window centered on $(i,j)$, typically $n=3$. In that formulation, each pixel can be reconstructed from neighboring values by a zero-masked median,

$$y_{i,j} = \mathrm{Median}(x_{k,l}, (k,l) \in \mathcal{N}'_{i,j}),$$

and the resulting feature map is the residual

$\mathrm{LPD} = I - I',$

which highlights disruptions in texture continuity, edge coherence, and color transitions (Liang et al., 25 Sep 2025).

A second viewpoint treats LPD as local differential structure. In Local Higher-Order Statistics, a $3 \times 3$ neighborhood is written as $v^n = (v_c, v_1,\ldots,v_8)$ and then converted into a gray-level-shift-invariant local differential vector

$$P(x_{i,j} \mid x_{k,l}, (k,l) \neq (i,j)) = P(x_{i,j} \mid x_{k,l}, (k,l) \in \mathcal{N}_{i,j}),$$0

This retains continuous-valued, non-binarized differential patterns rather than thresholded codes, and thereby generalizes LBP/LTP-style local pattern modeling (Sharma et al., 2015).

A third formulation extends LPD into space-time. In LP$$P(x_{i,j} \mid x_{k,l}, (k,l) \neq (i,j)) = P(x_{i,j} \mid x_{k,l}, (k,l) \in \mathcal{N}_{i,j}),$$1DH, dynamic texture is represented by a Pixel-Difference Vector

$$P(x_{i,j} \mid x_{k,l}, (k,l) \neq (i,j)) = P(x_{i,j} \mid x_{k,l}, (k,l) \in \mathcal{N}_{i,j}),$$2

where $$P(x_{i,j} \mid x_{k,l}, (k,l) \neq (i,j)) = P(x_{i,j} \mid x_{k,l}, (k,l) \in \mathcal{N}_{i,j}),$$3 for a cubic $$P(x_{i,j} \mid x_{k,l}, (k,l) \neq (i,j)) = P(x_{i,j} \mid x_{k,l}, (k,l) \in \mathcal{N}_{i,j}),$$4 spatiotemporal neighborhood. Here the dependency is not only spatial but also temporal, and the descriptor is designed to preserve the local structure of these PDVs under binary hashing (Ding et al., 17 Apr 2026).

These formulations show that LPD is not restricted to one architecture or one loss. It can be expressed as conditional dependence, local residual structure, differential statistics, or locality-preserving embeddings. This suggests that LPD is best understood as a family of constraints on neighborhood structure rather than a single canonical representation.

2. Statistical descriptors and locality-preserving embeddings

Before recent hybrid transformer-CNN designs, LPD was already used as a basis for compact image descriptors. Local Higher-Order Statistics replaces hard, hand-set quantization with a Gaussian Mixture Model,

$$P(x_{i,j} \mid x_{k,l}, (k,l) \neq (i,j)) = P(x_{i,j} \mid x_{k,l}, (k,l) \in \mathcal{N}_{i,j}),$$5

followed by Fisher score aggregation,

$$P(x_{i,j} \mid x_{k,l}, (k,l) \neq (i,j)) = P(x_{i,j} \mid x_{k,l}, (k,l) \in \mathcal{N}_{i,j}),$$6

The representation is then power-normalized and $$P(x_{i,j} \mid x_{k,l}, (k,l) \neq (i,j)) = P(x_{i,j} \mid x_{k,l}, (k,l) \in \mathcal{N}_{i,j}),$$7-normalized. In the reported experiments, LHS achieved 99.5% on Brodatz-32, 73.4% on LFW in the unsupervised setting, and up to 88.3% with discriminative metric learning in the supervised setting; it was also reported as 6–38$$P(x_{i,j} \mid x_{k,l}, (k,l) \neq (i,j)) = P(x_{i,j} \mid x_{k,l}, (k,l) \in \mathcal{N}_{i,j}),$$8 more compact and 100–185$$P(x_{i,j} \mid x_{k,l}, (k,l) \neq (i,j)) = P(x_{i,j} \mid x_{k,l}, (k,l) \in \mathcal{N}_{i,j}),$$9 faster than SIFT-FV in the compared configuration (Sharma et al., 2015).

LP$\mathcal{N}_{i,j}$0DH applies the same locality principle to dynamic textures by learning a binary embedding

$\mathcal{N}_{i,j}$1

while explicitly constraining locality preservation through

$\mathcal{N}_{i,j}$2

Its full objective combines quantization, entropy, variance, and locality,

$\mathcal{N}_{i,j}$3

under the orthogonality constraint $\mathcal{N}_{i,j}$4, optimized on the Stiefel manifold with a curvilinear search strategy. The method reported 99.80% on UCLA, 98.52% on DynTex++, and 96.19% on YUPENN (Ding et al., 17 Apr 2026).

In both cases, LPD is not merely a preprocessing heuristic. It is the object of representation learning itself: the statistics of local neighborhoods are encoded, aggregated, and preserved across compression. The historical significance of these methods lies in showing that strong local structure can remain highly discriminative even without global-image modeling.

3. Preservation of LPD in dense prediction and segmentation

In continuous pixel-wise prediction, TransDepth was introduced as a hybrid architecture combining a ResNet backbone with transformer blocks and an Attention Gate Decoder (AGD). The ResNet stage preserves rich local pixel correlations before the transformer layers enhance long-range semantic relationships. AGD receives multi-scale decoder features $\mathcal{N}_{i,j}$5 and replaces simple concatenation or averaging with adaptive, content-dependent gating. Its integrated attention fusion is written as

$\mathcal{N}_{i,j}$6

and the final output concatenates locally aware, attention-weighted features from multiple scales. The paper reports that this was the first transformer application to pixel-wise prediction problems involving continuous labels, namely monocular depth prediction and surface normal estimation. The full model achieved $\mathcal{N}_{i,j}$7 on KITTI and $\mathcal{N}_{i,j}$8 on NYU Depth, while attention visualizations after AGD were reported to respond strongly to local structures (Yang et al., 2021).

PARF-Net addresses a different failure mode: fixed receptive fields. Its Conv-PARF module applies multiple convolution filters with different kernel sizes, such as $\mathcal{N}_{i,j}$9, $n \times n$0, and $n \times n$1, computes a spatial attention map for each scale, and fuses them pixelwise by

$n \times n$2

The paper states that Conv-PARF dynamically adjusts convolutional receptive fields for each pixel to cope with inter-pixel semantic heterogeneity. The best setting used kernel sizes $n \times n$3, and the reported Synapse result was 84.27% mean Dice, with a pancreas Dice of 72.86 versus 68.54 for the best baseline (Ma et al., 6 Jan 2025).

CrackSCF targets structural crack segmentation under a low-compute regime. Its LRDS block replaces standard convolutions with a Reduce-Depthwise-Pointwise-Expand structure, where depthwise convolution captures local spatial relationships and pointwise convolution mixes channels. Local and long-range features are fused in the staircase cascaded fusion module through pixel attention,

$n \times n$4

On the TUT dataset, the reported F1 and mIoU were 0.8382 and 0.8473, respectively. The LRDS variant achieved these scores with 9.26G FLOPs, 4.79M parameters, and 36 FPS, outperforming the compared Orig, DS, and LR versions in the ablation table (Liu et al., 2024).

Taken together, these studies make a consistent architectural claim: LPD is not automatically preserved when global-context modules are added. It has to be reintroduced by gated multiscale fusion, pixel-wise adaptive receptive fields, or lightweight local convolutions.

4. Hierarchical local inductive bias at gigapixel scale

Whole slide images intensify the LPD problem because they are often over $n \times n$5 pixels and densely packed with cells, vessels, and other small tissue features. Pixel-Mamba addresses this by directly tokenizing each pixel into $n \times n$6 tokens,

$n \times n$7

and preserving local spatial adjacency through a region-based zigzag scan. Its core mechanism is Progressive Token Expansion, which repeatedly aggregates neighboring pixels in a CNN-analogous hierarchy, expanding the receptive field from $n \times n$8 up to $n \times n$9 across a 24-layer network (Qiu et al., 2024).

After each expansion stage, Pixel-Mamba applies a bi-directional state-space model,

$(i,j)$0

where forward and backward Mamba modules allow information flow in both sequence directions. The paper emphasizes linear memory and compute, arguing that this makes end-to-end training on full slides feasible. It further reports that Pixel-Mamba achieves or even surpasses the quantitative performance of state-of-the-art foundation models pretrained on millions of WSIs or WSI-text pairs, even without requiring any pathology-specific pretraining (Qiu et al., 2024).

This line of work makes the local-global tradeoff explicit. Locality is not handled by a fixed early-stage CNN and then abandoned; it is progressively enlarged and carried through the network. A plausible implication is that, at gigapixel scale, preserving LPD requires not only local operators but also a schedule by which local neighborhoods are grown into region-level context without destroying adjacency information.

5. LPD in pixel-space generation, parallel decoding, and forensic analysis

Recent pixel-space generative models treat LPD as the missing ingredient in large-patch or latent abstractions. PixelDiT eliminates the autoencoder and learns diffusion directly in pixel space through a dual-level design: a patch-level DiT captures global semantics and a pixel-level DiT refines texture details. Two mechanisms are central. First, pixel-wise AdaLN modulation assigns each pixel token its own modulation parameters,

$(i,j)$1

with $(i,j)$2 partitioned into pixel-wise normalization and modulation parameters. Second, pixel token compaction compresses the $(i,j)$3 pixels of each patch before attention and expands them afterward. The model is trained with the Rectified Flow velocity-matching loss,

$(i,j)$4

Reported results include 1.61 FID on ImageNet $(i,j)$5, 0.74 on GenEval, and 83.5 on DPG-bench (Yu et al., 25 Nov 2025).

DiP reaches a similar conclusion by different means. Its Diffusion Transformer backbone operates on large non-overlapping patches for global structure, while a co-trained lightweight Patch Detailer Head, implemented as a shallow convolutional U-Net, restores fine-grained local details inside each patch using both noisy patch input and global context. The paper reports an 1.90 FID score on ImageNet $(i,j)$6, up to $(i,j)$7 faster inference speeds than the previous method, and only 0.3% increase in total parameters (Chen et al., 24 Nov 2025).

Autoregressive image generation introduces a distinct version of the same dependency structure. Locality-aware Parallel Decoding argues, on the basis of Per-Token Attention,

$(i,j)$8

that attention is predominantly concentrated on spatially nearby tokens. It therefore combines learnable position query tokens, mutual visibility among concurrently generated tokens, and a locality-aware generation ordering that seeks to maximize proximity to previous context while minimizing mutual proximity within a parallel group. The reported effect is a reduction of generation steps from 256 to 20 at $(i,j)$9 resolution and from 1024 to 48 at $n=3$0, with at least $n=3$1 lower latency than previous parallelized autoregressive models (Zhang et al., 2 Jul 2025).

Forensic detection uses LPD in nearly the opposite direction: not to synthesize detail but to expose where synthetic models violate natural local structure. FerretNet reconstructs each pixel from its neighborhood median with center-pixel zero-masking and feeds the residual LPD map into a 1.1M-parameter CNN with Ferret Blocks. Trained exclusively on the 4-class ProGAN dataset, it achieved an average accuracy of 97.1% and a mean average precision of 99.6% on an open-world benchmark comprising across 22 generative models. The paper also reports a +10.2% average accuracy gain when using the LPD map rather than the raw image, and identifies the $n=3$2 neighborhood as most effective (Liang et al., 25 Sep 2025).

Across generation and detection, the same pattern recurs. Fine-grained texture, sharp boundaries, and local consistency are treated as information that coarse tokens, large patches, or latent bottlenecks either erase or fail to constrain.

6. Distributed pixel-level inference and terminological scope

PixVOD extends LPD beyond feature extraction into optimization itself. It assumes an on-sensor vision device in which each image pixel is paired with a dedicated, locally connected processor capable of only local memory access and message exchange with its neighbors. Visual odometry and dense depth are formulated as a Gaussian factor graph in which each pixel maintains a local copy of camera pose and a per-pixel log-depth estimate. The local photometric factor is

$n=3$3

camera-motion consensus is enforced by identity factors,

$n=3$4

and neighboring depths are regularized by normal integration factors derived from a surface normal prior. Optimization proceeds through hierarchical Gaussian Belief Propagation, and a keyframe anchoring strategy is introduced to maintain an effective and stable baseline. The paper states that computational cost per pixel is low enough to allow real-time processing on existing or near-future pixel processor array chips (Kim et al., 2 Jun 2026).

A recurring misconception is that the acronym “LPD” always denotes local pixel dependencies. In current literature it is overloaded. “Locality-aware Parallel Decoding” is abbreviated LPD in autoregressive image generation (Zhang et al., 2 Jul 2025), and “Low-energy Polarization Detector” is abbreviated LPD in the POLAR-2 instrumentation context. In the latter case, Topmetal-L is a dedicated charge-sensitive pixel sensor fabricated in a 130 nm CMOS process, integrating a $n=3$5 array with 45 $n=3$6m pitch, an average equivalent noise charge of approximately 22.8 $n=3$7, and a sentinel-scanning readout scheme that reduces full-frame readout time to 730 $n=3$8s (Xie et al., 13 Nov 2025). These usages are terminologically adjacent but conceptually distinct from local pixel dependencies as a modeling principle.

The broader literature therefore uses LPD in two senses: as a specific acronym in unrelated subfields, and as a recurring technical concept for neighborhood-structured image modeling. Within the second sense, the unifying theme is that preserving or exploiting local neighborhood structure remains necessary even in systems dominated by transformers, state-space models, diffusion backbones, or distributed optimization.