XGBoost Ensemble Algorithm for Classifying Tomato Leaf Diseases Based on Texture Descriptors

Abstract

This article presents a simple and understandable approach to the automatic assessment of the severity of late blight on tomato leaves. We collect our own dataset of 5245 RGB images of healthy and diseased tomato leaves and determine five ordinal classes: healthy (0%) and four infection levels (0.1–10%, 11–25%, 26–50%, and ≥51% of the affected area). Each image is segmented using the global definition of the Otsu threshold, followed by morphological purification, after which seven textural and geometric characteristics are extracted from the contours of the lesion: contrast, number of contours, average and standard deviation of the contour area, average and standard deviation of the contour perimeter, and average area-to-perimeter ratio. All characteristics are normalized and used as input data for the XGBoost classifier. The dataset is randomly split into 80% training and 20% test images, resulting in an independent test set of 1049 images. In this test set, the proposed model provides an overall accuracy of 0.93 and an F1 macro score of 0.93 points, while for each F1 class, it varies from 0.90 to 0.97. The confusion matrix shows a stable difference between neighboring severity levels, while the analysis of the importance of the features confirms the relevance of contour descriptors for characterizing the size and shape of the lesion. This method only runs on a central processor, requires a small amount of memory, and outputs interpretable output data, making it suitable for use in greenhouses and farms with limited computing resources. We also discuss the limitations associated with the boundaries between neighboring classes and the potential shift in the subject area, and we outline directions for expanding the approach to multi-sheet scenes and explicit ordinal loss functions.

1. Introduction

Late blight (Phytophthora infestans) represents one of the most serious tomato diseases in Uzbekistan, causing substantial losses in local crop yields, potentially up to 60–70% if not identified at an early stage. Due to its significant impact on production, traditional diagnostic approaches, such as visual inspection and laboratory testing, are often slow and highly dependent on expert knowledge, limiting their applicability in large-scale cultivation. Modern agricultural development increasingly relies on intelligent technologies to automate plant health monitoring and improve crop yields [1]. In particular, the image-based disease diagnosis of leaves enables early detection of pathological changes and the timely implementation of effective agricultural measures. In recent years, machine learning methods have been actively applied to classify plant diseases, though their effectiveness largely depends on the quality of extracted features and the proper selection of model hyperparameters. By combining high-resolution imaging of tomato leaves with machine learning techniques, this study aims to provide an efficient, interpretable, and deployable approach for early detection and severity classification of late blight in real greenhouse conditions [2].

One of the promising algorithms that has a proven high performance in classification and regression problems is XGBoost (Extreme Gradient Boosting), a gradient boosting method that provides a balance between accuracy and training speed [3]. However, traditional XGBoost implementations often suffer from overfitting, parameter sensitivity, and feature space redundancy, especially when working with texture images where the data is characterized by high dimensionality and feature correlation.

In this regard, a pressing scientific challenge is the development of methods that combine statistical analysis, informative feature extraction methods, and optimization approaches to tuning model hyperparameters. Such architectures not only improve classification accuracy but also enhance the interpretability of results by analyzing feature significance and assessing the contribution of each descriptor to the final solution. This paper proposes an optimization method for the XGBoost model for classifying tomato leaf diseases based on texture descriptors [4]. The research aims to integrate traditional image analysis methods—such as calculating contrast, the number and area of contours, and the mean and standard deviation of perimeters—with modern hyperparameter optimization techniques, including grid search [5]. This approach allows us to create an adaptive and more noise-resistant model, ensuring high recognition accuracy with minimal computational costs. The relevance of this study is determined by the need to improve the efficiency of digital crop monitoring systems and the introduction of intelligent technologies into agricultural practice, which contributes to the sustainable development of agricultural technologies and the reduction in economic losses associated with plant disease.

The practical problem considered in this paper is the lack of simple and reproducible methods for assessing the degree of late blight on tomatoes in real images of greenhouses. In practice, many existing approaches are based on clean, ideal datasets and complex deep learning models, while farmers and greenhouses need simple, explicable solutions that run on standard processor hardware and work with imperfect images. This study aims to address this gap by proposing an XGBoost-based method that uses interpretable texture–geometric descriptors and can be easily applied in resource-limited settings.

The purpose of this study is to develop and experimentally verify a method for classifying images of tomato leaves by textural and geometric descriptors based on the XGBoost model, which improves the accuracy and reliability of recognizing the degrees of blight.

➢

CPU-only and low memory: full-fledged inference without a GPU; fast deployment on a laptop/edge device (in farms/greenhouses);

➢

Interpretability: texture–geometric descriptors + XGBoost → clear importance/SHAP, easy to explain to agronomists;

➢

Formalization of the feature space and construction of a training sample based on texture–geometric leaf descriptors;

➢

Normalization and scaling of features to ensure comparability of their contributions to the model;

➢

Optimizing hyperparameters of the XGBoost model;

➢

Experimental evaluation of classification quality and error analysis by classes.

2. Related Work

In [1], the impact of national demonstration zones for modern agriculture on the sustainability of rural household development is examined, with a focus on economic mechanisms and policies. Our work classifies the severity of late blight on tomato leaves. In [2], a stacking ensemble with feature selection and hyperparameter optimization for breast cancer diagnosis and its web implementation is proposed. We use XGBoost with GridSearchCV for five-class ordinal classification. In [3], the distribution of big data resources with the support of the XGBoost algorithm in the context of Industry 5.0 and ESG indicators is considered. We use XGBoost on texture–geometric features, CPU-only. In [4], a hybrid LSTM–XGBoost model optimized by grid enumeration is considered to improve the prediction of karst spring flow velocity. Our work uses GridSearchCV to optimize XGBoost on the ordinal severity scale. In [5], a method for planning the mooring trajectory of a UAV vessel with parameter selection through grid search is developed. The use of grid search for trajectory planning is a similar principle to the parametric optimization in our model. In [6], real-time spectral target detection by fusing saliency maps and edges is used. We use the method of Otsu+ morphology for leaf segmentation. In [7], rectangular partitioning of n-dimensional images is proposed for rectilinear objects. DCE-MRI is applied for the analysis of teeth, and the ROI imaging method is similar to the visualization of leaf lesions. In [8], the parametrically normalized probabilistic seismic demand model takes into account the structural strength when estimating the response. The lightweight detection of small objects is conceptually close to the selection of contours and features of leaves. In [9], XT-SECA combines XGBoost and Transformer models for functional urban zone classification from multi-band images. The real-time spectral target detection is similar to highlighting the boundaries of leaf lesions. In [10], spectral data analysis uses bagging stochastic configuration networks. The rectangular markup of n-dimensional images methodologically resembles the structuring of features. In [11], a “formal concept” theoretical framework for explainable boosting (including XGBoost/GBM) is used. Our approach includes the normalization of textural and geometric features. Ref. [12] compares Random Forest and XGBoost under different imbalances with SMOTE/ADASYN/GNUS and feature selection impact analysis. We are using XGBoost on RGB sheet images. In [13], greedy carousel algorithms for the minimum spanning tree problem are used. Spectral analysis with SCN packaging has a similar methodological connection to functional engineering. In [14,15], integrating species distribution models and piecewise linear regression is used to find the functional connectivity thresholds of urban eco-corridors. A clear system for improving performance is similar to SHAP analysis for interpreting functions. In [16], an AdaBoost ensemble of weak classifiers for gear failure diagnosis/prediction in DP motors is used. In our work, XGBoost is stable in five severity classes. In [17], active learning for stacking and AdaBoost-related models, with an analysis of the effectiveness of data selection, occurs. The greedy algorithms for a minimal spanning tree are left as an example of optimization. In [18], cost-constrained feature selection is proposed based on GBDT for problems where measurement cost is important. Similarly, for the piecewise regression for eco-corridors, the methodological relationship is minimal. In [19], an evolutionary AdaBoost ensemble is presented as an ML framework for depression detection. AdaBoost is used to diagnose gearboxes, similar to boosting for classification. In [20], the synthesis of myelin and iron stains from 7T multi-contrast MRI uses a DL model. Active learning for stacking/AdaBoost is conceptually similar to GridSearchCV. In [21], neural-NGBoost is Natural Gradient Boosting with Neural Network Base Algorithms. Cost-constrained feature selection with GBDT is similar to the feature selection for leaves. In [22], a deflationary certified greedy algorithm and adaptivity for branching nonlinear PDEs are used. Evolutionary AdaBoost is similar to using boosting. In [23], history matching is used to speed up grid search in evaluating fisheries management strategies. The synthesis of MRI with DL in our work methodology is minimally related. In [24], hyperparameter selection for retail sales forecasting uses grid search (an applied case study). We use the standard XGBoost. In [25], there are metrics for assessing legumes for protein enrichment potential in air classification. The greedy algorithm for PDE is left as an example of optimization. In [26], a comparison of tactile grid localization accuracy in people with and without back pain occurs. History matching is used to speed up GridSearch, which is similar to our hyperparameter optimization. In [27], a lightweight Siamese framework for tomato leaf disease recognition (PlantVillage/Taiwan) is used. The hyperparameter optimization with grid search is similar to our approach. In [28], the classification of tomato leaf diseases is performed using a combination of EfficientNetV2 and Swin Transformer. Grain evaluation metrics are left for methodological context [29]. The implementation and evaluation of a CNN for pixel-to-diagnosis tomato leaf disease detection [30] occurs. TOM-SSL is pseudo-labeling-based semi-supervised tomato disease recognition (labeling efficiency).

