Surrogate-Based Optimization of Interpretable Regular Expression Patterns for the Classification of Retinal Lesions in Retinal Fundus Images

Abstract

The correct classification of retinal lesions in retinal fundus images is important for supporting the analysis of diabetic retinopathy and age-related macular degeneration. State-of-the-art methods for this task are often based on black-box deep learning architectures that, despite their high performance, pose significant interpretability challenges, incur high computational costs, and lack computational interpretability at the feature-decision level. In this paper, a method based on surrogate-optimized features extracted by regular expressions is proposed for the classification of two retinal lesion categories (Drusen and Cotton Wool Spots). The method uses a compact and computationally interpretable row-by-row and column-by-column regular expression feature extractor together with a two-phase surrogate search over its discrete hyperparameters. Across 100 independent stratified executions under the repeated patch-level benchmark, the proposed method achieved a mean MCC of $0.7829\pm 0.0448$, a mean accuracy of $0.9008\pm 0.0217$, and a mean F1 score of $0.8529\pm 0.0294$. The best execution reached an MCC of $0.8433$, an accuracy of $0.9286$, and a macro F1 score of $0.8966$, which was the highest result among the evaluated baselines within that same benchmark. Additional source–image disjoint grouped analyses were carried out as leakage-aware robustness checks under stricter source–image separation and to examine validation overfitting. Together, these analyses support the usefulness of the compact run-based descriptor under the present experimental conditions, while indicating that the two-phase search should be interpreted as a practical hyperparameter selection heuristic rather than as a statistically superior search strategy.

1. Introduction

In retinal fundus analysis, disease entities and localized lesion findings should be distinguished carefully. Diabetic retinopathy and age-related macular degeneration are disease contexts, whereas Cotton Wool Spots and Drusen are retinal lesions or imaging findings that may appear within those contexts. The task studied in this paper is not the direct diagnosis of macular edema or age-related macular degeneration from a full fundus image; rather, it is a binary patch-level discrimination between two annotated retinal lesion categories [1,2].

Cotton Wool Spots are superficial retinal lesions associated with focal nerve fiber layer ischemia and are commonly reported in diabetic retinopathy and other vascular disorders. In contrast, macular edema is defined more specifically by retinal thickening or fluid accumulation, often assessed with multimodal imaging. For this reason, Cotton Wool Spots should not be treated as synonyms of macular edema, even though both may appear in related clinical settings [3,4,5,6,7,8,9,10,11,12,13,14,15,16].

Drusen, in turn, are extracellular deposits located between the retinal pigment epithelium and Bruch membrane and are imaging findings classically associated with age-related macular degeneration. Their detection remains challenging because the deposits may be small, their local appearance can overlap with surrounding retinal structures, and their clinical interpretation depends on size, distribution, and broader fundus context [17,18].

Accordingly, this work focuses on two lesion categories frequently identified in the annotated material provided by the High-Specialty Medical Unit (UMAE) of the Mexican Social Security Institute (IMSS): Cotton Wool Spots and Drusen. Figure 1 provides the anatomical reference used to situate these lesion patches within the retinal field, although the classifier itself operates only on the local $32\times 32$ patch content.

Full clinical interpretation still requires patient history, multimodal imaging, and spatial context beyond the local patch. The present method does not attempt to replace that full diagnostic reasoning. Instead, it aims for computational interpretability: the prediction can be traced to an explicit thresholding rule, run-length constraints, and a linear decision function defined on a compact descriptor.

Among methods that use annotated data, recent studies have focused mainly on CNN-based architectures for segmenting microaneurysms, exudates, hemorrhages, and other retinal structures in RFI [19,20,21,22]. In these systems, preprocessing is important because it can improve color normalization and reduce noise. Some approaches use multistage CNN pipelines that classify pixels as lesion or non-lesion, with good performance for certain lesion types but nontrivial computational cost. Other CNN-based methods address limited annotation through transfer learning [23], Glowworm Swarm Optimization for parameter tuning [24], or combinations of filtering with conventional segmentation methods such as the Hough transform and Gabor filters [25,26]. Another line of work uses stochastic networks as unsupervised backbones, including Deep Belief Networks [27] and Convolutional Deep Belief Networks [28].

The approach proposed in this paper, however, is based on regular expressions applied as structural descriptors over binarized image patches, combined with surrogate optimization for hyperparameter selection and ridge classification. Regular expressions have been used in text processing and information extraction for the identification and retrieval of relevant data from structured and unstructured sources. In the domain of image data, for instance, genetic algorithms have been applied to the automatic generation of regular expressions for extracting relevant image content from web pages [29]. In other intelligent monitoring domains, compact computationally interpretable pipelines based on explicit signal processing components have also been used when robustness and efficient deployment are important [30]. In this work, the structural patterns captured by regular expressions are exploited at the pixel level to distinguish between lesion classes in low-resolution retinal patches. The goal of this article is to present a method that converts retinal patches into binary fields and then extracts run-length statistics through regular expression-based constraints, producing a computationally interpretable and compact 32-dimensional descriptor whose hyperparameters are selected by a two-phase surrogate search. The main contributions are: (i) a run-based feature extraction scheme driven by regular expression constraints that produces a fixed, computationally interpretable descriptor from binarized retinal patches; (ii) a two-phase surrogate optimization strategy designed to explore stable regions of the discrete search space, together with robustness analyses that compare it against one-phase TPE and random search under grouped validation; and (iii) a leakage-aware source–image disjoint evaluation showing that the proposed descriptor remains informative on a specialist-annotated low-resolution dataset under stricter grouped protocols.

The remainder of this paper is organized as follows. Section 2 describes the database properties and the methodological background. Section 3 presents the proposed method. Section 4 reports the experimental results and discussion. Section 5 presents the conclusions and discusses directions for future work.

2. Database and Methodological Background

This section describes the database, the acquisition and annotation procedures, and the main methodological elements of the proposed pipeline. The composition of the dataset, the criteria followed for expert annotation, and the visual characteristics that make the classification problem difficult at the patch level are presented first. The methodological components are then introduced in the order in which they appear in the pipeline.

2.1. Retinal Lesion Patch Database

All labels were produced by Dr. Gloria P. Trujillo Sánchez, an ophthalmology specialist in the Department of Ophthalmology at the Mexican Institute of Social Security, IMSS T1 León. The database contains RGB retinal fundus images of size $400\times 600$ from 18 patients with Drusen and 31 patients with Cotton Wool Spots. Specialist annotations of size $32\times 32$ pixels yield 211 image patches: 70 Cotton Wool Spots and 141 Drusen. Therefore, the resulting dataset defines a two-class patch-level retinal lesion classification problem with a moderate class imbalance in favor of Drusen.

In the context of the complete database, Cotton Wool Spots and Drusen correspond to the two lesion classes with the lowest representation. This reduced number of annotated samples is relevant from a methodological point of view, since it limits the amount of training information available for both categories and increases the difficulty of learning stable decision boundaries at the patch level. Consequently, the classification task must be addressed under conditions of limited sample support, particularly in the case of Cotton Wool Spots.

