Binary Spatial Feature Extractor (BSFE)

• The paper demonstrates that BSFE extracts high-order spatial features from binary CE logs, bridging fault locations with downstream temporal prediction modules.
• BSFE is a domain-specific module that leverages both 1D and 2D extraction pipelines, using reduction-then-aggregation and aggregation-then-reduction to capture sparsity, clustering, and dispersion.
• Empirical results within M²-MFP show significant improvements in fault prediction metrics, validating BSFE’s effectiveness in encoding hierarchical memory log structures.

Binary Spatial Feature Extractor (BSFE) is a spatial representation module introduced within M$^2$-MFP for memory failure prediction from Correctable Error (CE) logs. In that framework, BSFE converts binary CE representations into structured high-order descriptors that encode both where faults occur in the memory hierarchy and how they are spatially distributed, with explicit attention to sparsity, clustering, adjacency, coverage, and dispersion. The term is used explicitly in M$^2$-MFP, where BSFE functions as the bridge between hierarchical CE records and downstream temporal prediction modules; related earlier work contains BSFE-like binary spatial pipelines, but does not use the name in the same sense (Xie et al., 9 Jul 2025).

1. Definition and design criteria

BSFE is designed for CE data that contains two distinct forms of spatial information: DIMM-level spatial information—rank, device, bank, row, and column—and bit-level spatial information—the DQ/Beat error pattern in a memory access (Xie et al., 9 Jul 2025). The central premise is that these signals can be represented as binary matrices, and that useful fault signatures are not exhausted by local counts or simple rule thresholds. Instead, BSFE seeks higher-order spatial structures such as sparsity, clustering, adjacency, coverage, and dispersion.

The design criteria stated for BSFE are unusually specific. It is intended to be symmetric, so that flipping a 1D binary pattern does not change the feature; general, so that the same mechanism applies to 1D or 2D binary matrices at multiple hierarchy levels; and sensitive, so that even a single flipped bit can affect the output (Xie et al., 9 Jul 2025). The paper explicitly positions it as a custom binary-feature engine for memory CE data rather than a generic CNN replacement.

This positioning also defines the problem BSFE is meant to solve. Prior approaches are described as relying on hand-crafted DIMM-level statistics, bit-level heuristics such as Risky CE or DQ-Beat rules, or generic deep models that do not respect the hierarchical structure of memory logs. BSFE is introduced as an automatic extractor for fine-grained bit-level structures and higher-level spatial correlations across ranks, banks, and cells (Xie et al., 9 Jul 2025).

2. Binary matrix representation of CE logs

The BSFE pipeline begins by reorganizing each CE log into a hierarchy of spatial levels. The broader log structure includes a Server-level with CPU, channel, DIMM metadata, manufacturer, and frequency; a DIMM-level with rank ID, device ID, bank ID, row ID, and column ID; and a Bit-level with a decoded error pattern represented as an $8 \times 4$ DQ-Beat Matrix for x4 DDR4 chips (Xie et al., 9 Jul 2025).

At the bit level, each CE event $e$ is represented by a binary matrix $B(e)$. In the implementation details, this is instantiated as an $8 \times 4$ matrix representing the DQ-Beat pattern (Xie et al., 9 Jul 2025). At the DIMM hierarchy, each CE is mapped to a binary vector or matrix with a single active entry marking fault location. For a bank-level fault, the representation is a binary row-column occupancy map in which exactly one cell is 1; analogous constructions are used at device, rank, and DIMM levels (Xie et al., 9 Jul 2025).

For multiple CE events within an observation window, the framework aggregates same-level matrices by element-wise max, yielding multi-event spatial occupancy maps (Xie et al., 9 Jul 2025). This produces binary summaries of where activity has occurred over time without discarding spatial structure. In the paper’s terminology, the overall design is that each CE becomes a binary matrix at each hierarchy level, and multiple CEs within a time window are aggregated into multi-event binary spatial maps.

This representation choice is consequential because BSFE does not operate on raw scalar log fields. It operates on structured binary maps that preserve hierarchy. A plausible implication is that the representation itself enforces an inductive bias absent from count-only or flat feature encodings.

3. 1D-BSFE and 2D-BSFE

BSFE has two submodules: 1d-BSFE, which extracts features from a 1D binary vector, and 2d-BSFE, which extends that construction to matrices through two complementary processing orders (Xie et al., 9 Jul 2025).

For a 1D binary vector

$X^{1d} = [x_1,\ldots,x_n], \quad x_i \in \{0,1\},$

the feature output is

$$BSFE^{1d}(X^{1d}) = (\phi_1(X^{1d}),\ldots,\phi_f(X^{1d})).$$

The paper gives five concrete descriptors (Xie et al., 9 Jul 2025):