Previous research on plant disease classification has widely employed deep learning and machine learning techniques. Many studies focus on achieving high accuracy on benchmark datasets, often neglecting resource efficiency, interpretability, and practical deployability in greenhouse environments. Existing studies on tomato leaf disease classification largely rely on deep learning models such as Siamese CNNs, EfficientNetV2 + Swin Transformers, or semi-supervised pseudo-labeling frameworks. While these models achieve high accuracy on standard datasets, they often require GPU training and a large amount of memory and are difficult to deploy in real greenhouses. In contrast, our approach uses lightweight XGBoost with interpretable texture–geometric descriptors and CPU-only inference and provides robust five-class ordinal severity classification. This highlights both the practical novelty and the reproducibility advantage of our method.

In [31], in terms of disease recognition, Tomato shows the steady leadership of lightweight and hybrid DL architectures, as well as the first attempts to reduce the cost of markup through semi-supervisory approaches. Thuseethan et al. proposed a lightweight Siamese framework where a 96.97% accuracy was achieved on the PlantVillage subset and a 95.48% accuracywas achieved on the Taiwan Tomato Leaf; the authors emphasize performance on small and unbalanced data and compatibility with CPU/2 GB RAM devices, which makes the model attractive for edge scenarios. Our CPU-only model is faster, cheaper in memory, and easier to transfer to production without deep learning infrastructure.

In [32], Applied Sciences presents a hybrid EfficientNetV2 + Swin Transformer (“Eff-Swin”) with thorough ablations. On the combined dataset (PlantVillage + Tomato-Village, 13 classes), the authors report accuracy = 99.70%, surpassing the classic CNN/ViT variants with the same learning protocol. We sacrifice 6–7% of accuracy, but gain speed, memory, and field implementation.

In [33], a custom CNN and retrained VGG16/VGG19 are considered; on the test, it reports 96.45% (VGG16), ≈96.0% (custom CNN), and ≈98% (ensemble). The emphasis is on high accuracy and a comparison of memory consumption/thermal regime within the CNN family. We deliberately take a different approach: engineering of texture–geometric features + XGBoost and optimized GridSearchCV. This yields accuracy = 93% on a five-class (ordinal) scale of late blight severity with CPU-only inference, minimal memory, and high interpretability. For real-world farms and edge scenarios, such properties are often more important than absolute maximum accuracy.

In [34], a separate line is the reduction in the cost of markup. TOM-SSL (AgriEngineering, 2025) uses pseudolabeling and 10% of annotated data: 72.51% (PlantVillage-tomato subset) and 70.87% (Taiwan) were obtained, which is lower than SOTA in accuracy but significantly higher in “label-efficiency”. We have a 93% accuracy on a fully labeled dataset and a simple, low-cost model (without the complications of pseudo-labeling).

Thus, refs. [31,32,33,34] are impressive: the Siamese CNN from [31] and the ViT/CNN hybrid from [7] improve SOTA accuracy on standard datasets; study [33] carefully compares the CNN family in terms of quality and resources; and the semi-supervised approach [34] convincingly reduces the cost of labeling. These results move the field forward and set strong benchmarks (accuracy, scale, and label-efficiency).

What makes our work different:

➢

CPU efficiency and low memory usage: the model performs full inference without a GPU, enabling rapid deployment on laptops or edge devices in farms and greenhouses.

➢

Interpretability: combining texture–geometric descriptors with XGBoost provides clear feature importance via SHAP, making results easy for agronomists to understand.

➢

Practical relevance: the model predicts five ordinal stages of late blight severity, offering a more precise assessment of leaf damage than simple disease-type classification.

➢

Robust validation and reproducibility: model performance is confirmed using K-fold GridSearchCV, classification reports, confusion matrices, and ablation studies.

Balanced accuracy and usability: achieving a 93% accuracy, our method sacrifices a small fraction (2–7%) compared to the highest-performing SOTA approaches but gains significantly in inference speed, memory efficiency, and deployability; unlike semi-supervised methods such as [34], our pipeline remains simple while maintaining high accuracy.

Compared to these state-of-the-art methods, including Siamese CNN, EfficientNetV2 + Swin Transformer, and semi-supervised frameworks, our XGBoost approach achieves competitive accuracy while drastically reducing computational resources. Unlike deep learning-based models, our method can be deployed on a CPU with minimal memory, and it maintains interpretable outputs through SHAP analysis of texture–geometric descriptors. Additionally, our approach focuses on classifying five ordinal stages of late blight, providing an actionable severity assessment rather than just disease type.

In summary, refs. [31,32,33,34] set strong benchmarks for maximum accuracy and annotation efficiency, but our innovation lies in a lightweight, interpretable, and easily deployable pipeline for real-world greenhouse conditions with a transparent methodology.

3. Materials and Methods

The overall workflow of the proposed system is summarized in Figure 1. Starting from an RGB image of a tomato leaf, the pipeline performs preprocessing, segmentation and morphological filtering; extracts a compact set of texture–geometric features and normalizes them; and finally applies an XGBoost classifier with tuned hyperparameters to predict the late blight severity class.

3.1. Formalization of the Problem

Otsu’s method is an algorithm that automatically determines the optimal global threshold $t^{*}$, dividing the image into two classes:

✓

Class 1 (background)—intensities $I\le t^{*}.$

✓