Figure 2 shows a sample set from each class in the database. It highlights why patch-level classification is difficult in this dataset. The classes often share color and intensity, and the morphological differences are subtle. Individual patches may also contain vessels and other anatomical structures. For this reason, the classification must rely on fine structural differences rather than on gross tonal contrast. In addition, the reduced spatial support of the patches limits the amount of contextual information available to the classifier, which increases the difficulty of the discrimination task. As may be observed, the overlap between classes is not restricted to chromatic information alone, but also involves similarities in local appearance, texture, and brightness patterns. These characteristics indicate that successful classification depends on the ability to capture subtle structural evidence at a local scale.

Figure 3 shows the spatial distribution of the annotated lesion patches across the retinal fundus images. Each map accumulates patch positions from the full database, so warmer regions indicate higher annotation frequency. Cotton Wool Spots appear more often in peripheral regions, whereas Drusen are concentrated closer to the central area. The physiological basis of this spatial pattern is not examined here. The maps are included to show how the annotated lesions are distributed over the retinal field and to confirm that the two lesion categories occupy different regions, a property of the database that is worth noting even though spatial location is not used as a feature in the present work.

Most publicly available retinal datasets focus on severity grading of diabetic retinopathy or age-related macular degeneration over full fundus images, or on pixel-wise detection and segmentation of individual lesion types. To the best of the authors’ knowledge, none of them defines a two-class patch-level classification task that isolates Cotton Wool Spots and Drusen as the target categories at this resolution. Because no external benchmark with this exact class definition and data regime is available, a direct comparison against previously published results on other datasets is not feasible. The comparative analysis in Section 4.2 addresses this by training and evaluating all baselines on the present dataset under the same protocol, with evaluation conditions adapted to each model family: deep architectures received data augmentation and standard training schedules, tree-based and linear classifiers operated on the features defined by each method, and handcrafted descriptors were paired with the same ridge classifier used by the proposed pipeline. This design ensures that the comparison reflects the specific combination of pathologies, resolution, and sample size that define the problem.

2.2. Methods

Low-resolution retinal patches are difficult to classify because the lesion classes often share color and intensity and are affected by noise, acquisition artifacts, and nearby anatomical structures. Under these conditions, structural descriptors may be more useful than descriptors based only on local photometric statistics. A similar difficulty was reported in recent retinal patch-classification work, where ambiguity between classes was attributed to the similarity of low-level features [28]. For this reason, the proposed method uses regular expressions as structural descriptors applied to binarized image patches. The regular expressions define minimum-length constraints on contiguous runs of ones and zeros, and the resulting run-length statistics capture continuity, fragmentation, and spatial extent at the row and column level.

The method begins with a controlled binarization step so that the subsequent analysis focuses on support, continuity, and fragmentation rather than on absolute intensity values. The main components are percentile thresholding, run-constrained binary patterns extracted through regular expression constraints, surrogate optimization for hyperparameter selection, and ridge regularization. A graphical overview of the pipeline is provided in Figure 4, and the full algorithm is given in Section 3.

2.2.1. Percentile Thresholding as a Controlled Binarization Rule

Let $A\in {\{0,\dots ,255\}}^{H\times W\times 3}$ denote an RGB patch. From A, a single intensity field $X\in {\mathbb{R}}^{H\times W}$ is derived through a luminance mapping. Given X, the binarization rule defines a threshold $\tau$ and the corresponding binary mask $B\in {\{0,1\}}^{H\times W}$. At the formal level, percentile thresholding defines $\tau$ through order statistics within the patch. Let $\mathrm{vec}\left(X\right)\in {\mathbb{R}}^{HW}$ denote vectorization, and let $Q_p$ denote the pth percentile operator. For $p\in (0,100)$,

$$\tau (X;p)=Q_p\left(\mathrm{vec}\left(X\right)\right).$$

(1)

From there, the binary mask may be defined in either of two ways:

$$B_{i,j}=\mathbb{I}\left[X_{i,j}\ge \tau (X;p)\right],$$

(2)

Alternatively, an inverted rule may be used:

$$B_{i,j}=\mathbb{I}\left[X_{i,j}<\tau (X;p)\right].$$

(3)

Percentile thresholding is appropriate for low-resolution patches for several reasons. The percentile p fixes the fraction of activated pixels and therefore gives direct control of the binary support. Because the rule depends on rank rather than absolute intensity, it is invariant to strictly monotonic intensity transformations and less sensitive to global illumination changes. Extreme pixels influence the cutoff only when p is close to the ends of the range. In small patches with sparse, multimodal, or background-dominated histograms, the rule may still remain stable even when bimodality is absent.

This differs from Otsu thresholding, which selects $\tau$ by maximizing between-class separation and works best when the histogram is close to bimodal. In retinal patches, lesion pixels share the field with background tissue and anatomical structures, so the histogram may be multimodal or dominated by a single mode. For this reason, percentile thresholding provides a more controlled support for the run-based analysis.

2.2.2. Run-Constrained Binary Patterns and Regular Expressions

A run-constrained binary pattern is a representation that summarizes the spatial organization of a binary image by measuring the lengths, counts, and continuity of contiguous blocks (runs) of identical pixel values, subject to minimum-length constraints. Once a binary field $B\in {\{0,1\}}^{H\times W}$ has been obtained, each row and each column can be read as a binary string. For a row index r, define $s_r^{\mathrm{row}}=(B_{r,1},\dots ,B_{r,W})\in {\{0,1\}}^W$. For a column index c, define $s_c^{\mathrm{col}}=(B_{1,c},\dots ,B_{H,c})\in {\{0,1\}}^H$. A run is a maximal contiguous block of identical symbols within a sequence. If $s=(s_1,\dots ,s_L)$, then indices $a\le b$ form a run when $s_a=\cdots =s_b$, while $s_{a-1}\ne s_a$ when $a>1$, and $s_{b+1}\ne s_b$ when $b<L$. The run length is $\ell =b-a+1$.

Regular expressions provide a compact way to state these run constraints. For example, a sequence of ones of length at least m may be written as $1\{m,\}$, and $0\{m,\}$ denotes a background run of zeros of length at least m. In the implementation, however, the method does not call a full regular expression engine. Each binary sequence is scanned once and the same quantities are obtained directly. This is computationally cheaper during hyperparameter search.

The resulting run statistics describe continuity, fragmentation, and total extent. Since a single pixel can split a run and change the maxima and totals, the threshold and run parameters must be chosen carefully. Minimum-length constraints reduce the influence of short fragments, but they do not remove this sensitivity.

2.2.3. Surrogate Optimization for Hyperparameter Selection

The proposed method requires selecting the hyperparameters that control binarization and run extraction: the percentile threshold p, the polarity flag, the minimum run lengths $m_1$ and $m_0$, and the long-run threshold L. These parameters define the structural descriptor from which the classifier operates, and their selection can be formulated as a black-box optimization problem. The real objective function is the classification performance measured on validation data, for example through the Matthews correlation coefficient or a stability-aware fitness score that penalizes the gap between training and validation performance. This function is expensive to evaluate in aggregate because each candidate configuration requires binarizing all training images, extracting run-length features, fitting a ridge model, and computing the resulting metric. In addition, the objective function may be discontinuous with respect to the discrete parameters and may also be affected by noise introduced by data resampling. A surrogate optimization approach is therefore applied: instead of evaluating all possible configurations, a probabilistic model is built from the evaluations collected so far and used to guide the selection of the next candidate.

