PEdger++: Efficient Edge Detection

• PEdger++ is a binary edge detection framework that assembles cross-architecture, temporal, and parameter-sampling information for improved accuracy and efficiency.
• It employs both recurrent and non-recurrent CNN branches to robustly capture edge features while meeting stringent model-size and throughput constraints.
• Validation-weighted ensemble fusion minimizes epistemic uncertainty, enabling a single compact deployment model without sacrificing the benefits of diverse training dynamics.

Searching arXiv for PEdger++ and closely related edge-detection papers to ground the article. PEdger++ is a practical edge detection framework that predicts a dense edge probability map for each input image while explicitly targeting the accuracy–efficiency regime required for deployment across devices with different computational budgets. In its 2025 formulation, it is defined as a collaborative learning system that assembles cross information from heterogeneous architectures, diverse training moments, and multiple parameter samplings, with the stated goal of improving edge detection accuracy while reducing computational cost and model size (Fu et al., 16 Aug 2025).

1. Definition and task setting

PEdger++ addresses classical low-level edge detection. Given an image, the model estimates a pixel-wise edge confidence map in which larger values indicate higher probability of an object boundary or salient edge. The task is evaluated under the standard boundary detection protocol: edge maps are thinned by non-maximum suppression, thresholded over a range of operating points, and summarized by ODS-F and OIS-F. The framework is evaluated on BSDS500, NYUD, and Multicue, with BSDS and Multicue ground truths binarized using threshold $0.2$, and NYUD evaluated with the larger matching tolerance $0.011$ used in prior work (Fu et al., 16 Aug 2025).

The practical problem PEdger++ is organized around is not merely boundary localization, but boundary localization under stringent model-size and throughput constraints. The paper frames the central question as how to efficiently capture discriminative, robust edge features without relying on large, sophisticated models. This directly targets a long-standing tradeoff in edge detection: classical operators such as Sobel, Canny, LoG, pb/gPb-UCM, SE, and OEF are lightweight but weak on complex scenes, whereas deep methods such as HED, RCF, BDCN, LPCB, CED, EDTER, UAED, MuGE, DiffusionEdge, and SAUGE are accurate but typically much larger and slower (Fu et al., 16 Aug 2025).

A central conceptual point in PEdger++ is that standard deterministic training ignores epistemic uncertainty in model parameters. The framework therefore treats diversity across architectures, epochs, and parameter samplings as a resource rather than a by-product. This suggests a shift from single-network optimization toward an explicitly ensemble-based formulation, but one whose final deployment model remains a single compact network.

2. Lineage, nomenclature, and related uses of “PED”

PEdger++ is the direct successor to PEdger, which introduced a robust collaborative learning framework based on two lightweight CNNs, momentum-style temporal aggregation, and uncertainty-aware fusion of recurrent and non-recurrent predictions. In that earlier formulation, the key mechanism was the progressive replacement of noisy labels with soft labels produced by heterogeneous models across training moments, without relying on pre-training on extra data (Fu et al., 2023).

PEdger++ extends that design by adding a third source of diversity: multiple parameter samplings interpreted from a Bayesian perspective. Relative to PEdger, the newer framework retains heterogeneous recurrent and non-recurrent CNNs, momentum networks, and confidence-aware soft-target generation, but augments them with sampled momentum-network parameters and validation-weighted ensemble fusion (Fu et al., 16 Aug 2025). In this sense, PEdger++ is best understood as a broader collaborative system that unifies architectural diversity, temporal diversity, and parameter-space diversity.

The name can be confused with other arXiv uses of the acronym PED. In "Panoptic Edge Detection," PED denotes a different task: semantic-level boundaries for stuff categories together with instance-level boundaries for instance categories, evaluated by the panoptic dual F-measure $F^2$ (Hu et al., 2019). In "DETR for Crowd Pedestrian Detection," PED instead denotes Pedestrian End-to-end Detector, a transformer-based pedestrian detector for crowded scenes (Lin et al., 2020). PEdger++ is unrelated to either usage: it is an efficient binary edge detector rather than a panoptic boundary model or a pedestrian detector.

3. Network architecture and model variants

PEdger++ uses two CNN architectures during training.

The first is a recurrent architecture $\mathcal{G}^R$. It consists of an encoding module followed by a recurrent module with shared parameters across $T=5$ steps, max-pooling at steps $t>1$, and a bi-directional decoding module. The decoding stage aggregates features in both fine-to-coarse and coarse-to-fine directions, producing side outputs at each step and a final fused edge map through a $1\times1$ convolution and sigmoid. Parameter sharing across recurrent steps allows more channels without a corresponding parameter blow-up, and the paper characterizes this branch as slower but useful as a collaborative partner (Fu et al., 16 Aug 2025).