Class 2 (object)—intensities $I<t^{*}$.

Otsu seeks a threshold t that maximizes the interclass variance ${\sigma }_b^2\left(t\right)$, that is, the classes should be as distinguishable as possible [10].

Let $P\left(i\right)$ is the probability of occurrence for pixels of level $i$ and $N$ is the total number of pixels, ${\sum }_{i=0}^{L-1}P\left(i\right)=1$. Splitting into two classes for any chosen threshold t of class probabilities:

$$w_1\left(t\right)={\sum }_{i=0}^{t}P\left(i\right), w_2\left(t\right)={\sum }_{i=t+1}^{t}P\left(i\right),$$

(1)

Average intensities of classes:

$${\mu }_1\left(t\right)={\displaystyle \frac{{\sum }_{i=0}^{t}iP\left(i\right)}{w_1\left(t\right)}}, {\mu }_2\left(t\right)={\displaystyle \frac{{\sum }_{i=t+1}^{t}iP\left(i\right)}{w_2\left(t\right)}}$$

(2)

Overall average:

$${\mu }_T={\sum }_{i=0}^{L-1}iP\left(i\right)$$

(3)

Between-class and within-class variance and between-class variance (goal to maximize):

$${\sigma }_b^2=w_1(t)w_2(t){\left[{\mu }_1\left(t\right){\mu }_2\left(t\right)\right]}^2$$

(4)

Intraclass variance (goal to minimize):

$${\sigma }_w^2\left(t\right)=w_1\left(t\right){\sigma }_1^2\left(t\right)+w_2\left(t\right){\sigma }_2^2\left(t\right)$$

(5)

Otsu chooses $t^{*}$ that maximizes ${\sigma }_b^2\left(t\right)$ or equivalently minimizes ${\sigma }_w^2\left(t\right)$. The final rule:

$$t^{*}=\underset{t}{\mathrm{a}\mathit{rg}\max }{\sigma }_b^2\left(t\right)$$

(6)

Figure 2 illustrates the image preprocessing and segmentation process using the Otsu thresholding method. The original leaf image is shown in Figure 2a, the resulting binary segmented image in Figure 2b, and the corresponding grayscale intensity histogram with the selected Otsu threshold in Figure 2c.

3.2. Textural and Contour Characteristics

3.2.1. Contrast

This is the standard deviation of pixel brightness. It shows the spread of brightness; the greater the contrast, the greater the difference between dark and light areas. If the contrast is low, the image is too washed out or dark and can be discarded [7].

Root-mean-square deviation:

$$\sigma =\sqrt{{\displaystyle \frac{1}{n}}{\sum }_{i=1}^k{(x_i-\overline{x})}^2{n}_i}$$

(7)

where $x_i$ is the pixel brightness, $\overline{x}$ is the average pixel brightness and $\left(\overline{x}={\displaystyle \frac{1}{n}}{\sum }_{i=1}^k{x}_i{n}_i\right)$, $n_i$ is the pixel number.

3.2.2. Num Contours

This is the number of closed objects found in the binarized image. Let the sets of points $C_i$ lie on the boundary of the object and spots [8]:

$$C_i=\left\{\left(x,y\right)|I\left(x,y\right)=1˄\exists \left(x^{\prime },y^{\prime }\right)ϵN\left(x,y\right):I\left(x^{\prime },y^{\prime }\right)=0\right\}$$

(8)

where $N\left(x,y\right)$ is a set of neighboring points, a point is considered a contour point if it belongs to the object $I\left(x,y\right)=1$, and there is at least one background pixel nearby, $I\left(x^{\prime },y^{\prime }\right)=0$.

Grouping points into separate contours:

$$C_i=\left\{\left(x_{i1},y_{i1}\right),\left(x_{i2},y_{i2}\right),\dots ,\left(x_{ik},y_{ik}\right)\right\}$$

(9)

where $i$ is the contour number and, $k$ is the number of points in this contour. The number of contours is the cardinality of the set of all contours found.

The number of contours is the power of the set of all contours found:

$$K=\left|\left\{C_i|i=\mathrm{1,2},\dots ,n\right\}\right|$$

(10)

3.2.3. Mean Contour Area

Average area of all contours found. After all contours $C_1,C_2,\dots ,C_n$ have been found, the area is calculated for each [9]. For contour $C_i$, which is represented by the sequence of points from Formula (11), the area is calculated:

$$A_i={\displaystyle \frac{1}{2}}\left|{\sum }_{j=1}^k\left(x_{ij}·y_{i(j+1)}-x_{i\left(j+1\right)}·y_{ij}\right)\right|$$

(11)

where $k$ is the number of points in the contours, $\left(x_{i(k+1)},y_{i(k+1)}\right)=\left(x_{i1},y_{i2}\right)$ is the closed contour. The average area of all contours if n contours are found, and the average area is calculated:

$$m={\displaystyle \frac{1}{n}}{\sum }_{i=1}^n{A}_i$$

(12)

where $A_i$ is square $i$-th contour.

3.2.4. Standard Contour Area

Formula:

$${\sigma }_A=\sqrt{{\displaystyle \frac{1}{n}}{\sum }_{i=1}^n{\left(A_i-{\mu }_A\right)}^2}$$

(13)

where $A_i$ is the area of the $i$-th contour and ${\mu }_A$ is the average area $\left({\mu }_A={\displaystyle \frac{1}{n}}\sum A_i\right)$.

This shows how much the areas of the contours differ. A larger standard deviation means that there are spots of different sizes.

3.2.5. Mean Contour Perimeter

Formula:

$$\mathfrak{R}={\displaystyle \frac{1}{n}}{\sum }_{i=1}^n{P}_i$$

(14)

where $P_i$ is thelength of the border, $i$ is the contour, and $n$ is the number of contours.

From there

$$P={\sum }_{i=1}^n\sqrt{{\left(x_{i+1}-x_i\right)}^2+{\left(y_{i+1}-y_i\right)}^2}$$

(15)

Average value of perimeters. And the large perimeter of the contour about the complex shape of the spots.

3.2.6. Standard Contour Perimeter

Formula:

$${\sigma }_P=\sqrt{{\displaystyle \frac{1}{n}}{\sum }_{i=1}^n{\left(P_i-{\mu }_P\right)}^2}$$

(16)

where $P_i$ is the perimeter of the $i$-th contour and ${\mu }_P$ is the average perimeter. If the spread of values is large, it means the spots on the leaves have different shapes.

3.2.7. Mean Area to Perimeter Ratio

Formula:

$$\phi ={\displaystyle \frac{1}{n}}{\sum }_{i=1}^n{R}_i$$

(17)

where $R_i$ is the area ratio

Here

$$R_i={\displaystyle \frac{A_i}{P_i}}$$

(18)

where $A_i$ is the area of the contour and $P_i$ is the perimeter of the contour. If $R$ is greater, the closer the shape of the spots is to a circle. If $R$ is smaller, the spots have uneven edges. The geometric texture descriptor extraction is illustrated in Figure 3.

3.2.8. Normalization Signs

The calculation of the area of the object in the image and the allocation of its informative features is carried out as follows [10]:

• − Contrast;
• − Num contours;
• − Mean contour area;
• − Standard contour area;
• − Mean contour perimeter;
• − Standard contour perimeter;
• − Mean area to perimeter ratio.

These parameters are in each column with an image characteristic that can be extracted from images and used for analysis and recognition in vector values. Combining different features and analyzing them using different image processing and machine learning techniques allows us to create more accurate, faster and more efficient image recognition systems.