Formally, let $\theta \in \Theta$ denote a candidate configuration and let $f:\Theta \to \mathbb{R}$ denote the objective function.

Several standard strategies may be used to explore this type of search space. Grid search evaluates the Cartesian product of predefined candidate values, but its computational cost increases combinatorially with the number of parameters and with the number of values considered for each parameter. Random search samples configurations independently and often improves upon grid search when only a subset of dimensions is truly influential. However, it remains non-adaptive and therefore continues allocating evaluations to regions that have already shown little promise. In contrast, surrogate optimization follows a sequential model based strategy in which past observations are used to guide future evaluations. After t evaluations, the observation set is given by

$${\mathcal{D}}_t={\left\{({\theta }_i,y_i)\right\}}_{i=1}^t,y_i=f\left({\theta }_i\right)+{\epsilon }_i,$$

(4)

where ${\epsilon }_i$ represents measurement noise. On the basis of these observations, a surrogate model induces a predictive distribution for $f\left(\theta \right)$ at any candidate $\theta$. In many practical constructions, this predictive distribution is summarized through a mean ${\mu }_t\left(\theta \right)$ and a standard deviation ${\sigma }_t\left(\theta \right)$. The next candidate is selected by maximizing an acquisition function $a_t$, so that

$${\theta }_{t+1}\in \arg \underset{\theta \in \Theta }{\max }{a}_t\left(\theta \right).$$

(5)

The acquisition function balances exploration and exploitation. The predictive uncertainty ${\sigma }_t\left(\theta \right)$ controls exploration, since regions with large ${\sigma }_t$ have not been sufficiently sampled and may contain good solutions. The predictive mean ${\mu }_t\left(\theta \right)$ controls exploitation, since regions with favorable ${\mu }_t$ are likely to contain good objective values based on the observations collected so far.

Common acquisition rules are written directly in terms of ${\mu }_t$ and ${\sigma }_t$. In minimization settings, let $f_t^{★}={\min }_{i\le t}{y}_i$ denote the best observed value. The expected improvement criterion is then defined as

$${\mathrm{EI}}_t\left(\theta \right)=\mathbb{E}\left[\max \left(0,f_t^{★}-f\left(\theta \right)\right)\mid {\mathcal{D}}_t\right].$$

(6)

In practice, the predictive distribution at each candidate $\theta$ is assumed to be Gaussian with mean ${\mu }_t\left(\theta \right)$ and standard deviation ${\sigma }_t\left(\theta \right)$. This assumption is adopted for computational convenience, since the true distribution of $f\left(\theta \right)$ is generally unknown and unlikely to be exactly Gaussian. Under this assumption, expected improvement has a closed form and is larger when ${\mu }_t\left(\theta \right)$ is small and ${\sigma }_t\left(\theta \right)$ is large. Confidence-bound strategies follow a related principle. The Lower Confidence Bound (LCB) acquisition function is defined as

$${\mathrm{LCB}}_t\left(\theta \right)={\mu }_t\left(\theta \right)-\kappa {\sigma }_t\left(\theta \right),$$

(7)

and candidates are selected by minimizing ${\mathrm{LCB}}_t$. The scalar $\kappa >0$ controls how much weight is given to exploration relative to exploitation: larger values of $\kappa$ encourage the selection of candidates in regions with high uncertainty. The expected improvement and LCB formulations above are presented for completeness, since they are the most common acquisition functions in the surrogate optimization literature. In the present work, the surrogate method actually used is the Tree-structured Parzen Estimator (TPE), which is suited for mixed and discrete search spaces. The TPE models $p(\theta \mid y)$ by splitting the observations collected so far into a good set and a bad set through a quantile threshold $y^{★}$. This produces two densities,

$$\ell \left(\theta \right)=p(\theta \mid y\le y^{★}),g\left(\theta \right)=p(\theta \mid y>y^{★}).$$

(8)

Candidate generation then favors configurations that are more likely under ℓ than under g, often through maximization of a ratio of the form $\ell \left(\theta \right)/g\left(\theta \right)$. In this way, the search is directed toward regions that have produced good objective values, while retaining enough diversity to reduce premature convergence in irregular objective spaces. Once the TPE selects the best configuration from the surrogate search, the corresponding ridge model is fitted on the training data with the selected hyperparameters, and the resulting weight vector ${\widehat{w}}_{\alpha }$ together with the intercept $\widehat{b}$ define the linear decision function used for classification.

2.2.4. Ridge Classification Recast in Explicit Mathematical Form

After feature extraction, each sample is represented by a vector $x\in {\mathbb{R}}^d$, and the linear score is $s\left(x\right)=w^{\top }x+b$, with prediction $\widehat{y}=\mathrm{sign}\left(s\left(x\right)\right)$ in the binary setting. Let $X\in {\mathbb{R}}^{n\times d}$ denote the design matrix whose rows are feature vectors, and let $y\in {\mathbb{R}}^n$ denote a numerical encoding of the labels, for example through $-1$ and $+1$. The ridge classifier can then be written as a regularized least-squares problem

$$\underset{w\in {\mathbb{R}}^d,b\in \mathbb{R}}{\min }{\parallel y-Xw-b\mathbf{1}\parallel }_2^2+\alpha {\parallel w\parallel }_2^2,\alpha >0,$$

(9)

where $\mathbf{1}$ denotes the vector of ones. If the columns of X and the vector y are centered so that the intercept can be omitted, the ridge solution has the closed form

$${\widehat{w}}_{\alpha }={\left(X^{\top }X+\alpha I\right)}^{-1}{X}^{\top }y.$$

(10)

When the intercept is retained without centering, a standard identity gives $\widehat{b}=\overline{y}-{\widehat{w}}_{\alpha }^{\top }\overline{x}$, where $\overline{x}$ denotes the mean feature vector and $\overline{y}$ denotes the mean label encoding. The effect of ridge regularization may be seen more clearly through spectral analysis. Let $X^{\top }X=V\Sigma V^{\top }$ be an eigendecomposition with orthonormal V and diagonal $\Sigma$ containing the nonnegative eigenvalues ${\sigma }_1,\dots ,{\sigma }_d$. It then follows that

$$X^{\top }X+\alpha I=V(\Sigma +\alpha I)V^{\top },$$

(11)

so the eigenvalues are shifted from ${\sigma }_i$ to ${\sigma }_i+\alpha$. Two consequences follow. First, invertibility is guaranteed for any $\alpha >0$, even when $X^{\top }X$ is singular. Second, numerical conditioning improves because small eigenvalues, which correspond to nearly dependent feature directions, are displaced away from zero by $\alpha$. As a result, the estimator tends to have lower variance along directions affected by multicollinearity.