The second is a non-recurrent architecture $\mathcal{G}^{NR}$, which is the deployment model. It uses $T=4$ stages with scale-specific parameters, again followed by bi-directional decoding and final fusion. Its key design choice is that channel count increases as spatial resolution decreases, allocating more capacity to later semantic stages while controlling compute. The framework also omits BatchNorm and instead uses adaptive gradient clipping, described as clipping based on gradient norm versus parameter norm, to reduce runtime overhead and memory (Fu et al., 16 Aug 2025).

For the recurrent decoder, the side features obey

$$\mathbf{F}_{n}^{f2c(t)} = \begin{cases} \mathbf{Z}_n^{f2c(t)}, & t=1, \ \mathbf{Z}_n^{f2c(t)} + \text{Down}\!\left(\mathbf{F}_{n}^{f2c(t-1)}\right), & t>1, \end{cases}$$

and

$0.011$0

All fine-to-coarse and coarse-to-fine outputs are concatenated and fused into the final prediction. The non-recurrent branch mirrors the same bi-directional principle across scales rather than recurrent steps (Fu et al., 16 Aug 2025).

The paper defines several size variants by adjusting depth and channels. The reported parameter counts are approximately 315–317K for Tiny, 487–496K for Small, 716–734K for Normal, and 4.0M–4.3M for Large. It also reports pre-trained variants in which the non-recurrent encoding module is replaced by the first four stages of VGG16 or ResNet50. Because the recurrent architecture does not match standard backbone structure, the pre-trained setting uses two non-recurrent architectures rather than a recurrent/non-recurrent pair (Fu et al., 16 Aug 2025).

4. Assembling cross information

The defining mechanism of PEdger++ is the assembly of three forms of cross information.

Cross-architecture information comes from jointly training recurrent and non-recurrent networks. Their predictions are fused in a confidence-aware way so that, pixel by pixel, predictions farther from $0.011$1 receive larger weight. For a training sample, the architecture-level fusion is

$0.011$2

This preserves the uncertainty-aware idea already present in PEdger, where distance from $0.011$3 functions as a per-pixel confidence proxy (Fu et al., 16 Aug 2025, Fu et al., 2023).

Cross-training-moment information is captured by momentum networks. For each architecture, momentum parameters are updated across epochs according to

$0.011$4

with $0.011$5. The momentum model is therefore an exponential moving average over epochs, intended to aggregate broader early features and more specialized later features into a smoother representation (Fu et al., 16 Aug 2025).

Cross-parameter-sampling information is the new ingredient. Parameters are treated as random variables with posterior $0.011$6, approximated by drawing multiple samples from the momentum networks. In the main formulation this is done with Monte Carlo Dropout; in the efficient variant, by random weight pruning. With $0.011$7 samples in the best setting, each architecture produces an ensemble prediction

$0.011$8

where the pixel-wise weights $0.011$9 and $F^2$0 are optimized on a held-out validation set (Fu et al., 16 Aug 2025).

These ensemble predictions are converted into soft targets by linear interpolation with the original labels: $F^2$1 Thus early epochs remain label-dominated, whereas later epochs increasingly trust the ensemble. The loss for each output is a weighted binary cross-entropy with adaptive coefficients

$F^2$2

$F^2$3

with $F^2$4 for BSDS and Multicue and $F^2$5 for NYUD (Fu et al., 16 Aug 2025).

A distinctive theoretical claim in the paper is that the validation-set weighting of parameter samples is equivalent, under the BCE model, to maximizing the mutual information $F^2$6 between the ensemble weights and the labels. The intended consequence is that sample weighting is not merely heuristic model averaging, but a validation-grounded mechanism for reducing epistemic uncertainty (Fu et al., 16 Aug 2025).

5. Training, inference, and deployment regime

Training uses SGD with momentum $F^2$7 and weight decay $F^2$8. The learning rate is warmed up for the first four epochs to a peak of $F^2$9, then linearly decayed. Batch size is 16, implemented with gradient accumulation because of variable image sizes. Data augmentation includes random brightness, contrast, saturation, and hue changes between 50\%–150\% of the original values, plus grayscale conversion with probability 0.2 (Fu et al., 16 Aug 2025).

The framework explicitly separates training-time complexity from test-time simplicity. During training, both back-propagation networks, both momentum networks, and multiple sampled parameter sets are involved. During testing, only the non-recurrent network is retained, and even that network uses a single parameter vector computed as a weighted average of the sampled parameters: $\mathcal{G}^R$0 This is a compact distillation of the sampled ensemble into one deployment model (Fu et al., 16 Aug 2025).

The paper also provides an efficient collaborative variant. This version removes the recurrent branch, uses only the non-recurrent back-propagation and momentum networks, and realizes diversity through stochastic weight pruning rather than recurrent/non-recurrent heterogeneity. The reported effect is a training-time reduction of roughly 35–45\%, or about 40\%, with only a small drop of approximately 0.3–0.6\% ODS-F (Fu et al., 16 Aug 2025).

At inference, the output edge map is post-processed with non-maximum suppression. The paper also replaces the standard sigmoid by a sharper activation centered at $\mathcal{G}^R$1,