After identifying informative features, each feature is normalized in a range from 0 to 1 according to Formula (10) [11]:

$$I_{i,j}^{normal}={\displaystyle \frac{I_{i,j}-I_{i,j}^{min}}{I_{i,j}^{max}-I_{i,j}^{min}}}$$

(19)

where $I_{i,j}^{normal}$ is normalized values, $I_{i,j}$ is input values in the column, and $I_{i,j}^{max}$,$I_{i,}^{min}$ are the minimum and maximum values of the column.

3.3. XGBoost (Extreme Gradient Boosting)

To improve forecasting accuracy, ensemble methods are used by using multiple primary learners [12]. The basic idea is to train each individual model on multiple datasets and average the results to achieve better model generalization. At the same time, by averaging the results of several models, differences and/or biases in classification can be reduced. In this case, noise, variance, and bias are the causes of the difference between observed and expected values. The ensemble method helps to reduce these variations and deviations.

The most common ensemble methods are bagging and boosting:

Bagging: The main goal of bagging is to reduce the large variance in the model. Decision trees help reduce variance and also have a low variance. Bagging involves creating smaller data sets from a main data set using multiple subsamples. The data from each subset is then placed into separate decision trees, which helps prevent each tree from overfitting the data. The accuracy of the model during bagging depends on the number of decision trees used, and the results are summarized.

Boosting: In boosting, trees are built sequentially, and each subsequent tree tries to reduce the errors of the previous tree. With this approach, weak learners at each stage learn from the mistakes made in previous trees and transfer this information to the new tree. Weak learners exhibit slightly higher accuracy than random guesses, and each one adds small but useful information that can be combined to form a strong learner [14].

The idea of bagging is to form $T$ independent simple algorithms and calculate the output value as an average of the responses from each of them:

$$a\left(x\right)={\displaystyle \frac{1}{T}}{\sum }_{i=1}^T{a}_i\left(x\right)$$

(20)

To emphasize that this approach will be effective if the algorithms’ responses are statistically independent of each other, the constraint can be written as follows:

$$E\left\{a_j\left(x\right)·a_i\left(x\right)\right\}=0, ⩝i,j:i\ne j$$

(21)

But there are two subtle points in this scheme:

➢

$a_1\left(x\right), a_2\left(x\right), \dots , a_T\left(x\right)$ produce somewhat dependent values (in general, complete independence is impossible to achieve);

➢

They are weighted with the same weighting coefficient ${\displaystyle \frac{1}{T}}$ that is, the significance of each is assumed to be equal.

These are very strict conditions and can be considered to be always violated when implementing bagging. This means that potential quality is not achieved when composing algorithms:

$$a\left(x\right)={\sum }_{t=1}^T{\alpha }_t·b_t\left(x\right)$$

(22)

where $\left\{{\alpha }_t\right\}$ are weights (positive numbers), $\left\{b_t\left(x\right)\right\}$ are simple algorithms for processing the input vector $x$. The algorithms produce a real value $b_t\left(x\right) ϵ\mathbb{R}$. In classification problems, this can be the margin value, which for linear algorithms is defined as the scalar product, $M=〈\omega ,x〉={\omega }^T·x$. That is, the algorithms $\left\{b_t\left(x\right)\right\}$ produce non-rigid (final) solutions, but a more accurate (intermediate) real value.

When combining algorithms according to Formula (22), weighting coefficients are calculated, and a set of T algorithms is constructed so that a given quality indicator is minimized. For the sake of clarity, the next task will be a binary classification. Then, it is logical to choose the quality indicator as the number of incorrectly classified images [16]:

$$Q_T={\sum }_{i=1}^l\left[M_i<0\right]={\sum }_{i=1}^l\left[y_i·a\left(x_i\right)<0\right]={\sum }_{i=1}^l\left[y_i· \underset{a\left(x_i\right)}{\underbrace{{\sum }_{t=1}^T{\alpha }_t{b}_t\left(x_i\right)<0}}\right]$$

(23)

when the offset for the $i$-th image is less than zero ($M_i<0$), a classification error has occurred, and the square brackets (Iverson notation) will return $1$. Otherwise, $0$ is returned.

There are no hard restrictions on the algorithms $b_t\left(x_i\right)$ and the weighting coefficients ${\alpha }_t$. The only thing is that weighting coefficients are usually taken as positive.

It is necessary to optimize both in terms of weights and algorithms:

$$Q_T= {\sum }_{i=1}^l\left[y_i·{\sum }_{t=1}^T{\alpha }_t{b}_t\left(x_i\right)<0\right]\to \underset{\left\{{\alpha }_i\right\},\left\{b_j\right\}}{\min }{Q}_T$$

(24)

But this is a rather complex mathematical problem, so Freund and Shapiro proposed using the following two heuristics:

• “Greedy” construction of the composition is the search (selection) of the current algorithm $b_t$ and the weight factor ${\alpha }_t$ while fixing the previously found algorithms and weight factors, $b_1\left(x\right), \dots , b_{t-1}\left(x\right)$ and ${\alpha }_1, \dots , {\alpha }_{t-1}$. That is, at each step $t$ is calculated as only one weighting coefficient ${\alpha }_t$ and can train only one algorithm $b_t$ predominantly on those training set images on which the previous algorithms showed weak results [17].
• A threshold quality functional in the form of a smooth differentiable loss function, which will allow solving the optimization problem using numerical or analytical methods [18].

These two approaches form the basis of almost all boosting algorithms. That is, it attempts to construct $T$ relatively simple algorithms (classification or regression) and then calculate a weighted sum of their outputs to improve the resulting value according to a chosen quality metric. This is the point of algorithm boosting.

• Adaptive Boosting (AdaBoost)

AdaBoost applied to binary classification problems with class labels $Y= \left\{-1,+1\right\}$. Boosting trains $T$ algorithms and then computes a weighted sum [19]:

$$a\left(x\right)={\sum }_{i=1}^T{\alpha }_i{b}_i\left(x\right)$$

(25)

Moreover, the search for weights and algorithms is performed according to the “greedy” principle, and all previously found elements, $b_1\left(x\right), \dots , b_{T-1}\left(x\right)$ and ${\alpha }_1, \dots , {\alpha }_{T-1}$, are recorded to find the current $b_T\left(x\right)$ and ${\alpha }_T$. When solving a regression problem, the quality criterion is usually formed using a quadratic loss function:

$$Q_T={\displaystyle \frac{1}{2}}{\sum }_{i=1}^l{\left(y_i-a\left(x_i\right)\right)}^2\to min$$

(26)

That is, the training sample goes through all the objects of $X^l=\left\{{\left(x_i,y_i\right)}_{i=1}^l\right\}$ and calculates the sum of the squares of the errors. If the value of a(x) is written into Formula (26), it will change as follows [20]:

$$Q_T={\displaystyle \frac{1}{2}}{\sum }_{i=1}^l{\left(y_i-{\sum }_{j=1}^T{\alpha }_j{b}_j\left(x_i\right)\right)}^2={\displaystyle \frac{1}{2}}{\sum }_{i=1}^l{\left(\underset{S_{i,T-1}}{\underbrace{y_t-{\sum }_{j=1}^{T-1}{b}_j(x_i)}-b_T(x_i)}\right)}^2$$

(27)