This is relevant for the descriptor family used here. Run-derived features may be strongly correlated because several statistics summarize the same structure from different viewpoints. A simple example arises when one feature is a normalized version of another: if u denotes the sum of accepted run lengths and v the corresponding coverage, then $v=u/\left(HW\right)$, which implies exact linear dependence. Approximate dependence also appears when row-wise and column-wise summaries reflect the same geometric structure. In this setting, ridge shrinkage stabilizes the estimator by reducing large coefficients induced by correlated predictors while preserving a direct relation between features and decisions.

For the proposed ridge model, the quantity used in threshold-free ranking analyses is the signed decision score $s\left(x\right)$ returned by the linear decision function. AUROC and one-versus-rest precision–recall curves are therefore computed directly from these scores. No additional score transformation was applied for these analyses.

3. Proposed Method

The proposed pipeline consists of deterministic transformations followed by surrogate optimization over a discrete hyperparameter space. The method is described in eight steps.

• Step 1. Intensity field construction. Given an RGB patch $A\in {\{0,\dots ,255\}}^{32\times 32\times 3}$, an intensity field $X\in {\mathbb{R}}^{32\times 32}$ is computed using luminance

  $$X_{i,j}=0.299A_{i,j,1}+0.587A_{i,j,2}+0.114A_{i,j,3}.$$

  (12)
• Step 2. Percentile threshold selection. Given a percentile hyperparameter $p\in (0,100)$, a patch-specific threshold is computed

  $$\tau =Q_p\left(\mathrm{vec}\left(X\right)\right),$$

  (13)

  where $Q_p$ is the percentile operator.
• Step 3. Binary mask construction. A binary mask $B\in {\{0,1\}}^{32\times 32}$ is then obtained using a polarity hyperparameter $\mathrm{invert}$. If $\mathrm{invert}=0$ then

  $$B_{i,j}=\mathbb{I}[X_{i,j}\ge \tau ].$$

  (14)

  If $\mathrm{invert}=1$ then

  $$B_{i,j}=\mathbb{I}[X_{i,j}<\tau ].$$

  (15)
• Step 4. Run extraction with minimum length constraints. Each row and each column of B is scanned to extract maximal runs of identical symbols. Two integer hyperparameters are used: $m_1$ for one-runs and $m_0$ for zero-runs. A one-run is retained only if its length satisfies $\ell \ge m_1$, and a zero-run only if $\ell \ge m_0$. For each of the four cases, rows ones, columns ones, rows zeros, and columns zeros, three summaries are computed. The maxima array M stores the maximum valid run length per line, the count array C stores the number of valid runs per line, and the sum S stores the total length of all valid runs across lines.
• Step 5. Long-run structure and block continuity. A long-run threshold hyperparameter L defines a long-run flag per line

  $$\Lambda (\ell )=\mathbb{I}\left[M\right(\ell )\ge L],$$

  (16)

  where ℓ indexes a row or a column. Two long-run descriptors are then computed for each case. The long-run count is ${\sum }_{\ell }\Lambda (\ell )$. The long-run block length is the maximum number of consecutive lines with $\Lambda (\ell )=1$.
• Step 6. Explicit construction of the 32 dimensional descriptor. A fixed descriptor $f\left(A\right)\in {\mathbb{R}}^{32}$ is assembled from four coverage features and twenty-eight run summary features. The four coverage features are defined by

  $${\mathrm{cov}}_1^{\mathrm{row}}={\displaystyle \frac{S_1^{\mathrm{row}}}{{32}^2}},{\mathrm{cov}}_0^{\mathrm{row}}={\displaystyle \frac{S_0^{\mathrm{row}}}{{32}^2}},{\mathrm{cov}}_1^{\mathrm{col}}={\displaystyle \frac{S_1^{\mathrm{col}}}{{32}^2}},{\mathrm{cov}}_0^{\mathrm{col}}={\displaystyle \frac{S_0^{\mathrm{col}}}{{32}^2}}.$$

  (17)

  For each case determined by an orientation $o\in \{\mathrm{row},\mathrm{col}\}$ and a polarity $b\in \{1,0\}$, define the per-line maxima array $M_b^o$, the per-line count array $C_b^o$, and the long-run flag array ${\Lambda }_b^o$ derived from $M_b^o$ and L. Seven summary features are computed per case:

  $$\max \left(M_b^o\right),\mathrm{mean}\left(M_b^o\right),\mathrm{std}\left(M_b^o\right),\sum C_b^o,\mathrm{mean}\left(C_b^o\right),\sum {\Lambda }_b^o,\mathrm{blockmax}\left({\Lambda }_b^o\right),$$

  (18)

  where $\mathrm{blockmax}$ returns the maximum length of a consecutive block of ones in a binary sequence. The final descriptor is formed by concatenation in a fixed order. First the four coverages are appended, then seven features for rows ones are appended, seven features for columns ones are appended, seven features for rows zeros are appended and lastly seven features for columns zeros are appended.
• Step 7. Standardization and ridge decision function. Given descriptors $x_i=f\left(A_i\right)$, each dimension is standardized using the training-set mean ${\mu }_k$ and standard deviation ${\sigma }_k$:

  $${\tilde{x}}_{i,k}={\displaystyle \frac{x_{i,k}-{\mu }_k}{{\sigma }_k}}.$$

  (19)

  A ridge model is fitted and produces a score

  $$s\left(x\right)=w^{\top }\tilde{x}+b,\widehat{y}=\mathrm{sign}\left(s\left(x\right)\right).$$

  (20)
• Step 8. Two-phase surrogate optimization for hyperparameter selection. The hyperparameters are collected as $\theta =(p,\mathrm{invert},m_1,m_0,L)$, where $\theta \in \Theta$ and $\Theta$ is a discrete search space. Selection proceeds in two phases. The first phase seeks configurations whose training performance does not substantially exceed validation performance. For a candidate configuration $\theta$, the ridge model is trained on the training split and evaluated on both training and validation splits. Let ${\mathrm{MCC}}_{\mathrm{tr}}\left(\theta \right)$ and ${\mathrm{MCC}}_{\mathrm{val}}\left(\theta \right)$ denote the corresponding Matthews correlation coefficients. The phase one objective is the generalization gap

  $$g\left(\theta \right)=\left|{\mathrm{MCC}}_{\mathrm{tr}}\left(\theta \right)-{\mathrm{MCC}}_{\mathrm{val}}\left(\theta \right)\right|.$$

  (21)

  Surrogate optimization is then used to minimize $g\left(\theta \right)$ over $\Theta$, subject to feasibility constraints that reject degenerate extractions. All feasible configurations are collected and sorted in ascending order of $g\left(\theta \right)$. The K best configurations, denoted ${\theta }^{\left(1\right)},\dots ,{\theta }^{\left(K\right)}$, are retained as seeds. In the second phase, each seed defines a local discrete neighborhood $\mathcal{N}\left({\theta }^{\left(k\right)}\right)\subseteq \Theta$ by restricting each coordinate to nearby candidate values. Surrogate optimization is executed within each neighborhood to maximize a stability-aware objective computed on resampling splits of the merged training and validation data. The external test split remains excluded from the search and is used only for final reporting. Let ${\mathrm{MCC}}^{\left(r\right)}\left(\theta \right)$ denote the validation MCC obtained on repetition r from an internal stratified split of the merged set. The phase-two fitness is defined by

  $$\mathrm{fitness}\left(\theta \right)=\overline{\mathrm{MCC}}\left(\theta \right)-\lambda \mathrm{std}\left({\mathrm{MCC}}^{\left(r\right)}\left(\theta \right)\right),\overline{\mathrm{MCC}}\left(\theta \right)={\displaystyle \frac{1}{R}}{\displaystyle \sum _{r=1}^R}{\mathrm{MCC}}^{\left(r\right)}\left(\theta \right),$$

  (22)

  where $\lambda \ge 0$ controls the variability penalty and R is the number of repetitions. The final configuration is the maximizer of the phase-two objective across all neighborhoods, with $\overline{\mathrm{MCC}}\left(\theta \right)$ used as the primary criterion and the penalty term used to prefer stable solutions when mean values are similar.