$\mathcal{G}^R$2

and evaluates either single-scale or multi-scale testing. The reported fixed-size examples are 320×480 for BSDS and 500×500 for NYUD in single-scale mode (Fu et al., 16 Aug 2025).

Variant	Parameters	Representative BSDS w/ VOC result
PEdger++ Tiny	~315–317K	ODS-F $\mathcal{G}^R$3
PEdger++ Small	~487–496K	intermediate setting
PEdger++	716K	0.835 ODS-F, 92 FPS
PEdger++Large	4.3M	0.848 ODS-F, 48.5 FPS
PEdger++Large w/ ResNet50	12.7M	0.857 ODS-F, 37.6 FPS

The variant table illustrates the paper’s deployment logic: a single algorithmic framework is exposed through a family of parameter budgets rather than a single fixed model. A plausible implication is that PEdger++ treats architecture scaling as an integral part of the method rather than as a post hoc engineering detail.

6. Empirical performance, interpretation, and limitations

On BSDS w/o VOC, the non-pretrained base PEdger++ reports 0.830 ODS-F, 0.846 OIS-F, 92 FPS, and 716K parameters, versus 0.807 / 0.823, 76 FPS, and 710K for PiDiNet, and 0.813 / 0.834, 71 FPS, and 734K for PEdger. The Large non-pretrained variant reaches 0.841 / 0.852 at 48.5 FPS. With pre-training, PEdger++Large w/ ResNet50 reaches 0.847 / 0.856 and 37.6 FPS, while MuGE (M=11) is listed at 0.850 / 0.856 and 3.2 FPS (Fu et al., 16 Aug 2025).

On BSDS w/ VOC, the base non-pretrained PEdger++ reports 0.835 ODS-F, 0.850 OIS-F, and 92 FPS, while PEdger++Large reaches 0.848 / 0.859 at 48.5 FPS. The strongest pre-trained entry, PEdger++Large w/ ResNet50, reports 0.857 ODS-F, 0.861 OIS-F, and 37.6 FPS. In the same table, MuGE (M=11) reports 0.855 / 0.860 and 3.2 FPS, so the paper presents PEdger++Large w/ ResNet50 as matching or exceeding that accuracy with more than ten times the speed (Fu et al., 16 Aug 2025).

Under multi-scale testing on BSDS with VOC, PEdger++Large w/ ResNet50-MS reaches 0.862 ODS-F and 0.871 OIS-F at 11.6 FPS, compared with 0.861 / 0.867 and 1.2 FPS for MuGE (M=11)-MS. On NYUD, the base PEdger++ reports 0.765 ODS-F, 0.769 OIS-F, and 88 FPS, improving over PEdger’s 0.742 / 0.757 and PiDiNet’s 0.733 / 0.747. On Multicue, PEdger++ reports 0.901 / 0.903 for edge detection and 0.866 / 0.874 for boundary detection, while PEdger++Large w/ ResNet50 reaches 0.911 / 0.916 and 0.878 / 0.884, respectively (Fu et al., 16 Aug 2025).

The ablations are central to the paper’s interpretation of why the method works. On BSDS with VOC and pre-training, the single non-recurrent baseline is 0.820 ODS-F. Adding only structures, only training moments, or only parameter sampling yields 0.837, 0.836, and 0.835, respectively, while the full cross-information design reaches 0.846. Likewise, validation-weighted sample fusion outperforms simple addition, best-single-sample selection by cross-entropy, and confidence-based selection, with 0.846 versus 0.831, 0.835, and 0.833 (Fu et al., 16 Aug 2025). This supports the paper’s claim that PEdger++ is not reducible to any one source of diversity taken in isolation.

The framework’s limitations are also explicit. Training is more complex than standard single-model optimization because it uses multiple networks, momentum models, parameter sampling, and validation-based weighting. The recurrent architecture is discarded at inference, so part of the training computation is intentionally expendable. The method targets binary edge detection rather than semantic edge detection, and its sample weighting depends on the quality of the validation split (Fu et al., 16 Aug 2025). The authors suggest extensions to semantic segmentation, depth estimation, saliency detection, joint semantic edge detection, tiny-device adaptation, and richer uncertainty models; these are stated as future directions rather than demonstrated capabilities.

In the current literature context, PEdger++ occupies a specific methodological niche. Relative to PEdger, it broadens collaborative learning into a three-source ensemble framework (Fu et al., 2023). Relative to heavy edge detectors such as EDTER, UAED, MuGE, DiffusionEdge, and SAUGE, it prioritizes the accuracy–speed–size frontier rather than absolute model scale (Fu et al., 16 Aug 2025). Relative to other “PED” works in arXiv nomenclature, it belongs to practical binary edge detection rather than panoptic boundary prediction or pedestrian detection (Hu et al., 2019, Lin et al., 2020). Its distinctive contribution is therefore not a new boundary taxonomy, but a deployment-oriented reorganization of ensemble and Bayesian ideas into a compact edge detector.