Here it can be noted that, firstly, in linear regression problems, the factors $\left\{{\alpha }_j=1\right\}$ can be discarded, since they only determine the scale of the output responses of the algorithms. This scale can be formed by the algorithm itself, $\widetilde{b_J}\left(x\right)={\alpha }_i{b}_i\left(x\right)$. And secondly, given fixed previous weights and algorithms, at step $T$ the residual values are minimized:

$$S_{i,T-1}=y_i-{\sum }_{j=1}^{T-1}{b}_j\left(x_i\right), i=\mathrm{1,2},\dots ,l$$

(28)

It is necessary to decide on the choice of the family of algorithms {$b_j\left(x_i\right)$} for the regression problem. A common case is decision trees, as in classification problems. In general, boosting over crucial trees is a classic and the most common way of using it. Although, there are other algorithm families to choose from, for example, a set of linear algorithms, etc. The main thing is that these algorithms can be formed and then used relatively quickly (from a computational point of view) [21].

Thus, if decision trees are chosen, then in regression problems, with a quadratic loss function, the leaves store the average values of the target labels $\left\{y_i\right\}$ of the objects that fall into them. If the $M$ objects $R_v=\left\{{\left(x_i,y_i\right)}_{i=1}^M\right\}$ of the training sample have reached some leaf node, then the optimal value for their description can be found from the equation:

$$Q={\displaystyle \frac{1}{2}}{\sum }_{ie{R}_v}{\left(y_i-c\right)}^2\to min, {\displaystyle \frac{dQ}{dc}}={\sum }_{ie{R}_v}\left(y_i-c\right)=0$$

(29)

Here, $c={\displaystyle \frac{1}{\left|R_v\right|}}\sum _{ie{R}_v}{y}_i$.

With a different loss function, the value of $c$ can be calculated differently. As a result, the pseudocode of the AdaBoost algorithm as applied to regression problems will look like this:

Input: training sample $X^l$ and parameter $T$ (number of algorithms in the composition). Output: set of basic algorithms $b_1\left(x\right), \dots , b_T\left(x\right)$ [22].

➢

Initialization of residues: $S_{i,0}=y_i,i=\mathrm{1,2},\dots ,l$;

➢

For all $t=\mathrm{1,2},\dots ,T$;

➢

Find the best current algorithm using the rule: $b_t=\underset{b_l}{\mathrm{a}\mathit{rg}\min } Q_t$,

➢

Update balances: $S_{i,t}=S_{i,t-1}-b_t\left(x_i\right)$.

Different problems use different loss functions in the composition quality functional:

$$Q_T\left(\alpha ,b\right)={\sum }_{i=1}^{l}L(a\left(x\right),y_i)\to \underset{\alpha ,b}{\min } Q_T$$

(30)

according to the training sample $X^l=\left\{{\left(x_i,y_i\right)}_{i=1}^l\right\}$. Thus, in a binary classification problem, the AdaBoost algorithm uses an exponential loss function, and in a regression problem, it uses a quadratic loss function. Other loss functions allow us to obtain other well-known boosting algorithms in Figure 4:

• $E\left(M\right)=\mathrm{e}\mathrm{x}\mathrm{p}(-M)$—exponential (AdaBoost);
• $L\left(M\right)={\log }_2\left(1+e^{-M}\right)$—logarithmic (LogitBoost);
• $Q\left(M\right)={\left(1-M\right)}^2$—quadratic (GentleBoost);
• $G\left(M\right)=\mathrm{e}\mathrm{x}\mathrm{p}(-cM·(M+s\left)\right)$—Gaussian (BrownBoost).

One can come up with many other functions for developing (synthesizing) new boosting algorithms [23]. A universal boosting algorithm that would work with an arbitrary smooth and differentiable loss function is called gradient boosting. Gradient boosting has become one of the standard tools for trying to solve a particular machine learning problem. The principles of gradient boosting are a fragment of its derivation from Formula (31),

$$a\left(x\right)={\sum }_{i=1}^T{\alpha }_i,b_i\left(x\right)$$

(31)

and the choice of the quality functional for searching for weights ${\alpha }_i$ and specific algorithms $b_i\left(x\right)$. It can be written in general form through some loss function $L(a\left(x_i\right),y_i)$ [24].

$$Q\left(\alpha ,b\right)={\sum }_{i=1}^{l}L\left(\underset{f_{T,i}}{\underbrace{\underset{f_{T-1,i}}{\underbrace{{\sum }_{t=1}^{T-1}{\alpha }_t{b}_t\left(x_i\right)}+\alpha b\left(x_i\right),y_i}}}\right)\to \underset{\alpha ,b}{\min } Q(\alpha ,b)$$

(32)

Here, a composition is immediately written through ($T-1$) already known algorithms (found in the previous ($T-1$) steps) and the current $b\left(x_i\right)$ with some (still unknown) weight $\alpha$. These two elements must be found here from the condition of the minimum of the functional $Q(\alpha ,b)$. What is implemented here is a “greedy” strategy for searching algorithms: all previously found algorithms $b_1,\dots , b_{T-1}$ and weight coefficients ${\alpha }_1,\dots ,{\alpha }_{T-1}$ are fixed and no longer change [25]. The outputs of the composition are denoted according to ($T-1$) algorithms for each pattern $\left\{x_i\right\}$ of the training sample by the vector $f_{T-1}{\left[f_{T-1.1},f_{T-1.2},\dots ,f_{T-1,l}\right]}^T$. And the outputs for all $T$ algorithms are through the vector $f_T{\left[f_{T,1},f_{T,2},\dots ,f_{T,l}\right]}^T$. And at the next step, $T$ must choose a vector $f_T$, that would reduce the value of the quality functional $Q(\alpha ,b)$ compared to the previous vector $f_{T-1}$. The description of the operation of the gradient algorithm and the gradient of the loss function:

$$g_i={\displaystyle \frac{\partial L(f_{T-1,i},y_i)}{\partial f_{T-1,i}}}=L^{\prime }\left(f_{T-1,i},y_i\right), i=\mathrm{1,2},\dots ,l$$

(33)

That the correction of the $i$-th component can be written as follows:

$$f_{T,i}=f_{T-1,i}-\alpha g_i$$

(34)

In the formula (according to the composition of the algorithms), this same adjustment looks like this:

$$f_{T,i}=f_{T-1,i}+\alpha {b(x}_i)$$

(35)

The similarities are obvious. And since the coefficient $\alpha >0$, then the algorithm ${b(x}_i)$ at the current step $T$ should produce values as close as possible to the antigradient of the loss:

$$b_T=\underset{b}{\mathrm{a}\mathit{rg}\min }{\sum }_{i=1}^l{\left(b\left(x_i\right)+g_i\right)}^2$$

(36)

Here, a quadratic function is used as a measure of the closeness of the $i$-th values, and everything is summed up over the training sample; decision trees for regression problems often use this criterion by default.

Find the best algorithm $b_T$ at step $T$, knowing the gradient of the loss function and solving the least squares problem. And the last thing that remains is to calculate (find) the weighting coefficient ${\alpha }_T$. Since a general problem with an arbitrary loss function, the search for this weighting coefficient is reduced to the following one-dimensional optimization problem:

$${\alpha }_T=\underset{\alpha >0}{\mathrm{a}\mathit{rg}\min }{\sum }_{i=1}^{l}L\left(f_{T-1,i}+\alpha b_T\left(x_i\right),y_i\right)$$

(37)