• Figure 4 provides a graphical overview of the complete pipeline. The diagram follows the eight steps described above: the input retinal patch enters the intensity field construction (Step 1), passes through percentile thresholding (Step 2) to produce the binary mask (Step 3), from which runs are extracted with minimum-length constraints (Step 4) and long-run structure is computed (Step 5). The resulting 32-dimensional descriptor (Step 6) is standardized and fed to the ridge classifier (Step 7), whose hyperparameters are selected through the two-phase surrogate optimization (Step 8). At each stage, the figure shows representative inputs and outputs so that the transformation from patch to decision can be traced visually.

3.1. Pseudocode for the Proposed Pipeline

To make the method easier to reproduce, Algorithm 1 presents the complete procedure in pseudocode form. The algorithm receives the dataset, the discrete search space, and the optimization budgets as inputs. It first splits the data into training, validation, and test sets. Phase one then evaluates $T_1$ configurations sampled by the TPE surrogate in minimization mode, retaining the K configurations with the smallest generalization gap. Phase two defines a local neighborhood around each seed and runs $T_2$ additional surrogate-guided evaluations in maximization mode using repeated internal cross-validation. The configuration with the highest stability-aware fitness is selected, and the final ridge model is trained on the merged training and validation sets and evaluated once on the held-out test set.

Algorithm 1 Run descriptor extraction and two-phase surrogate optimization

Input: dataset ${\left\{(A_i,y_i)\right\}}_{i=1}^N$, discrete search space $\Theta$, integer K, phase one budget $T_1$, phase two budget $T_2$, repetitions R, penalty $\lambda$ Split data into training set $\mathcal{T}$, validation set $\mathcal{V}$, test set $\mathcal{E}$ using stratified sampling Define procedure Descriptor that maps a patch A and configuration $\theta$ to $x\in {\mathbb{R}}^{32}$ using Steps 1 to 6 Define procedure FitScore that standardizes descriptors on a fit set, fits ridge, and returns MCC on requested sets   Phase one search Initialize empty list $\mathcal{L}$ for $t=1$ to $T_1$ do       Sample ${\theta }_t\in \Theta$ using surrogate optimization in minimization mode       Compute descriptors $X_{\mathcal{T}}=\{\mathrm{D}\mathrm{ESCRIPTOR}(A,{\theta }_t):A\in \mathcal{T}\}$ and $X_{\mathcal{V}}$ analogously       if feasibility constraints fail then             Continue       end if       Compute ${\mathrm{MCC}}_{\mathrm{tr}}\left({\theta }_t\right)$ and ${\mathrm{MCC}}_{\mathrm{val}}\left({\theta }_t\right)$ using FitScore       $g\left({\theta }_t\right)\leftarrow \left|{\mathrm{MCC}}_{\mathrm{tr}}\left({\theta }_t\right)-{\mathrm{MCC}}_{\mathrm{val}}\left({\theta }_t\right)\right|$       Append $({\theta }_t,g\left({\theta }_t\right))$ to $\mathcal{L}$ end for Sort $\mathcal{L}$ by $g\left(\theta \right)$ in ascending order Select seeds ${\theta }^{\left(1\right)},\dots ,{\theta }^{\left(K\right)}$ as the first K configurations in $\mathcal{L}$   Phase two refinement Initialize best configuration ${\theta }^{★}$ and best value $F^{★}\leftarrow -\infty$ for $k=1$ to K do       Define a local neighborhood $\mathcal{N}\left({\theta }^{\left(k\right)}\right)\subseteq \Theta$       for $t=1$ to $T_2$ do             Sample ${\theta }_t\in \mathcal{N}\left({\theta }^{\left(k\right)}\right)$ using surrogate optimization in maximization mode             Compute descriptors on merged set $\mathcal{M}=\mathcal{T}\cup \mathcal{V}$             if feasibility constraints fail then                  Continue             end if             Generate R internal stratified splits of $\mathcal{M}$ into fit and validation subsets             Compute ${\mathrm{MCC}}^{\left(1\right)}\left({\theta }_t\right),\dots ,{\mathrm{MCC}}^{\left(R\right)}\left({\theta }_t\right)$ using FitScore on each split             $\overline{\mathrm{MCC}}\left({\theta }_t\right)\leftarrow {\displaystyle \frac{1}{R}}{\sum }_{r=1}^R{\mathrm{MCC}}^{\left(r\right)}\left({\theta }_t\right)$             $\mathrm{fitness}\left({\theta }_t\right)\leftarrow \overline{\mathrm{MCC}}\left({\theta }_t\right)-\lambda \mathrm{std}\left({\mathrm{MCC}}^{\left(r\right)}\left({\theta }_t\right)\right)$             if $\mathrm{fitness}\left({\theta }_t\right)>F^{★}$ then                  ${\theta }^{★}\leftarrow {\theta }_t$, $F^{★}\leftarrow \mathrm{fitness}\left({\theta }_t\right)$             end if       end for end for   Final training and test evaluation Fit ridge on merged set $\mathcal{M}$ using ${\theta }^{★}$ and evaluate once on test set $\mathcal{E}$ Output: selected configuration ${\theta }^{★}$ and test metrics

To clarify how the regular expression constraints translate into a concrete descriptor, consider a single row of the $32\times 32$ binary mask, for example the sequence $s=0011111000000110\dots$. With a minimum one-run length of $m_1=4$, the pattern $1\{4,\}$ matches the first block of five consecutive ones but rejects the shorter block of two ones. Similarly, $0\{6,\}$ with $m_0=6$ retains only zero-runs of at least six symbols. The matched runs yield the statistics described in Step 4: maximum run length, run count, and total run length per line. These values are computed for every row and every column, for both ones and zeros, producing the 32-dimensional descriptor defined in Step 6. When this descriptor is passed to the ridge classifier, the linear decision function directly weights run-level summaries, so the contribution of each structural pattern can be inspected at the descriptor level.

Leakage-Aware Grouped Evaluation Protocol

Because multiple patches can originate from the same retinal fundus image, the revised evaluation distinguishes the original repeated patch-level benchmark from a complementary leakage-aware grouped protocol. The main repeated benchmark is retained for the 100 execution summary and the comparative results, whereas the grouped analysis was added as an additional source–image disjoint robustness check. The grouped dataset contains 211 patches from 47 source images.