$\phi_1(X^{1d}) = \sum_{i=1}^{n} x_i$

$$\phi_2(X^{1d}) = \sum_{i=1}^{n-1} \mathbb{I}(x_i=0 \wedge x_{i+1}=1) + \mathbb{I}(x_1=1)$$

$^2$0

$^2$1

$^2$2

These descriptors are stated to model density, dispersion, clustering, and coverage (Xie et al., 9 Jul 2025). Their construction is deterministic and interpretable: element count measures occupancy, group count measures the number of contiguous runs of 1s, maximum consecutive count captures the longest run, and maximum/minimum distance characterize spread and tightness among active positions.

For a 2D binary matrix $^2$3, BSFE uses 2D-BSFE, built from 1D-BSFE through two paths (Xie et al., 9 Jul 2025).

In Reduction-then-Aggregation, BSFE first applies row-wise 1d-BSFE: $^2$4 then performs column-wise pooling over rows with an $^2$5 kernel: $^2$6 The paper notes that multiple pooling operators can be used, such as max pooling and average pooling.

In Aggregation-then-Reduction, BSFE first compresses the matrix with column-wise max pooling: $^2$7 and then applies row-wise 1d-BSFE: $^2$8

For the row-oriented case, the outputs are vectorized and concatenated: $^2$9 The paper then computes an analogous column-level 2D-BSFE by swapping row-wise and column-wise operations, and concatenates row-level and column-level results (Xie et al., 9 Jul 2025). This makes the 2D module explicitly dual-view and enforces row/column symmetry in the representation.

The dual ordering is presented as essential rather than redundant. Reduction-then-Aggregation preserves local row or column descriptors before global summarization, whereas Aggregation-then-Reduction first compresses occupancy and then extracts structure from the reduced view (Xie et al., 9 Jul 2025). This suggests that BSFE is attempting to encode both localized clusters and broader occupancy patterns within the same handcrafted feature family.

4. Integration within M$8 \times 4$0-MFP

In M$8 \times 4$1-MFP, BSFE is not a standalone predictor. It is the core spatial encoder inside a dual-path temporal framework consisting of a Time-patch scale Prediction Module and a Time-point scale Prediction Module (Xie et al., 9 Jul 2025).

In the Time-patch module, BSFE is used as a hierarchical spatial encoder called Multi-BSFE. At the bit level, each event-level DQ-Beat matrix is transformed by 2D-BSFE into a bit-level feature. At the bank level, the model combines two ingredients: the bank’s own 2D-BSFE output from the aggregated bank matrix, and a pooled summary over the bit-level features of all events in that bank (Xie et al., 9 Jul 2025). The same logic is generalized across adjacent levels: $8 \times 4$2

The paper further notes a practical simplification: over 90% of DIMMs have only a single erroneous device, rank, or DIMM within a time patch, so pooling is omitted at these low-dimensional levels and applied only at the DIMM level (Xie et al., 9 Jul 2025). The resulting Multi-BSFE outputs are concatenated with additional counting features: CE counts in the patch, number of events with DQ errors $8 \times 4$3, number of events with Beat errors $8 \times 4$4, and CE frequency. These features are then fed to a classifier such as LightGBM (Xie et al., 9 Jul 2025).

In the Time-point module, BSFE is used differently. The model extracts BSFE-derived bit-level features, trains a DIMM-centric decision tree, extracts all root-to-leaf branches that predict fault, and converts those branches into a rule base (Xie et al., 9 Jul 2025). During inference, each incoming CE record is matched against this rule base; if it satisfies any learned fault rule, the corresponding DIMM is predicted to fail.

This division of labor is important. The Time-patch path treats BSFE outputs as inputs to a statistical classifier, whereas the Time-point path uses BSFE features for interpretable rule discovery. A common misconception would be to treat BSFE as synonymous with the full prediction framework. The paper instead makes clear that BSFE is the spatial encoding core within a broader architecture that also includes temporal aggregation, count features, LightGBM classification, and a rule-generation tree (Xie et al., 9 Jul 2025).

5. Empirical evidence, ablations, and interpretability

The empirical case for BSFE is presented through the performance of M$8 \times 4$5-MFP and through ablation studies, rather than through a standalone BSFE benchmark (Xie et al., 9 Jul 2025). The paper explicitly does not isolate BSFE in a separate end-to-end comparison, so claims about BSFE’s effectiveness are mediated by the broader system.

For the Time-patch module, the reported performance is:

• Precision: 0.3446
• Recall: 0.2893
• $8 \times 4$6: 0.3145

This is reported as better than Himfp with $8 \times 4$7, STIM with $8 \times 4$8, and CNN/ViT baselines (Xie et al., 9 Jul 2025). For the Time-point module, the reported performance is:

• Precision: 0.4029
• Recall: 0.2245
• $8 \times 4$9: 0.2883