It can be solved fairly quickly using numerical methods. Modern optimization methods can easily handle this (for example, the bisection method).

Input: training sample $X^l$ and parameter $T$ (number of algorithms in the composition). Output: a set of base algorithms $b_1\left(x\right),\dots ,b_T\left(x\right)$ and weights ${\alpha }_1,\dots ,{\alpha }_T$

➢

Initialization: $f_i=0,i=1,\dots ,l$

➢

For all $t=1,\dots ,T$;

➢

Find the best current algorithm that approximates the antigradient: $b_t=\underset{b}{\mathrm{a}\mathit{rg}\min }{\sum }_{i=1}^l{\left(b\left(x_i\right)+g_i\right)}^2$;

➢

Find the weighting coefficient: Formula (37);

➢

Update the vector of values on the sample objects: $f_i=f_i+{\alpha }_t{b}_t\left(x_i\right),i=\mathrm{1,2},\dots ,l$.

3.4. Grid Search

In the grid of hyperparameters, there are $J$ hyperparameters, each given a finite set of values [26]:

$${\mathsf{\Theta }}_j=\left\{{\theta }_{j,1},\dots ,{\theta }_{j,m_j}\right\}, j=1,\dots ,J$$

(38)

The Cartesian product forms a grid:

$$\left|\mathsf{\Theta }\right|=\prod _{j=1}^J{m}_j, \Theta ={\mathsf{\Theta }}_1·,\dots ,·{\mathsf{\Theta }}_J$$

(39)

Training operator (abstract): Let $A(D;\theta )$ is an operator that, given data $D$ and a setting $\theta \in \Theta$, returns a trained model $f_{\theta }$.

Evaluation metric: Let $S(f,D_{val})$ is a scalar quality metric (the higher the better) calculated on the validation data $D_{val}$.

$K$—fold (stratified) cross-validation: The training set D is split into K disjoint folds of indices $S_1,\dots ,S_K$ (class proportions are preserved during stratification). For each $\theta \in \Theta$ a CV score is determined [27]:

$$\widehat{S_{CV}}\left(\theta \right)={\displaystyle \frac{1}{K}}{\sum }_{k=1}^{K}S\left(A\left({\displaystyle \frac{D}{S_k}},\theta \right),S_k\right)$$

(40)

The model is trained on ${\displaystyle \frac{D}{S_k}}$ and tested on $S_k$.

Hyperparameter selection criterion: Finds the grid point that maximizes the average CV score:

$${\theta }^{*}=arg\underset{\theta \in \Theta }{\max }\widehat{S_{CV}}\left(\theta \right)$$

(41)

The final model: After selecting ${\theta }^{*}$ the model is retrained on all available training data:

$$f_{{\theta }^{*}}=A(D,{\theta }^{*})$$

(42)

Counting the number of training runs and the complexity and the number of training runs for $K$-fold:

$$N_{fits}=\left|\Theta \right|·K$$

(43)

and time costs are scaled as: $O(\mid \Theta \mid \cdot K\cdot time\_train(\theta \left)\right)$.

In this work, XGBoost is used to classify tomato leaf images into five levels of late blight damage. Each data instance is a vector of texture descriptors that forms the input space X. The model is trained on the labeled sample and then predicts the probability that pixels or images belong to the corresponding disease class.

3.5. Evaluation Metrics

To evaluate the effectiveness of the proposed approach based on the XGBoost algorithm, standard machine learning indicators are used: accuracy, precision, responsiveness, and F1 score. These indicators allow us to comprehensively assess the accuracy of the classification [28,35].

The metrics are based on four possible classification outcomes:

• $TP$ (True Positive)—a correctly identified diseased tomato leaf (the algorithm correctly classified the disease);
• $TN$ (True Negative)—a correctly identified healthy tomato leaf (the algorithm correctly classified it as “healthy”);
• $FP$ (False Positive)—a healthy leaf is mistakenly identified as diseased (false positive);
• $FN$ (False Negative)—a diseased leaf is mistakenly identified as healthy (missed disease).

• Accuracy (Overall accuracy)

Shows the proportion of correctly classified examples [29,36]:

$$Accuracy={\displaystyle \frac{TP+TN}{TP+TN+FP+FN}}$$

(44)

• Precision (Positive Class Accuracy)

Characterizes the reliability of the prediction:

$$Precision={\displaystyle \frac{TP}{TP+FN}}$$

(45)

• Recall (Recall, Sensitivity)

Determines which part was correctly recognized:

$$Recall={\displaystyle \frac{TP}{TP+FN}}$$

(46)

• F1-score (Balanced Metric)

Allows simultaneous consideration of precision and recall:

$$F1=2·{\displaystyle \frac{Precision·Recall}{Precision+Recall}}$$

(47)

4. Results

The XGBoost algorithm was proposed as the primary classifier, allowing for the effective classification of tomato leaf condition classes based on a combination of textural and contour-geometric features: contrast, number of contours, mean and standard values of contour areas and perimeters, and area-to-perimeter ratios. To form the sample, images of healthy and diseased leaves (by stage) were collected and labeled, after which the specified descriptors were extracted and normalized.

4.1. Formation of Input Data

For this study, we created our own dataset of tomato leaf images. RGB photographs were acquired in greenhouse conditions in Uzbekistan using a Samsung Galaxy S22 Ultra (Samsung, South Korea) smartphone. The main camera has a 108 MP sensor (f/1.8) with a maximum photo resolution of 12,000 × 9000 pixels. Additional cameras include a 12 MP ultra-wide and two 10 MP telephoto lenses (3× and 10× optical zoom). Natural illumination was used, with approximate brightness ranging between 400 and 600 lux. The images contain single leaves on heterogeneous backgrounds (soil, sky, and greenhouse equipment) and exhibit realistic variability in focus, angle, scale, and leaf orientation.

Each image was annotated by an agronomist into one of five late blight severity classes according to the percentage of visibly affected leaf area:

-

Class 0—healthy leaf (0% infection);

-

Class 1—initial stage (0.1–10% of the leaf surface affected);

-

Class 2—moderate stage (11–25%);

-

Class 3—middle stage (26–50%);

-

Class 4—severe stage (≥51% with expected yield loss).

Late blight (Phytophthora infestans) is a major tomato disease in Uzbekistan, significantly affecting local crop yields and potentially reducing them by 60–70% if not detected at an early stage. Given the severity of its impact on Uzbek tomato production, traditional diagnostic methods, including visual inspection and laboratory testing, are time-consuming and rely heavily on specialist expertise, which limits their practicality for large-scale production systems. In total, the dataset contains 5245 images of tomato leaves. To evaluate the model, the data was randomly divided into training and test parts in an 80/20 ratio with class stratification, resulting in 4129 training images and 1049 test images. This dataset is used throughout the experimental section to train, validate, and test all the models being compared. Some example images from the dataset are shown in Figure 5.

The next step involves pre-processing the image using Otsu’s method to separate areas of the leaf by intensity and highlight the affected areas as illustrated in Figure 6.

4.2. Formation of a Vector Training Sample

As a result of processing the images of tomato leaves, a training sample was formed for the $T_{nml}$, in

Table 1. Fragments of the training sample.