Three grouped evaluations are reported as complementary robustness analyses. First, an illustrative grouped holdout split uses 30 source images for training, 8 for validation, and 9 for test, corresponding to 147, 32, and 32 patches, respectively. Second, a 100-run grouped repeated holdout analysis quantifies variability under source–image disjoint resampling. Third, grouped repeated cross-validation and grouped nested cross-validation are used to assess validation overfitting and to compare two-phase TPE, one-phase TPE, and random search under stricter source–image separation.

Whenever comparative deep or handcrafted baselines could not be reconstructed with a source–image mapping, those results continue to be interpreted within the patch-level benchmark and are not presented as direct grouped comparisons.

The evaluation metrics used for the proposed method and the comparative models are defined below.

3.2. Evaluation Metrics

For binary classification with known ground truth, predictions fall into four categories: true positive ($TP$), false positive ($FP$), true negative ($TN$), and false negative ($FN$). Let P denote the total number of positive samples and N the total number of negative samples. The following metrics are then defined:

$$\mathrm{recall}={\displaystyle \frac{TP}{P}},\mathrm{precision}={\displaystyle \frac{TP}{TP+FP}}.$$

(23)

Recall measures the fraction of positive samples that are detected correctly, whereas precision measures the fraction of predicted positives that are correct. These metrics are useful when the main priority is to recover positive cases, even at the cost of false positives. When the goal is to distinguish two lesion classes and to assess performance on both, it is also useful to consider:

$$\mathrm{accuracy}={\displaystyle \frac{TP+TN}{P+N}},\mathrm{F}1-\mathrm{Score}={\displaystyle \frac{2TP}{2TP+FP+FN}}.$$

(24)

Accuracy measures the fraction of correctly classified samples in the full dataset, and the F1-score is the harmonic mean of recall and precision. Both incorporate information beyond the positive class alone. In imbalanced datasets, however, accuracy and F1-score can depend strongly on how the positive class is defined and may therefore favor solutions that fit the dominant class. For this reason, the phi coefficient, also known as the Matthews correlation coefficient (MCC), is additionally used:

$$\mathrm{MCC}={\displaystyle \frac{(TP·TN)-(FP·FN)}{\sqrt{(TP+FP)(TP+FN)(TN+FP)(TN+FN)}}}.$$

(25)

Unlike the preceding metrics, MCC ranges from $-1$ to $+1$: $+1$ denotes perfect classification, $-1$ denotes complete inverse classification, and 0 indicates performance no better than random. The last case occurs when the product of correct predictions is equal or close to the product of incorrect predictions, so that $TP·TN\simeq FP·FN$ and the numerator approaches zero.

4. Results and Discussions

Experiments for the proposed method and the classical machine learning baselines were run on an Apple Silicon M1 system (Apple Inc., Cupertino, CA, USA) with 8 GB of RAM, whereas CNN and vision transformer models were run on two NVIDIA Tesla T4 GPUs (NVIDIA Corporation, Santa Clara, CA, USA) with 29 GB of RAM. All implementations used Python 3.11.8 and PyTorch 2.4.0.

The revised manuscript reports two complementary evaluation settings. The main benchmark remains the repeated stratified patch-level protocol used for the 100-execution summary and the comparative analysis in

Table 1. Descriptive statistics of the proposed method across 100 independent executions, each using a different stratified partition of the dataset. Each row summarizes the distribution of the corresponding metric over the 100 held-out test evaluations.

Metric	Min	Max	Mean	Median	Std. Dev.
MCC	0.7144	0.8433	0.7829	0.7826	0.04475
Accuracy	0.8571	0.9286	0.9008	0.9048	0.02174
F1-Score	0.8125	0.8966	0.8529	0.8462	0.02939
Precision	0.7222	1.000	0.8525	0.8619	0.06912
Recall	0.7857	0.9286	0.8619	0.8571	0.06746

and

Table 2. Model Performance Metrics.

Model	Accuracy	F1-Score	Recall	mcc
EfficientNetB0 [31]	0.6279	0.5905	0.5948	0.1839
HOG	0.6744	0.5000	0.5000	0.2586
Random Forest	0.7358	0.7016	0.7358	0.3654
GLCM (Haralick)	0.7442	0.4762	0.3571	0.3658
MobileNetV2 [32]	0.6512	0.6481	0.7044	0.3884
Gabor	0.7442	0.5600	0.5000	0.3889
XGBoost [33]	0.7547	0.7363	0.7547	0.4189
LBP	0.7907	0.6400	0.5714	0.5026
DenseNet121 [34]	0.8140	0.7952	0.8067	0.5946
SVM	0.8302	0.8260	0.8302	0.6108
NesT-Base [35]	0.8302	0.8174	0.8302	0.6154
Logistic Regression L2	0.8302	0.8329	0.8302	0.6409
ConvNeXtTiny [36]	0.8605	0.8626	0.8605	0.6972
Proposed Method	0.9286	0.8966	0.9286	0.8433

. In addition, source–image disjoint grouped analyses were added as leakage-aware robustness checks.

Table 2 summarizes the main performance metrics of all models under the same evaluation protocol.

For the proposed ridge classifier, AUROC and AUPRC were computed from the raw signed decision scores returned by the fitted model; these quantities are therefore interpreted only as score ranking summaries of the decision function.

4.1. Overall Performance of the Proposed Method

The main repeated execution summary is reported in Table 1, which is kept as the primary descriptive table of the manuscript. Table 1 reports descriptive statistics of the proposed method across 100 independent executions of the complete pipeline, each carried out on a different stratified partition of the full dataset into 60% training, 20% validation, and 20% test. The dataset itself, not the test set, is re-split each time, so the training, validation, and test subsets change from one execution to the next. The optimization procedure, including both surrogate phases, is then run from scratch on each partition, and the resulting model is evaluated once on the corresponding held-out test set. In this way, the statistics in the table capture two sources of variability simultaneously: the randomness introduced by different data partitions and the stochasticity of the surrogate search. This protocol gives a more realistic picture of expected performance than a single fixed split, especially under class imbalance, where MCC can shift with small changes in the confusion matrix even when precision and F1 remain stable.

Table 1 shows that accuracy and F1 remain consistently high across the 100 partitions, with standard deviations of 0.022 and 0.029, respectively. MCC ranges from 0.714 to 0.843, with a standard deviation of 0.045. This narrower spread relative to the other metrics reflects the sensitivity of MCC to small confusion matrix changes under limited data, since a test set of only 42 images means that a single additional misclassification can shift MCC by a larger margin than it shifts accuracy or F1. The curve-based and uncertainty analyses reported next provide further context for these observations.

4.2. Comparative Analysis

Table 2 is kept in the main text as the central comparative benchmark. To make the deep learning comparison more explicit, all CNN and transformer baselines used AdamW, batch size 16, weighted cross-entropy, and augmentation with ${90}^{\circ }$, ${180}^{\circ }$, and ${270}^{\circ }$ rotations together with horizontal and vertical flips. The pretrained backbones used $224\times 224$ inputs with ImageNet normalization. An additional scratch CNN reference benchmark is reported in the Supplementary Material. To contextualize the proposed performance against deep baselines, Figure 5 reports the training and validation loss trajectories of the comparative CNN and transformer architectures. These curves provide a direct view of optimization stability and generalization under the low-resolution ($32\times 32$) and limited-data regime.