This is reported as better than Risky CE with $e$0, DQ Beat Predictor with $e$1, and CNN with $e$2 (Xie et al., 9 Jul 2025).

For the full M$e$3-MFP framework, the paper reports:

• Precision: 0.3208
• Recall: 0.3942
• $e$4: 0.3537

It states that this corresponds to about a 55% relative $e$5-score improvement over the best baseline method in offline evaluation (Xie et al., 9 Jul 2025). In Huawei Cloud production or gray-environment deployment, the paper reports $e$6 for UniMFP and $e$7 for M$e$8-MFP, a 15% relative improvement, with precision gain at high recall regimes of over 20% (Xie et al., 9 Jul 2025).

The ablation study is the most direct evidence for the BSFE design itself. In the Time-patch module, five settings are reported (Xie et al., 9 Jul 2025):

• without Reduction-then-Aggregation: 0.2979
• without Aggregation-then-Reduction: 0.2911
• without DIMM-level features: 0.2847
• without bit-level features: 0.2475
• full Time-patch BSFE: 0.3145

These results support three conclusions stated in the extracted summary: both BSFE branches matter, both DIMM-level and bit-level features matter, and removing bit-level features hurts more than removing DIMM-level features in this setup (Xie et al., 9 Jul 2025).

Interpretability evidence is also emphasized. A feature-importance plot for the Time-patch LightGBM classifier shows that both DIMM-level BSFE features and bit-level BSFE features are highly important, and that features from both Reduction-then-Aggregation and Aggregation-then-Reduction contribute significantly (Xie et al., 9 Jul 2025). The Time-point module additionally yields human-readable fault rules derived from 2D-BSFE-based features, although the textual rendering of an example rule is partially corrupted in the provided content.

6. Relation to prior binary feature extraction methods

The term Binary Spatial Feature Extractor is explicit in M$e$9-MFP, but the broader methodological pattern has antecedents in earlier work. A plausible historical framing is that BSFE formalizes a class of binary spatial feature pipelines that had previously appeared under other names and in other domains.

In texture recognition, "Binary Distance Transform to Improve Feature Extraction" proposes a preprocessing pipeline that converts a grayscale texture image into 150 binary versions, applies the Euclidean Binary Distance Transform (EDT) to each thresholded image, and combines one selected EDT-derived representation with the original image at the feature level before classification (Neiva et al., 2016). The paper does not name the method “BSFE” explicitly, but its extracted summary describes the pipeline as effectively a binary spatial feature extractor with the sequence: Binarization, Binary Euclidean Distance Transform, Fusion with original image, Descriptor extraction, and Classification (Neiva et al., 2016). Its reported gains include improvements of up to 10.15% on Outex and a best overall tendency for LBP combined with EDT (Neiva et al., 2016).

In mobile facial alignment, "Fast, Dense Feature SDM on an iPhone" introduces Binary Approximated SIFT (BASIFT) as the feature-side component of Sparse Compositional Regression (SCR) (Fagg et al., 2016). BASIFT replaces classical SIFT orientation computation with a 3-bit binary code

$B(e)$0

learns a linear approximation to SIFT, and then uses a sign-only matrix: $B(e)$1 This is a binary feature approximation rather than BSFE per se, but it shares the core idea of converting local spatial structure into cheap, sparse binary encodings for downstream prediction (Fagg et al., 2016).

In "Local Binary Pattern(LBP) Optimization for Feature Extraction", LBP is explicitly reinterpreted as a structured binary mapping over local neighborhoods and written as

$B(e)$2

The paper is described in the extracted notes as being “best understood as a reinterpretation and optimization of Local Binary Pattern (LBP) as a binary spatial feature extractor,” although the authors do not use the term BSFE (Sedaghatjoo et al., 2024). Its contribution is to optimize the fixed spatial and histogram operators with SVD, selecting discriminative LBP codes and producing improved performance in face detection and facial expression recognition, including above 99% face-vs.-clutter accuracy with 16 features or more on one setup and about 90% average accuracy on CK/CK+ versus about 87% for standard LBP (Sedaghatjoo et al., 2024).

These precedents clarify what is distinctive about BSFE in M$B(e)$3-MFP. Earlier binary-feature systems either preprocess images through thresholding and distance transforms, approximate gradient histograms through binary comparisons, or optimize local binary descriptors. BSFE, by contrast, is explicitly tailored to hierarchical memory CE logs, uses 1D and 2D binary spatial descriptors rather than learned image filters, and is integrated into both a LightGBM-based time-patch classifier and a rule-learning time-point decision tree (Xie et al., 9 Jul 2025). This suggests that BSFE is best understood not as a generic binary vision descriptor, but as a domain-specific binary spatial encoding framework for reliable cloud infrastructure.