Objects	${\mathit{x}}_1$	${\mathit{x}}_2$	${\mathit{x}}_3$	${\mathit{x}}_4$	${\mathit{x}}_5$	${\mathit{x}}_6$	${\mathit{x}}_7$	Classes
${\mathit{S}}_1$	37.36588247504914	745	41.673154362416106	1096.1588095661043	8.330579827295853	83.11645492742072	0.0698983762629732	$K_1$
${\mathit{S}}_1$	49.92771511928245	75	799.96	6858.56285225994	45.5727153412501	309.37147289112323	0.3879013626354471	$K_1$
${\mathit{S}}_2$	44.800203163762916	1070	31.04252336448598	921.8226545107976	11.55998361277803	133.91557719418205	0.05231692861451514	$K_2$
${\mathit{S}}_2$	35.32940780603492	1242	26.27012882447665	897.8260553703684	6.992370426366871	103.71063206434167	0.032662478234222254	$K_2$
${\mathit{S}}_3$	36.33191702294344	1291	25.538729666924866	884.1931264970506	6.707476758938442	91.27237081140451	0.03187086575374872	$K_3$
${\mathit{S}}_3$	51.038177014839626	830	37.859638554216865	1050.186030793863	10.271922461239688	145.63491861360953	0.0476645162238748	$K_3$
${\mathit{S}}_4$	51.80684926493237	507	61.18836291913215	1344.0553293395762	11.741234552460545	125.64160858519503	0.058907243655364615	$K_4$
${\mathit{S}}_4$	38.43759350132606	1107	28.365853658536587	907.861229755167	6.858337591118714	73.44108053326875	0.04048500480098933	$K_4$
${\mathit{S}}_5$	39.368361543602774	1240	25.12983870967742	848.3892383064318	6.508126003223081	76.17733156444132	0.038053655871191874	$K_5$
…	…	…	…	…	…	…	…	…
${\mathit{S}}_{\mathit{m}}$	$x_n$	$x_n$	$x_n$	$x_n$	$x_n$	$x_n$	$x_n$	$K_l$

, containing both textural and geometric features, where $T$ is the training sample, $n$ are the features, $s$ are the objects, and $K$ are the classes. This sample is further used for training and testing machine learning models.

Each record of the training sample is a feature vector that includes the following parameters.

• Signs
• Textural and contour characteristics:

✗

$x_1=$ contrast;

✗

$x_2=$ num_contours;

✗

$x_3=$ mean_contour_area;

✗

$x_4=$ std_contour_area;

✗

$x_5=$ mean_contour_perimeter;

✗

$x_6=$ std_contour_perimeter;

✗

$x_7=$ mean_area_to_perimeter_ratio.

Objects:

✗

$S_1=$ healthy leaf;

✗

$S_2=$ 0.1–10% (initial stage);

✗

$S_3=$ 11–25% (moderate stage);

✗

$S_4=$ 26–50% (middle stage);

✗

$S_5=$ more 51% (severe stage with loss of yield).

Classes:

✗

${\mathrm{K}}_1=$ 0–0% infection.

✗

${\mathrm{K}}_2=$ 1–0.1–10% infection rate.

✗

${\mathrm{K}}_3=$ 2–11–25% infection rate.

✗

${\mathrm{K}}_4=$ 3–26–50% infection rate.

✗

${\mathrm{K}}_5=$ 4–51% + infection rate.

4.3. Normalization of Training Sample Features

To ensure the correct functioning of the machine learning model, all numerical features of the training sample were subjected to a normalization procedure. This operation is necessary because the features have different ranges of values. The use of normalization allows:

• Reduce the influence of features with large numerical ranges on the model error function;
• Speed up the convergence of gradient learning methods;
• Improve the robustness and accuracy of classification.

• Normalization method

In this work, linear normalization (Min–Max Scaling) is used, which transforms the values of each feature $x$ to the range $\left[\mathrm{0,1}\right]$ as given in

Table 2. Fragment of the training sample after normalization.

Objects	${\mathit{x}}_1$	${\mathit{x}}_2$	${\mathit{x}}_3$	${\mathit{x}}_4$	${\mathit{x}}_5$	${\mathit{x}}_6$	${\mathit{x}}_7$	Classes
${\mathit{S}}_1$	0.52	0.002	0.019	0.022	0.214	0.002	0.794	$K_1$
${\mathit{S}}_1$	0.319	0.005	0.042	0.046	0.326	0.004	0.754	$K_1$
${\mathit{S}}_2$	0.267	0.006	0.049	0.032	0.161	0.015	0.701	$K_2$
${\mathit{S}}_2$	0.246	0.007	0.052	0.036	0.164	0.016	0.703	$K_2$
${\mathit{S}}_3$	0.576	0.002	0.019	0.022	0.218	0.001	0.861	$K_3$
${\mathit{S}}_3$	0.349	0.005	0.037	0.038	0.203	0.006	0.777	$K_3$
${\mathit{S}}_4$	0.075	0.046	0.231	0.091	0.441	0.021	0.91	$K_4$
${\mathit{S}}_4$	0.75	0.001	0.012	0.018	0.126	0.002	0.943	$K_4$
${\mathit{S}}_5$	0.809	0.016	0.084	0.104	0.537	0.009	0.5	$K_5$
…	…	…	…	…	…	…	…	…
${\mathit{S}}_{\mathit{m}}$	$x_n$	$x_n$	$x_n$	$x_n$	$x_n$	$x_n$	$x_n$	$K_l$

:

• Using normalized data:

After normalization, all features form a single vector $X_i^{\prime }=[x_1^{\prime },x_2^{\prime },\dots ,x_n^{\prime }]$, which is fed to the classifier as input. This approach allows the model to equally consider both fractal and textural–geometric characteristics without a bias toward features with larger initial ranges.

4.4. Classification

This study implemented an experiment to classify images of tomato leaves using the XGBoost algorithm.

• Description of the experiment:

✓

The XGBoost classification algorithm was trained on 80% of the sample, and the remaining 20% were used for testing;

✓

Grid Search;

✓

Model evaluation (metric);

✓

Confusion matrix (test).

Figure 7 shows a heatmap of the cross-validation accuracy (CV Accuracy) when changing the max_depth and n_estimators hyperparameters for XGBoost; the best result (0.93) is achieved with max_depth = 5 and n_estimators = 400.

The results in

Table 3. Model evaluation (metric).

	Precision	Recall	F1-Score	Support
0	0.97	0.97	0.97	321
1	0.91	0.93	0.92	120
2	0.95	0.85	0.90	142
3	0.91	0.95	0.93	258
4	0.92	0.92	0.92	208
Accuracy			0.93	1049
Macro avg	0.93	0.92	0.93	1049
Weighted avg	0.93	0.93	0.93	1049

show that the proposed model maintains a high and balanced performance across all five severity classes. The lowest F1-score (0.90) is obtained for class two, which corresponds to the visually ambiguous transition between early and middle stages of infection.

The classification performance of the proposed model is illustrated in Figure 8, which presents the confusion matrix summarizing the prediction results across different classes.

After classification, each test sample was assigned to one of five tomato leaf disease severity classes. The results demonstrated the high accuracy of the XGBoost model and consistent discrimination between healthy and diseased samples at all stages of late blight development.

• Comparison with existing methods

We compare our CNN method (Siamese-CNN), the EfficientNetV2 + Swin hybrid model, and classical algorithms (SVM, Random Forest, k-NN, Logistic Regression) using the same data partitioning and the same metrics (accuracy, macro-F1, F1 per class), as well as measuring inference time and peak CPU memory consumption in

Table 4. Comparison of the proposed XGBoost method with baseline models.