Figure 5 shows that EfficientNetB0 and MobileNetV2 exhibit validation losses that remain in a narrow band during most of training, with training loss that oscillates or decreases only slightly. This pattern, despite data augmentation, points to limited learning capacity under the present low-resolution and small-sample conditions, which is consistent with the low MCC values reported for these two architectures in Table 2. DenseNet121 shows an abrupt increase in training loss while validation loss remains almost flat, which suggests instability during optimization, although its final MCC of 0.595 indicates that the model still extracts useful features from the augmented data.

In contrast, ConvNeXtTiny and NesT-Base show sustained decreases in both training and validation loss, with the smallest train–validation gaps among the five architectures evaluated. ConvNeXtTiny reaches an MCC of 0.697 after augmentation, which makes it the highest-performing deep baseline. NesT-Base, despite a comparatively simpler loss trajectory, achieves an MCC of 0.615, which confirms that transformer-based architectures can also learn from $32\times 32$ patches under limited data. These loss trajectories help explain the downstream classification results and show that data augmentation substantially improves deep model performance on this dataset. However, this comparison is limited to the repeated patch-level benchmark of Table 2; it is not a source–image disjoint grouped comparison against the deep baselines.

The comparative results in Table 2 remain one of the central results of the manuscript. The grouped source–image analyses added in the revision are reported later as complementary robustness checks rather than as replacements for this benchmark. In addition to the deep and tree-based baselines, four handcrafted texture descriptors were included in the comparison: Local Binary Patterns (LBP), Gray-Level Co-occurrence Matrix features (GLCM, Haralick descriptors), a Gabor filter bank, and Histogram of Oriented Gradients (HOG). Recent evidence indicates that traditional machine learning pipelines with handcrafted features can remain competitive in biomedical imaging when training data is limited, while requiring far less computation [37,38]. These four descriptors were selected because they capture complementary texture properties and have been applied together for the classification of retinal pathologies in optical coherence tomography images [39]. Each descriptor was paired with the same ridge classifier used by the proposed method so that differences in performance can be attributed to the representation rather than to the classification stage.

Under the repeated patch-level protocol of Table 2, the proposed method achieved the highest MCC and macro-F1 among the evaluated models. Within this same benchmark, ConvNeXtTiny was the highest-performing deep baseline, with an MCC of 0.697, above DenseNet121 (0.595) and NesT-Base (0.615). EfficientNetB0 and MobileNetV2 remained in the low-MCC range despite augmentation, with values of 0.184 and 0.388, which suggests limited discrimination between the two lesion classes at this resolution under this protocol. Among the classical models, logistic regression and SVM reached MCC values above 0.6 without any augmentation, which indicates that the run-based descriptor captures discriminative structure that simpler classifiers can use directly. The handcrafted texture descriptors fell in the MCC range of 0.259 to 0.503, with LBP as the highest-performing handcrafted baseline. The proposed method exceeded ConvNeXtTiny by 0.146 MCC points in this repeated patch-level benchmark while requiring orders of magnitude less computation, as shown in

Table 3. Computation times of the evaluated models in seconds.

Model	Training Time	Test Time	Mean Time per Image	Std. Dev.
ConvNeXtTiny	82.2875	6.8226	0.0779	0.0036
DenseNet121	145.5829	18.6904	0.0840	0.0029
EfficientNetB0	108.1226	11.0021	0.0760	0.0030
MobileNetV2	64.6640	7.0957	0.0734	0.0029
NesT-Base	44.1216	0.5660	0.0210	0.0027
GLCM (Haralick)	0.0019	0.0003	<0.0001	—
Gabor	0.0018	0.0002	<0.0001	—
HOG	0.0112	0.0004	<0.0001	—
LBP	0.0233	0.0003	<0.0001	—
SVM	0.0371	0.0161	0.0010	0.0001
Logistic Regression L2	0.1657	0.0022	0.0007	0.0001
Proposed Method	0.2305	0.0576	0.0013	0.0003
Random Forest	1.8824	0.0262	0.0244	0.0011
XGBoost	9.3886	0.0014	0.0005	0.0001

.

From a deployment perspective, Table 3 reports training time and test time latency for all models and makes the computational tradeoffs between deep architectures and the proposed lightweight pipeline easier to judge.

In Table 3, the mean time per image was computed as the reported test time divided by the 42 images in each held-out test partition. As shown in Table 3, deep architectures require much longer training and test times under the repeated patch-level benchmark. The proposed approach reduces inference to deterministic feature extraction and a linear decision function, which yields low latency per image. The intermediate masks and feature families can also be inspected directly. The following results therefore report operating curve behavior and uncertainty, with AUROC and AUPRC interpreted only as ranking summaries of the signed ridge scores.

4.3. Discriminative Performance, Operating Curve Behavior, and Stability

Table 4. Test-set performance of the proposed method with 95% bootstrap confidence intervals.

Metric	Value	CIlow	CIhigh
MCC	0.843	0.641	1.000
Accuracy	0.929	0.833	1.000
Macro F1	0.897	0.816	1.000
Weighted F1	0.928	0.844	1.000
Balanced Accuracy	0.911	0.802	1.000
AUROC (macro)	0.934	0.837	1.000
AUPRC (macro)	0.911	0.792	1.000

reports the global test-set metrics of the proposed method together with the corresponding 95% bootstrap confidence intervals.

For these ROC- and PR-based summaries, AUROC and AUPRC were computed from the signed ridge decision scores and are therefore reported only as ranking diagnostics of the decision function. Figure 6 presents the one-versus-rest ROC and precision–recall curves for Cotton Wool Spots and Drusen. The AUROC is 0.934 for both classes. The AUPRC is 0.854 for Cotton Wool Spots and 0.968 for Drusen.

The ROC curve (Figure 6a) is better when the curve departs from the diagonal and approaches the upper-left corner, since that indicates high true positive rates at low false positive rates. The similar AUROC values for both classes indicate that the score ranks positive cases comparably in Cotton Wool Spots and Drusen. The precision-recall curve (Figure 6b) is better when it stays close to the upper-right corner, since that indicates high precision and high recall simultaneously. In this case the curves differ more between classes, which is expected when the degree of class overlap is not the same for the two lesion types. The higher AUPRC for Drusen indicates that the classifier retrieves Drusen more cleanly across operating thresholds than it retrieves Cotton Wool Spots.

Figure 6 also includes micro- and macro-averaged summaries. The micro-averaged AUROC is 0.918 and the macro-averaged AUROC is 0.934. The stepwise shape of the curves is due to the small test set, since each sample changes the operating points discretely.

Figure 7 summarizes the mean ROC and precision–recall curves across repeated executions of the optimization pipeline.

Figure 7 shows that the mean ROC and precision-recall curves remain well above chance, although run-to-run variation is visible because the search space is discrete and the extracted features are sensitive to threshold and minimum-length parameters.

The same figure also shows the difference between the best single execution and the mean behavior across runs. The mean AUROC is 0.857 for both classes. The mean AUPRC is 0.907 for Drusen and 0.796 for Cotton Wool Spots.

Figure 8 reports bootstrap confidence intervals for the main test metrics and the variability across runs in the repeated evaluation protocol. The width of the MCC confidence interval is largely a consequence of the small test set rather than a specific weakness of the proposed method. For comparison, the same bootstrap procedure applied to NesT-Base (MCC = 0.615) yields a 95% confidence interval of approximately [0.333, 0.857], which is wider than the interval obtained for the proposed method. This confirms that any classifier evaluated on a test set of this size would produce broad confidence intervals for MCC, regardless of its underlying architecture.

Figure 8a quantifies uncertainty due to finite sample size: the bootstrap procedure resamples the test predictions with replacement and recomputes each metric, so the resulting intervals reflect how much each metric could change if a different test sample of the same size were drawn. Wider intervals, such as those observed for MCC and AUPRC, indicate that these metrics are more sensitive to the composition of the test set. Figure 8b shows a different source of variability: the dispersion introduced by re-running the complete optimization pipeline with different random seeds. Here, each box summarizes the distribution of a given metric across independent executions. Accuracy and balanced accuracy are more stable across runs, whereas MCC varies more because a single change in the confusion matrix can shift MCC substantially when the test set is small.

4.4. Additional Grouped Source–Image Robustness Analyses

Because multiple patches can arise from the same retinal fundus image, a complementary source–image disjoint evaluation was added as a leakage-aware robustness analysis. The grouped dataset contains 211 patches from 47 source images. The illustrative grouped holdout split used 147 patches from 30 source images for training, 32 patches from 8 source images for validation, and 32 patches from 9 source images for test. The test subset contained 23 Drusen patches and 9 Cotton Wool Spot patches.

Under this grouped protocol, the two-phase TPE search used only the training and validation partitions. After the final configuration was fixed, the test partition was evaluated once. The grouped confusion matrix was $\left[\begin{array}{cc}22& 1\\ 1& 8\end{array}\right]$, with rows denoting the true labels and columns the predicted labels in the order Drusen and Cotton Wool Spots. This yielded an MCC of $0.8454$, an accuracy of $0.9375$, and a macro F1 of $0.9227$. This grouped split is presented as an additional leakage-aware robustness check and does not replace the main repeated benchmark summarized in Table 1.

As a second grouped robustness analysis, the distribution across 100 source–image disjoint repeated holdout executions was also computed.

Table 5. Grouped repeated holdout results across 100 source–image disjoint executions, reported as complementary robustness statistics.

Metric	Mean	Std. Dev.	Median	Min	Max
MCC	0.4748	0.1607	0.4697	−0.1260	0.8454
Accuracy	0.7592	0.0953	0.7642	0.4375	0.9375
Macro F1	0.7160	0.0945	0.7216	0.4182	0.9227

summarizes the resulting distribution of MCC, accuracy, and macro F1, thereby showing how much grouped holdout performance can vary across leakage-aware splits drawn at the source-image level.

Within this grouped 100-execution analysis, the validation-selected run reached a test MCC of $0.5807$, whereas the test oracle run reached $0.8454$. The difference of $0.2647$ shows how strongly a favorable grouped split can change the narrative. These values are therefore used as complementary leakage-aware variability evidence rather than as replacements for Table 1.

4.5. Robustness Against Validation Overfitting

Because the dataset is small and the hyperparameter space is discrete, additional grouped safeguards were added to evaluate validation overfitting. First, the proposed representation was assessed under grouped repeated cross-validation by source image. Second, the two-phase TPE search was compared against one-phase TPE and random search under grouped nested cross-validation.

Table 6. Robustness analysis under grouped repeated and grouped nested validation.

Protocol	Search Strategy	Mean MCC	Median MCC	95% CI MCC	Mean Macro F1
Grouped repeated cross-validation	Proposed representation	0.5642	0.5843	0.5122–0.6144	0.7549
Grouped nested cross-validation	Two-phase TPE	0.4714	0.5138	0.3833–0.5485	0.7112
Grouped nested cross-validation	One-phase TPE	0.4823	0.4557	0.4310–0.5329	0.7082
Grouped nested cross-validation	Random search	0.5234	0.5637	0.4596–0.5856	0.7263

summarizes these grouped validation protocols so their test behavior can be compared directly under source-image control.

Grouped repeated cross-validation yielded a mean MCC of $0.5642$, a median of $0.5843$, and a 95% bootstrap confidence interval from $0.5122$ to $0.6144$. Under grouped nested cross-validation, random search obtained the highest mean test MCC ($0.5234$), followed by one-phase TPE ($0.4823$) and two-phase TPE ($0.4714$). However, the Friedman test did not detect significant differences among the three search strategies (statistic $=2.7949$, $p=0.2472$). Accordingly, the revision does not claim a statistically demonstrated advantage for the two-phase search under the grouped nested protocol.

These grouped analyses complement Table 1 and Table 2; they do not displace the main repeated benchmark or the main comparative table.

5. Conclusions

This paper presented a compact and computationally interpretable method for classifying retinal lesions in retinal fundus images by combining percentile thresholding, run-based descriptors defined through regular expression constraints, a two-phase surrogate optimization strategy, and ridge classification. Under the repeated patch-level benchmark used in the main comparative analysis, the proposed method achieved a mean MCC of $0.7829\pm 0.0448$, a mean accuracy of $0.9008\pm 0.0217$, and a mean F1-score of $0.8529\pm 0.0294$. The best execution reached an MCC of $0.8433$, an accuracy of $0.9286$, a macro F1 of $0.8966$, and a macro AUROC of $0.934$, with a mean inference time of $0.0013$ s per image. Within that repeated patch-level comparative benchmark, the proposed method achieved the highest result in Table 2, with ConvNeXtTiny as the highest-performing deep baseline and logistic regression as the highest-performing non-ridge classical baseline. The grouped source–image analyses were incorporated only as leakage-aware robustness checks for the proposed pipeline; because matched grouped comparisons were not available for all deep baselines, the manuscript does not claim grouped superiority over deep learning. The interpretability analysis suggests that one-run coverage, one-run maxima, and long-run continuity are the descriptors most closely associated with the separation between the two lesion classes. Because the classes share color and intensity at low resolution, converting each patch to a binary field and then measuring contiguous spatial structure appears to capture useful discriminatory information under the present experimental conditions. In that sense, the proposed pipeline can be described as compact, computationally interpretable, and competitive on this small patch dataset, but these findings should still be read with appropriate caution. The main limitations of the method remain the irregular discrete search space, the sensitivity of the optimization process to parameter configuration, the limited dataset size, the small number of grouped source images, and the absence of an external validation cohort with the same lesion definition protocol. The present results should therefore not be interpreted as establishing generalizability beyond this dataset or as proving broad superiority over deep learning outside the specific benchmark conditions studied here. Future work should emphasize larger source–image and patient-level collections, external validation on independently acquired retinal lesion patches, and optimization procedures that preserve interpretability while improving stability under leakage-controlled evaluation.