Method	Dataset/Split	Accuracy	Macro-F1	Inference Time/Frame	Peak RAM
XGBoost (proposed)	Own dataset (5-fold cross-validation, 80/20 split)	0.93	0.93	≈35 мc	≈120 MB
SVM (RBF)	Own dataset (5-fold cross-validation, 80/20 split)	0.88	0.87	≈70 мc	≈210 MB
Random Forest	Own dataset (5-fold cross-validation, 80/20 split)	0.90	0.89	≈55 мc	≈190 MB
k-NN	Own dataset (5-fold cross-validation, 80/20 split)	0.86	0.85	≈90 мc	≈250 MB
Logistic Regression	Own dataset (5-fold cross-validation, 80/20 split)	0.84	0.83	≈30 мc	≈110 MB
CNN block (control comparison)	Own dataset (5-fold cross-validation, 80/20 split)	0.95	0.94	≈120 мc (GPU)	≈600 MB

. Comparisons with results from other studies are provided only as a guide, as they used different datasets and experimental protocols.

The proposed XGBoost model demonstrates an optimal balance between accuracy and computational efficiency. While achieving classification quality similar to neural network methods, it operates faster and requires significantly fewer resources, making it suitable for implementation in local and mobile plant health monitoring systems.

The architecture in

Table 5. Functional architecture of the proposed XGBoost-based tomato leaf disease recognition system.

Stage No.	Module	Operation/Description	Input/Output	Parameters/Tools	Notes
1	Data Input	Import RGB tomato leaf images from dataset	RGB image (1024 × 1024 px)	OpenCV cv2.resize(), cv2.cvtColor()	Raw image captured under natural light
2	Preprocessing	Resize → convert to grayscale → normalization	Grayscale image [0–1]	OpenCV cv2.resize(), cv2.cvtColor()	Reduces computational cost, standardizes scale
3	Segmentation	Apply global Otsu thresholding to isolate leaf area	Binary mask	cv2.threshold(…, cv2.THRESH_OTSU)	Separates leaf from the background
4	Morphological Filtering	Morphological opening + closing	Clean binary mask	Structuring elements 3 × 3, 5 × 5	Removes noise and small holes
5	Contour Detection	Apply Canny edge detector + dilation	Edge map/contour set	Canny (3 × 3 kernel)	Extracts lesion boundaries
6	Feature Extraction	Compute 7 texture–geometric descriptors: contrast, num_contours, mean/std contour area, mean/std contour perimeter, mean area/perimeter ratio, fractal dimension	Feature vector (7D)	Custom Python feature script (Python 3.13)	Represents leaf texture and lesion geometry
7	Feature Normalization	Normalize features using MinMaxScaler or Z-score	Normalized vector	Scikit-learn MinMaxScaler	Ensures comparable feature scales
8	Classification (XGBoost)	Train XGBoost model with K-fold cross-validation and GridSearchCV	Predicted disease class (0–4)	≈150 trees, learning rate = 0.2	Tuned for optimal accuracy and F1-score
9	Evaluation and Visualization	Generate a confusion matrix, accuracy, and F1-score, and overlay the segmentation mask	Quantitative + visual outputs	matplotlib, seaborn	Visual analysis of correctly and incorrectly classified leaves

reflects the classic structure of an image analysis pipeline. First, leaf segmentation is performed using Otsu’s method and morphological refinement. Then, the contours of the diseased areas are extracted, and the texture and geometric features are identified, normalized, and fed into the conservative XGBoost classifier. The model runs on a CPU, does not require a GPU, and is suitable for use in the field or on simple computer plants.

5. Analysis and Discussion

The optimized XGBoost model on texture–geometric descriptors demonstrated accuracy = 0.93 on the test set and CV-Accuracy ≈ 0.92 (5-fold GridSearchCV), which indicates the stability of the evaluation. The coincidence of macro-F1 = 0.93 and weighted-F1 = 0.93 confirms the uniformity of quality with moderate class imbalance. By class: 0—0.97/0.97/0.97; 1—0.91/0.93/0.92; 2—0.95/0.85/0.90; 3—0.91/0.95/0.93; and 4—0.92/0.92/0.92 (precision/recall/F1). The confusion matrix shows typical 1↔2 and 3↔4 biases that are characteristic of the ordinal severity scale; isolated 0→3 biases are associated with vein shadows and microtexture. Ablations confirm the contribution of the components: without mean/std perimeter −1.2 p.p., without num_contours −0.8 p.p., and without GridSearch −1.5 p.p. Therefore, perimeter features and hyperoptimization are critical for distinguishing between medium/heavy stages. The pipeline is CPU-only, low-memory, and interpretable (importance/SHAP), facilitating on-farm implementation; the main reserves remain increasing class two recall and reducing 3↔4 bias.

The obtained results confirm that the combination of carefully constructed texture–geometric descriptors with XGBoost provides practically significant quality with minimal resources and high interpretability. On the ordinal scale of late blight severity, the model demonstrates uniform metrics for most classes; characteristic errors arise at “borderline” stages (1↔2, 3↔4), where differences in the area and heterogeneity of lesions are small and partially masked by illumination variations. Perimeter features (mean/std perimeter) make a key contribution to distinguishing the moderate/severe stages, which is confirmed by ablations. Comparison with DL approaches from the literature reveals the expected trade-off: we give up a few percentage points in maximum accuracy, but gain in speed, memory, and ease of implementation (CPU-only), which is critical for greenhouse/field scenarios. The limitations are related to domain shift, subjectivity of lesion proportion labeling, and ignoring the class order during the training stage. Practically significant areas of development are ordinal-aware learning, probability calibration, and the expansion of the set of local features to increase completeness at early stages.

6. Conclusions

In this article, we presented an XGBoost–based method for assessing the degree of late blight on tomato leaves using a compact set of textural and geometric descriptors. This approach is based on the global determination of the Otsu threshold and morphological filtering for segmentation of leaf and lesion areas, followed by the identification of seven interpretable features describing the contrast, number, area and perimeter of contours, as well as their ratio. The hyperparameters of the XGBoost classifier are adjusted using GridSearchCV and K-fold cross-validation. Based on an independent test set of images of tomato leaves, the model achieved an overall accuracy of 0.93 and an F1 macro score of 0.93 points with balanced performance across all five hazard classes.

The proposed solution is characterized by low weight, processor compatibility, and ease of integration into existing monitoring systems. Analyzing the importance of characteristics and visualizing lesion contours makes solutions transparent to agronomists and greenhouse operators, which is crucial for practical applications. At the same time, there are still some limitations: the boundaries between neighboring severity levels are inherently fuzzy, and the model may be sensitive to strong shifts in area (camera type, lighting, and grade).

Further work will focus on three areas. First, we plan to include the ordinal number of the severity scale directly into the loss detection function or decision-making strategy of the classifier [37,38]. Secondly, we intend to expand the framework to images containing multiple leaves and combine predictions at the object level within a single frame. Third, we are considering the possibility of extending the feature set with additional color and fractal descriptors and testing this approach on datasets collected in other regions and seasons to further improve reliability and generalization. We also want to expand the possibilities of assessing not only the leaves of greenhouse tomatoes affected by late blight (Phytophthora infestans) but also other plant diseases and various types of crops. This extension will allow a comprehensive assessment of the generalizing ability of the model and its reliability in various growing conditions, regions, and varieties. The purpose of these steps is to ensure that the proposed method is effectively applied to a wider range of agricultural scenarios beyond the current dataset.