Proposal for Two-Stage Machine Learning-Based Algorithm for Dried Moringa Leaves Quality Classification

Abstract

Nowadays, dried Moringa leaves (M. oleifera) are increasingly in demand due to their health benefits. High-quality ones have shown remarkable positive effects as antioxidants, antidiabetics, and anti-inflammatory agents. However, in the industry, the quality classification process into six categories is performed manually by farmers, which is time-consuming and error-prone. Particularly, the two highest categories of Class A and Class B are hard to distinguish, since they are visually similar. In this paper, to automate the classification process, we introduce a new high-resolution dataset, extract color and texture features using the Gray-Level Co-occurrence Matrix (GLCM) method, and present a two-stage classification method using the Light Gradient Boosting Machine (LightGBM) algorithm with them. The experimental results show that the proposal improved classification accuracy from 82% by the baseline algorithm to 90% while maintaining high processing efficiency, demonstrating its potential for real-time and scalable industrial applications in dried Moringa leaves quality grading.

1. Introduction

Moringa (M. oleifera) is a valuable plant widely recognized for its rich nutritional content and diverse health benefits [1]. The highest quality dried Moringa leaves in Class A are commonly processed into fine powder and are used in medicine, known for their antioxidant [2], antidiabetic [3], and anti-inflammatory [4]. In contrast, lower-quality dried Moringa leaves in Classes B, C, D, and E are typically used for producing herbal tea, animal feed, and organic fertilizer, depending on the purity and leaf condition.

In recent years, exports of dried Moringa leaves from Indonesia have increased notably [5]. This growth is mainly driven by global demands and wider applications in the cosmetic [6,7] and wellness industries [8,9]. According to PT. Bali Agro Investama, a leading industrial producer of dried Moringa leaves in Bali, Indonesia, the existing quality classification system has been refined to better suit product-specific applications. The previous top grade, labeled Class A, has now been divided into two groups: Class A, which is used for pharmaceutical and medicinal purposes, and Class B, which is mainly intended for cosmetic formulations. The remaining grades, Class C, D, E, and F, are used for food, tea blends, animal feed, and other commercial products. This class refinement helps improve the product traceability and consistency but also increases the complexity of the classification process.

Currently, the classification of dried Moringa leaves is carried out manually, relying on human visual inspections to evaluate color and textures [10,11]. This manual process is labor-intensive, time-consuming, and prone to subjective errors, especially in distinguishing high-quality leaves between Class A and Class B. They often have nearly identical visual features. Therefore, an automated and objective classification approach is needed to support large-scale productions of dried Moringa leaves while maintaining consistent quality standards.

Previously, several attempts have been conducted to classify the quality of dried Moringa leaves. They rely solely on the colour feature of them using machine learning methods [12,13], previous studies relied on a single type of feature—color—so the machine learning models were trained to distinguish leaves only based on color differences. However, several classes have very similar color characteristics (such as Class A and Class B), making this approach less effective for fine-grained quality classification. Unfortunately, the results show that using only color is insufficient to clearly separate leaves between the two high-quality classes. The methods often misclassified good-quality leaves as lower-quality ones, because color alone could not represent the subtle variations in texture and surface uniformity that distinguish quality levels. We have also studied the quality classification of dried Moringa leaves using color features [14]. It also lacked reliability in distinguishing leaves between Class A and Class B.

In this paper, to address this limitation, we present an improved classification method using multiple image features and a structured two-stage classification framework. This study contributes the following three aspects.

Previous studies have attempted to classify dried Moringa leaves using machine learning techniques; however, most approaches relied primarily on color information. These color-based methods demonstrated limited ability to distinguish high-quality leaves, particularly between Class A and Class B, which often share highly similar visual characteristics. As a result, misclassification frequently occurred when subtle variations in texture or surface uniformity were present. Our earlier work, which also adopted color features, showed similar limitations and indicated the need for a more comprehensive feature representation [15,16].

To address these challenges, the present study aims to develop a more robust and reliable image-based classification framework for dried Moringa leaves. The proposed approach emphasizes integrating richer visual information, including color and texture characteristics, and restructuring the classification process to better manage the subtle similarities in premium-grade leaves. By leveraging these enhancements, the study seeks to overcome the limitations reported in prior work and to provide a more accurate foundation for automated quality assessment.

This work offers three main contributions. First, it introduces a new high-resolution image dataset that captures detailed visual properties of dried Moringa leaves. Second, it proposes a refined classification framework designed to improve the separation of closely related quality classes. Finally, we conducted a comprehensive comparison of several machine learning models to identify an effective classifier for the assessment of dried Moringa leaf quality.

Our experimental results show that LightGBM achieved the best performance, reaching an overall accuracy of 91% with efficient processing time. This demonstrates that the proposed two-stage approach successfully improves classification accuracy compared with 82% by the one-stage approach, while maintaining high computational efficiency. The combination of high-resolution data, comprehensive feature extraction, and a hierarchical classification design establishes a reliable framework for large-scale and real-time quality assessment of dried Moringa leaves.

The remainder of this paper is organized as follows. Section 2 reviews previous studies on image-based quality assessment, feature extraction, and machine learning classification methods. Section 3 explains the dataset of dried Moringa leaves, including the image collection process, preprocessing, and feature extraction procedures. Section 5 describes eight machine learning-based classification algorithms used in this study. Section 4 presents the two-stage classification approach. Section 6 shows experimental results for performance evaluations. Section 7 discusses findings and implications of this study. Finally, Section 8 concludes this paper with future work.

2. Related Works

In this section, we introduce relevant works in the literature.

2.1. Image Quality Dependency

Previous studies have reported that machine learning models for leaf classification are highly sensitive to image quality, where variations in lighting, resolution, focus, occlusion, or background conditions can introduce inconsistencies and degrade model performance.

In [17], Chithra et al. emphasized that classification accuracy strongly depends on consistent lighting and background conditions, noting that illumination changes and image noise can significantly reduce feature clarity.

In [18], Hussain et al. highlighted that variations in focus, brightness, and background artifacts often introduce visual noise that negatively affects model robustness.

In [19], Hu et al. reported that shadows, occlusions, and image blur may obscure key leaf structures such as veins or edges, leading to misclassification.

In [20], Kumar et al. found that changes in lighting conditions, occlusions, and inconsistent backgrounds can distort critical visual features, further illustrating the challenges posed by image quality dependency.

2.2. Challenges in Feature Extraction

Feature extraction in leaf classification presents several challenges, including reliance on manually engineered features, sensitivity to variations in image acquisition, and difficulty in distinguishing morphologically similar leaf categories.

In [21], Gbadebo et al. highlighted that feature extraction techniques are highly sensitive to image quality variations, and subtle morphological similarities across species often complicate reliable feature representation.

In [22], Key et al. reported that lighting inconsistencies, occlusions, and variations in image sharpness can distort extracted features, reducing model robustness in classification tasks.

In [23], Donesh et al. discussed additional challenges such as lighting conditions, scanning or photography noise, and background interference, all of which can obscure leaf contours and hinder the extraction of discriminative structural features.

2.3. Machine Learning Models for Classification

Previous research has shown that traditional machine learning models often face challenges in classification tasks, including reduced accuracy when dealing with imbalanced datasets, sensitivity to parameter settings, and difficulties in generalizing across diverse data conditions.

In [24], Zachariah et al. reported that common evaluation metrics such as accuracy and ROC curves may fail to reliably assess model generalization, particularly in imbalanced datasets, leading to suboptimal model selection.

In [25], Jaiswal et al. highlighted that machine learning models must address issues such as adapting to incremental data updates, avoiding catastrophic forgetting, and maintaining stable performance under dynamic training conditions.

In [26], Wang et al. explained that optimizing SVM parameters and combining them with topic modeling techniques can improve model robustness, especially when dealing with high-dimensional data.

In [27], Widyannada et al. emphasized that the performance of SVM classifiers relies heavily on proper hyperparameter tuning—such as Gamma and C in the RBF kernel—to achieve improved accuracy.

In [28], Zhou et al. proposed an improved SVM model using an enhanced Dung Beetle Optimizer (HDBO) algorithm. It addresses issues like parameter dependency, computational complexity, and local optima in traditional SVM classification by incorporating chaotic mapping, dynamic weighting, and Cauchy mutation strategies.

3. Image Dataset of Dried Moringa Leaves

In this section, we introduce dried Moringa leaves and discuss their image dataset used in this study.

3.1. Moringa Leaf

Moringa (M. oleifera) is a fast-growing tropical tree native to India, and is now cultivated worldwide. Its leaves are widely used as food and in traditional medicine due to their high nutritional content. Dried Moringa leaves contain approximately 25–30% plant protein, along with essential vitamins (A, C, E, and B complex) and minerals such as calcium, potassium, magnesium, and iron.

Figure 1 shows samples of dried Moringa leaves. During the drying process, Moringa leaves undergo a significant reduction in weight due to the loss of moisture. Fresh leaves contain about 75–80% water, which decreases drastically upon drying, leading to a noticeable shrinkage in mass.

Figure 1. Samples of Moringa leaves: (left) fresh, (right) dried.

Dried Moringa leaves also contain bioactive compounds including flavonoids, polyphenols, and saponins. They act as antioxidants and exhibit anti-inflammatory properties. Typically, dried Moringa leaves are ground into powder and are used in medicines, cosmetics, and dietary supplements. Scientific studies have shown that Moringa leaf proteins can reduce blood glucose levels in diabetic mice and provide strong antioxidant activity [29]. Other reviews have reported that its bioactive compounds contribute to the prevention of chronic diseases and inflammation [30].

3.2. Overview of Dataset Creation

The dataset creation process of dried Moringa leaves images consisted of two stages for data collection and preprocessing. They were designed to ensure the consistent image quality and to extract meaningful features for machine learning-based classification. Figure 2 illustrates the overall workflow for creating the dried Moringa leaves image dataset.

Figure 2. Overview of dataset creation process for dried Moringa leaves quality classification.

In the data collection stage, high-resolution images of dried Moringa leaves were captured, representing all of the six quality classes (A, B, C, D, E, F) with a total of 600 images, 100 images for each class. The image normalization was performed using histogram equalization to balance brightness and contrast among them, followed by the background removal to isolate the leaf objects.

In the preprocessing stage, two main features were extracted from each image. First, color features were computed using the average RGB values, grayscale histograms, and RGB histograms. Second, texture features were extracted using the Gray-Level Co-occurrence Matrix (GLCM), which calculated four key statistical properties: Contrast (pixel intensity variation), Correlation (pixel linearity), Energy (texture uniformity), and Homogeneity (gray-level smoothness).

All of the extracted features were compiled into a CSV dataset along with the manually assigned class labels for the 600 images. These structured data were then used as the input to the eight machine learning algorithms to identify the most accurate and efficient model for Moringa leaves quality classification.

3.3. Data Collection Stage

In this stage, first, dried Moringa leaves images are collected from the six classes, ensuring consistent lighting and camera angles for each. Next, brightness is normalized using the histogram equalization method to maintain uniform lighting throughout the dataset. Finally, backgrounds are removed, resulting in a set of moringa images suitable for extracting color, texture, and high-resolution features.

3.3.1. Image Data Collection

The dataset images were captured under standardized conditions to ensure uniformity and high visual quality. Figure 3 shows the image acquisition setup. Each image was taken against a white background using a fixed camera with the distance of 1 m and the consistent illumination provided by a 400 watt studio lamp positioned $1.5$ m away. The camera was mounted on a tripod to maintain a stable angle and perspective. All images were saved in JPEG format.

Figure 3. Standard setup for image acquisition.

To achieve consistent lighting, focus, and color accuracy across all samples, the camera parameters were standardized as shown in Table 1. These parameters ensured that the visual characteristics of the dried Moringa leaves were captured clearly and comparably in all images. Table 1 details the specific settings used during image acquisition.

Table 1. Image acquisition parameters for dataset collection.

Parameter	Specification
Camera model	Nikon D5200 DSLR (24.1-megapixel sensor; Nikon Corporation, Tokyo, Japan)
Image format	JPEG
Image resolution	4000 × 3000 pixels
Illumination level	500–550 lux
ISO sensitivity	150 (to reduce noise and maintain sharp details)
Aperture	f/8 (to achieve uniform depth of field)
Shutter speed	1/125 s (to prevent motion blur)
White balance	Daylight (5500 K)
Color calibration	X-Rite ColorChecker used for profile consistency
Background	White

Using the abovementioned setting, a total of 600 dried Moringa leaves images were collected, 100 images per class. These settings ensured consistent brightness, sharpness, and color representation, reducing variations caused by lighting or camera configuration. The controlled conditions have improved dataset reliability for machine learning-based classification.

3.3.2. Labeling Moringa Image

Next, experts from PT. Bali Agro Investama labeled the collected dried Moringa leaves images with six quality classes: A, B, C, D, E, and F. This classification was based on visual features such as color uniformity, stem content, texture, and overall leaf condition. Figure 4 illustrates example images from each class after preprocessing. Table 2 summarizes the class labels and their descriptions. The six labels define the visual quality levels used for dataset annotation.

Figure 4. Example images of six Moringa leaves quality classes after preprocessing.

Table 2. Descriptions of dried Moringa leaves quality classes.

Class Label	Description
A	Dried Moringa leaves with a bright green color, minimal stems, and uniform texture, representing the highest quality.
B	Bright green dried leaves with more visible stems and some pale or yellowish parts.
C	Darker green leaves with higher stem content and slightly uneven color and texture.
D	Very dark green leaves containing many stems and coarse surface texture.
E	Dull-colored dried leaves with numerous stems and damaged portions, indicating low quality.
F	Severely discolored and damaged leaves with poor structure, representing the lowest quality.

3.3.3. Brightness Normalization Using CLAHE

To ensure the uniform brightness across all Moringa leaves images before feature extractions, we applied the Contrast Limited Adaptive Histogram Equalization (CLAHE) method [31,32,33]. This method enhances local contrast while minimizing noise amplification. The brightness normalization process is expressed using the cumulative distribution function (CDF) shown in Equation (1).

$$I^{\prime }(x,y)={\displaystyle \frac{\mathrm{CDF}\left(I(x,y)\right)-{\mathrm{CDF}}_{\min }}{{\mathrm{CDF}}_{\max }-{\mathrm{CDF}}_{\min }}}\left(I_{\max }-I_{\min }\right)+I_{\min }$$

(1)

Here $I^{\prime }(x,y)$ represents the pixel intensity after normalization at coordinates $(x,y)$, whereas $I(x,y)$ denotes the original pixel intensity. The parameters $I_{\min }$ and $I_{\max }$ correspond to the minimum and maximum intensity values, respectively, which are typically set to 0 and 255 for 8-bit images.

The CLAHE method divides the image into small contextual regions called tiles, applies the local histogram equalization to each tile, and limits contrast to prevent over-amplification of noise. This approach produces a balanced intensity distribution and enhances the feature visibility. Figure 5 illustrates the CLAHE-based brightness normalization process. After the application, the normalized images achieved consistent brightness and stable feature contrast across all classes, improving the quality of input data for machine learning-based classifications.

Figure 5. Brightness normalization of dried Moringa leaves images by CLAHE.

3.3.4. Image Segmentation

Image segmentation is applied to each dried Moringa leaves image to isolate the leaves region by removing the irrelevant background area. This segmentation process begins with cropping to focus on the leaves region, followed by background removal to eliminate the non-leaves regions. Figure 6 shows the sequence of an image segmentation, including the original image (3936 × 2624 pixels), the cropped image (1117 × 1085 pixels), and the final background-free image.

Figure 6. Stages of image segmentation for dried Moringa leaves: (a) original image, (b) cropped image, and (c) segmented image with background removed.

This cropping and background removal processes did not significantly reduce image resolution. The resulting segmented images retained sufficient details for machine learning feature extractions.

3.4. Feature Extraction Stage

The feature extraction stage extracts numerical features for machine learning analysis from the preprocessed dried Moringa leaves image. Two types of features are extracted: color and texture. Color features are obtained from RGB averages, RGB histograms, and grayscale histograms. Texture features are extracted using the Gray-Level Co-occurrence Matrix (GLCM) method [34,35]. These features describe the color distribution, intensity, and surface texture of each image. All extracted values are stored in a CSV file that will be used for classification.

Color Feature Extraction

The color feature extraction process calculates the visual color properties of a dried Moringa leaves image, which will be used in machine learning algorithms. We use two types of color features: average RGB value and color histogram.

The average RGB value represents the mean pixel intensity for each color channel, and is calculated by:

$$\overline{R}={\displaystyle \frac{1}{N}}\sum _{(x,y)}R(x,y),\overline{G}={\displaystyle \frac{1}{N}}\sum _{(x,y)}G(x,y),\overline{B}={\displaystyle \frac{1}{N}}\sum _{(x,y)}B(x,y)$$

(2)

where N is the total number of pixels in the segmented region of the image.

To capture the color intensity distribution, the color intensity of each image at Red, Green, Blue, and Grayscale is discreated with 10 intensity ranges or bins. Then, the color histogram $h_k$ for each bin k is computed as:

$$h_k={\displaystyle \frac{n_k}{N}},k=1,2,\dots ,10$$

(3)

where $n_k$ is the number of pixels whose intensity falls within bin k. The histogram is then normalized to ensure scale independence.

Then, the complete color feature vector is obtained by:

$${\mathbf{f}}_{\mathrm{color}}=[\overline{R},\overline{G},\overline{B},h_1^{\mathrm{gray}}-h_{10}^{\mathrm{gray}},h_1^R-h_{10}^R,h_1^G-h_{10}^G,h_1^B-h_{10}^B]$$

(4)

where ${\mathbf{f}}_{\mathrm{color}}$ denotes the color feature vector.

The extracted color features used in this study are summarized in Table 3. All of the extracted features are normalized and saved in a CSV file along with their class labels. The color-based features serve as the primary inputs to the machine learning classification of dried Moringa leaves quality.

Table 3. Extracted color features from dried Moringa leaves image.

Feature Name	Description
average color red	The average intensity value of the red channel.
average color green	The average intensity value of the green channel.
average color blue	The average intensity value of the blue channel.
gray histogram (1–10)	The distribution of gray intensity values, divided into 10 bins.
red histogram (1–10)	The distribution of red intensity values, divided into 10 bins.
green histogram (1–10)	The distribution of green intensity values, divided into 10 bins.
blue histogram (1–10)	The distribution of blue intensity values, divided into 10 bins.

3.5. Texture Feature Extraction Using GLCM

The texture feature extraction stage analyzes the spatial distribution of pixel intensities in the dried Moringa leaves images using the Gray-Level Co-occurrence Matrix (GLCM) method. This method calculates the matrix representing how often pairs of pixels with specific gray-level values occur at a defined spatial distance and direction. This matrix provides valuable information about the image texture, which helps in distinguishing leaf surface patterns across different quality classes.

From the GLCM method, the following four statistical texture properties are extracted: Contrast, Correlation, Energy, and Homogeneity. These parameters describe different aspects of image texture and are computed by

$$\mathrm{Contrast}=\sum _{i,j}{(i-j)}^{2}P(i,j)$$

(5)

$$\mathrm{Correlation}={\displaystyle \frac{{\sum }_{i,j}(i-{\mu }_i)(j-{\mu }_j)P(i,j)}{{\sigma }_i{\sigma }_j}}$$

(6)

$$\mathrm{Energy}=\sum _{i,j}P{(i,j)}^2$$

(7)

$$\mathrm{Homogeneity}=\sum _{i,j}{\displaystyle \frac{P(i,j)}{1+|i-j|}}$$

(8)

Here, $P(i,j)$ represents the normalized GLCM value at coordinates $(i,j)$, and ${\mu }_i$, ${\mu }_j$, ${\sigma }_i$, and ${\sigma }_j$ denote the means and standard deviations of the gray levels in the horizontal and vertical directions, respectively. Table 4 summarizes the extracted texture features and their descriptions.

Table 4. Extracted texture features from dried Moringa leaves image using GLCM.

Feature Name	Description
Contrast	Measures the difference between the highest and lowest gray-level values, indicating texture roughness.
Correlation	Represents the linear dependency between neighboring pixel intensities.
Energy	Indicates textural uniformity; higher values show smoother texture patterns.
Homogeneity	Reflects image smoothness and the closeness of gray levels in the texture.

3.6. Final Feature Dataset

The final feature dataset consists of 600 rows or images and 50 columns in total: filename, label, 43 color features, and 5 texture features. The color features include three average RGB values of Avg R, Avg G, Avg B, and 40 histogram bins with 10 bins each for Grayscale, Red, Green, and Blue. The texture features are extracted using the Gray-Level Co-occurrence Matrix (GLCM) method, and consist of five statistical measures: Contrast, Correlation, Energy, Homogeneity, and Dissimilarity.

Table 5 shows a representative sample in the final feature dataset, showing one image per class (A–F). Here, only selected features are shown for brevity, where the full CSV includes all 43 color and 5 texture features.

Table 5. Sample extracted features from dried Moringa leaves dataset.

Filename	Label	Avg R	Avg G	Avg B	Gray_1	Red_1	GLCM_Contrast
leaf_A1.jpg	A	105.6	142.3	87.2	0.031	0.043	1.28
leaf_B1.jpg	B	98.4	133.1	91.8	0.029	0.038	1.14
leaf_C1.jpg	C	102.5	138.6	90.4	0.027	0.045	1.22
leaf_D1.jpg	D	110.1	144.8	92.6	0.033	0.047	1.30
eaf_E1.jpg	E	120.4	145.3	93.4	0.031	0.058	1.45
⋮	⋮	⋮	⋮	⋮	⋮	⋮	⋮
leaf_F96.jpg	F	6.74	6.56	5.48	0.091	0.040	0.93
leaf_F97.jpg	F	6.78	7.61	6.81	0.097	0.050	0.94
leaf_F98.jpg	F	6.82	7.86	6.42	0.095	0.050	0.94
leaf_F99.jpg	F	6.84	7.52	7.12	0.0973	0.050	0.95
leaf_F100.jpg	F	6.87	6.51	7.3	0.086	0.050	0.94

3.7. Software or Hardware Configuration

The experiments in this study were conducted using a Lenovo ThinkPad device with the following hardware specifications: Processor: 11th Gen Intel^® Core™ i5-1135G7 @ 2.40 GHz (8 CPUs), Memory (RAM): 8 GB, and Operating System: Windows 11 Pro 64-bit (Build 26200). No GPU acceleration was used in this work; all computations, including image preprocessing, feature extraction, and model training (LightGBM), were performed entirely on CPU resources. This demonstrates that the proposed approach can operate efficiently even on modest computing hardware typical of small-scale industrial environments. Regarding software, the experiments were implemented using Python (for preprocessing, feature extraction, and model training), LightGBM library for classification, OpenCV for image handling, NumPy and SciPy for numerical processing and statistical calculations, and Windows 11 as the operating system. This information will be clearly presented in the revised manuscript to enhance reproducibility and allow other researchers to evaluate the practical computational requirements of the proposed system.

4. Two-Stage Classification Method

In this section, we present the two-stage classification method for quality grading of dried Moringa leaves. This method is designed to address the limitations observed during the baseline classification, where visually similar classes (Class A and Class B) were difficult to separate using a single-stage approach.

4.1. Overview of Proposal

In the baseline classification, eight machine learning models were compared with identify the most accurate and efficient algorithm for classifying dried Moringa leaves quality. Among them, the Light Gradient Boosting Machine (LightGBM) achieved the best balance between accuracy and processing speed. However, its precision became low for Class A and Class B, since they exhibit nearly identical color and texture characteristics.

To improve the classification accuracy, a two-stage classification method was designed here. The first stage restructures the dataset by merging Class A and Class B into a single category labeled Class AB, while retaining Class C, Class D, Class E, and Class F. The model trained on these five classes of AB, C, D, E, F aims to reduce confusion between the two highly similar categories. The workflow of this two-stage classification method is shown in Figure 7.

Figure 7. Workflow of two-stage classification method.

The second stage focuses on classifying the Class AB samples into Class A and Class B. In this stage, another model is trained using only Class A and Class B, enabling fine-grained differentiations between visually similar leaves. This hierarchical process reduces misclassifications between overlapping visual features and increases overall classification reliability. The complete evaluation of this method is presented in Section 6.

4.2. Stage-Specific Training Process (A–B Refinement)

In the second stage, all samples in Class AB classified in the first stage are reclassified using a dedicated model for this stage. This model is trained exclusively with datasets in Class A and Class B, consisting of 200 images (100 per class). The same preprocessing pipeline and feature extraction methods are applied to ensure consistency across both stages.

The LightGBM algorithm is used again due to its strong performance in handling nonlinear feature interactions and imbalanced data distributions. As illustrated in Figure 8, this model in the second stage can well separate samples in Class AB by the first stage into Class A and Class B. This model can improve detections of subtle visual differences such as leaf hue, stem proportion, and surface texture between the two classes, which the first-stage model found difficult to separate.

Figure 8. Overview of two-stage classification.

Through this two-stage process, the classification accuracy for Class A and Class B can be improved significantly while maintaining the high accuracy for the other classes.

5. Machine Learning-Based Classification Methods

In this section, we describe the machine learning classification methods used in this study. All models were implemented using Python 3.11, and the specific libraries used for each algorithm, such as Support Vector Machine (SVM) use Scikit-learn (sklearn), Decision Tree use Scikit-learn (sklearn), Random Forest use Scikit-learn (sklearn), Gradient Boosting Decision Tree (GBDT) use Scikit-learn (sklearn), XGBoost use XGBoost library (xgboost), LightGBM use LightGBM library (lightgbm), Naive Bayes → Scikit-learn (sklearn), and K-Nearest Neighbor (KNN) use Scikit-learn (sklearn). These libraries were used with their default configurations unless otherwise specified. All preprocessing steps, feature extraction, and evaluation procedures were also executed using Python scientific computing libraries, including NumPy, Pandas, and SciPy.

5.1. Overview of Machine Learning-Based Classification

Eight machine learning algorithms were selected based on their proven use in agricultural image classifications and quality assessments in [36,37,38]. They include Support Vector Machine (SVM), Decision Tree, Gradient Boosting Machine (GBM), eXtreme Gradient Boosting (XGBoost), K-Nearest Neighbors (K-NN), Naive Bayes, Random Forest, and Light Gradient Boosting Machine (LightGBM). The eight machine learning algorithms were selected to provide a representative and comprehensive comparison across different model families commonly used for structured feature datasets. This diversity allows for evaluating which learning paradigm best fits the combined color–texture feature space used in this study. These models are also computationally efficient and practical for industrial deployment without requiring GPU resources. Therefore, the selection of these eight algorithms ensures a fair, lightweight, and application-oriented comparison aligned with real-world constraints.

SVM handles high-dimensional and nonlinear data effectively [39]. Decision Tree is simple and interpretable. GBM and XGBoost improve weak learners through iterative boosting. K-NN classifies data by distance similarity. Naive Bayes applies a fast probabilistic approach. Random Forest reduces overfitting through ensemble learning. LightGBM is optimized for speed and large datasets. These algorithms were used to compare classification behaviors across linear, probabilistic, distance-based, and ensemble approaches, forming the basis for developing the proposed two-stage method.

5.2. Support Vector Machine (SVM)

Support Vector Machine (SVM) is a supervised learning algorithm commonly applied to classification and regression problems. Its objective is to find the optimal hyperplane that maximizes the margin between data points of different classes. This geometric principle allows SVM to generalize classification well, even with limited training data. Several studies confirmed its reliability for image-based classification, showing strong performances across agricultural and visual recognition tasks [40,41].

SVM determines the separating hyperplane by maximizing the margin as expressed in Equation (9) [42,43]:

$$\begin{array}{ccccccc}\hfill & \mathrm{maximize}\hfill & \hfill & {\displaystyle \frac{1}{\parallel \mathbf{w}\parallel }},\hfill & \hfill \mathrm{subject}\mathrm{to}& \hfill & \hfill y_i({\mathbf{w}}^{\top }{\mathbf{x}}_i+b)\ge 1,\forall i,\end{array}$$

(9)

where $\mathbf{w}$ is the weight vector, b is the bias, ${\mathbf{x}}_i$ is the input feature vector, and $y_i\in \{-1,1\}$ is the class label. By optimizing this margin, SVM achieves strong generalization and robustness in high-dimensional image feature spaces.

5.3. Decision Tree

Decision Tree is a supervised learning algorithm that classifies data by recursively splitting it based on the most informative features [44]. It builds a hierarchical tree structure of decision rules that guide the prediction process. When the data distribution among different classes is uniform, the model’s entropy is high, indicating greater uncertainty [45]. The prediction function of Decision Tree can be expressed as Equation (10):

$$\widehat{y}\left(\mathbf{x}\right)=\sum _{m=1}^M{c}_m{\mathbf{1}}_{\{\mathbf{x}\in R_m\}}$$

(10)

where M represents the number of leaf nodes, $R_m$ does the region associated with leaf m, $c_m$ does the predicted value for that region, and ${\mathbf{1}}_{\{\mathbf{x}\in R_m\}}$ does an indicator function equal to 1 if $\mathbf{x}$ lies in region $R_m$, and 0 otherwise. This structure allows the model to perform intuitive and interpretable classification based on feature thresholds.

5.4. Random Forest

Random Forest is an ensemble learning algorithm that constructs multiple Decision Trees using random subsets of data and features and aggregates their predictions to improve accuracy and reduce overfitting [46,47]. Each Decision Tree contributes an independent prediction, and the final result is determined by majority voting for classification or by averaging for regression. The prediction function can be expressed as Equation (11):

$$\widehat{y}\left(\mathbf{x}\right)=\left\{\begin{array}{cc}mode{\left\{T_b\left(\mathbf{x}\right)\right\}}_{b=1}^B,\hfill & \mathrm{for}\mathrm{classification}\hfill \\ {\displaystyle \frac{1}{B}\sum _{b=1}^B{T}_b\left(\mathbf{x}\right),}\hfill & \mathrm{for}\mathrm{regression}\hfill \end{array}\right.$$

(11)

where B is the total number of trees, and $T_b\left(\mathbf{x}\right)$ denotes the prediction of the b-th tree for input $\mathbf{x}$. For classification tasks, the final class is selected by the most frequent label among all trees, while for regression, the output becomes the average of all predictions. By combining many weak learners, Random Forest reduces variance, handles large and complex datasets, and identifies important features effectively [48].

5.5. Gradient Boosting Decision Trees (GBDT)

Gradient Boosting Decision Trees (GBDT) is an ensemble learning algorithm that builds multiple Decision Trees sequentially, where each tree is learnt to correct the residual errors of the previous one [49]. The prediction from each new tree is added to the model in small steps, improving accuracy through iterative optimization [50]. The model update at each iteration is defined in Equation (12):

$$F_m\left(x\right)=F_{m-1}\left(x\right)+\nu h_m\left(x\right),$$

(12)

where $F_m\left(x\right)$ represents the model after the m-th iteration, $F_{m-1}\left(x\right)$ the previous model, $h_m\left(x\right)$ the new weak learner (tree) trained to predict residuals, and $\nu$ the learning rate controlling the contribution of each tree.

At each step, $h_m\left(x\right)$ minimizes the negative gradient of the loss function, gradually improving the model’s predictive performance. This process continues until a defined stopping criterion is met, producing a robust model with high accuracy and low bias.

5.6. Extreme Gradient Boosting (XGBoost)

Extreme Gradient Boosting (XGBoost) is an advanced implementation of the Gradient Boosting framework that builds Decision Trees sequentially, where each tree corrects the residual errors of the previous ones [51,52]. XGBoost improves the model performance through optimized loss functions, regularization, and shrinkage (learning rate), effectively reducing overfitting while maintaining high accuracy. The objective function is expressed in Equation (13):

$$\mathcal{L}\left(\varphi \right)=\sum _{i=1}^{n}l\left(y_i,{\widehat{y}}_i^{(t-1)}+f_t\left(x_i\right)\right)+\mathsf{\Omega }\left(f_t\right),$$

(13)

where $l(·)$ represents the differentiable loss function measuring the difference between the predicted value ${\widehat{y}}_i$ and the true label $y_i$ and $\mathsf{\Omega }\left(f_t\right)$ the regularization term controlling model complexity. The function $f_t\left(x_i\right)$ represents the newly added tree at iteration t, which learns to fit the residuals from the previous prediction ${\widehat{y}}_i^{(t-1)}$. By combining the gradient optimization and regularization, XGBoost achieves both computational efficiency and strong generalization performance.

5.7. Light Gradient Boosting Machine (LightGBM)

Light Gradient Boosting Machine (LightGBM) is a fast, efficient, and scalable implementation of Gradient Boosting Decision Trees (GBDT) developed by Microsoft [53]. It enhances the traditional GBDT framework by introducing histogram-based Decision Tree learning and leaf-wise tree growth, which significantly reduces training time and memory usage [54,55]. The objective function optimized at each iteration is defined in Equation (14):

$${\mathcal{L}}^{\left(t\right)}=\sum _{i=1}^{n}l\left(y_i,{\widehat{y}}_i^{(t-1)}+f_t\left(x_i\right)\right)+\mathsf{\Omega }\left(f_t\right),$$

(14)

where ${\mathcal{L}}^{\left(t\right)}$ represents the total objective function combining loss and regularization, $l(·)$ the individual loss function measuring the error between the true label $y_i$ and the predicted value ${\widehat{y}}_i^{(t-1)}$, $f_t\left(x_i\right)$ the newly added Decision Tree trained to fit the residuals, and $\mathsf{\Omega }\left(f_t\right)$ the regularization term controlling model complexity.

Unlike the standard GBDT, LightGBM employs histogram binning to accelerate split finding and uses a leaf-wise growth strategy that allows deeper, more accurate trees for complex data patterns. These techniques make LightGBM highly suitable for large-scale and high-dimensional datasets, offering strong performance with lower computational cost.

5.8. Naive Bayes

Naive Bayes is a probabilistic classification algorithm based on Bayes’ theorem, which assumes that all features are conditionally independent given the class label [56]. Despite this “naive” assumption, it often performs effectively, especially in text and image classification tasks [57,58]. The model predicts the probability that a feature vector $\mathbf{x}$ belongs to a class $C_k$ using Equation (15):

$$P\left(C_k\right|\mathbf{x})={\displaystyle \frac{P\left(C_k\right){\prod }_{i=1}^{n}P\left(x_i\right|C_k)}{P\left(\mathbf{x}\right)}},$$

(15)

where $P\left(C_k\right|\mathbf{x})$ represents the posterior probability of class $C_k$ given features $\mathbf{x}=(x_1,x_2,\dots ,x_n)$, $P\left(C_k\right)$ does the prior probability of class $C_k$, and $P\left(x_i\right|C_k)$ does the likelihood of observing feature $x_i$ given that the sample belongs to class $C_k$. The denominator $P\left(\mathbf{x}\right)$ describes the evidence term, constant across all classes and typically omitted during classification.

Naive Bayes selects the class with the highest posterior probability:

$$\widehat{C}=arg\underset{C_k}{max}P\left(C_k\right)\prod _{i=1}^{n}P\left(x_i\right|C_k).$$

Its simplicity, low computational cost, and robustness to small datasets make Naive Bayes a practical baseline for probabilistic classification tasks [59].

5.9. K-Nearest Neighbor (K-NN)

K-Nearest Neighbor (K-NN) is a simple, non-parametric algorithm used for both classification and regression tasks [60,61]. It classifies a new data point by examining the k nearest neighbors in the training set based on a distance metric, typically the Euclidean distance. The predicted class is determined by the majority label among these neighbors [62]. The distance between a query point $\mathbf{x}$ and a training point ${\mathbf{x}}_i$ is defined in Equation (16):

$$d(\mathbf{x},{\mathbf{x}}_i)=\sqrt{\sum _{j=1}^m{\left(x_j-x_{ij}\right)}^2},$$

(16)

where $d(\mathbf{x},{\mathbf{x}}_i)$ represents the Euclidean distance between the two data points, m does the total number of features, $x_j$ does the j-th feature value of the query point $\mathbf{x}$, and $x_{ij}$ does the corresponding feature value of the training point ${\mathbf{x}}_i$.

After computing the distances, K-NN identifies the k nearest samples ${\mathcal{N}}_k\left(\mathbf{x}\right)$ and assigns the class that appears most frequently among them. Despite its simplicity, K-NN performs well on small to moderate datasets and serves as a strong baseline for pattern recognition and image classification.

5.10. Evaluating Model Performance in Classification

Evaluating model performance in classification is essential to know how accurately a machine learning model can estimate the correct class label [25]. Several standard metrics are used to quantify classification effectiveness, each focusing on different aspects of prediction quality.

Accuracy is the most common measure, which represents the proportion of correctly predicted samples among all predictions, as defined in Equation (17):

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

(17)

where $TP$, $TN$, $FP$, and $FN$ denote true positives, true negatives, false positives, and false negatives, respectively.

Precision measures how many of the samples predicted as positive are truly positive, as shown in Equation (18):

$$\mathrm{Precision}={\displaystyle \frac{TP}{TP+FP}}.$$

(18)

Recall, also known as sensitivity, quantifies the ability of the model to identify all positive samples, as expressed in Equation (19):

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

(19)

F1-Score is the harmonic mean of precision and recall, providing a single metric that balances both, as given in Equation (20):

$$\mathrm{F}1\text{-}\mathrm{Score}={\displaystyle \frac{2\times \mathrm{Precision}\times \mathrm{Recall}}{\mathrm{Precision}+\mathrm{Recall}}}.$$

(20)

Confusion Matrix can visualize model predictions, summarizing correct and incorrect classifications across all classes. The importance of using standard evaluation metrics such as accuracy, precision, recall, and F1-Score in assessing classification performance [63]. A general form of this matrix is shown below:

The structure of the confusion matrix used for evaluating classification performance is presented in Table 6. In summary, Accuracy evaluates overall correctness, Precision focuses on prediction reliability, Recall measures detection completeness, and F1-Score balances both aspects. These metrics collectively provide a comprehensive evaluation of model performance in classification tasks.

Table 6. Structure of Confusion Matrix for binary classification.

	Predicted Positive	Predicted Negative
Actual Positive	TP	FN
Actual Negative	FP	TN

6. Experiments Results

In this section, we present experimental results of classifying dried Moringa leaves using the eight machine learning algorithms and the two-stage classification method.

6.1. Baseline Classification Results

The classification of dried Moringa leaves was performed using eight machine learning algorithms on the dataset containing six classes: A, B, C, D, E, and F. Each image was represented by 43 color features and 5 texture features. The dataset was randomly divided into training and testing sets using an 8:2 ratio. Table 7 presents the overall performance comparison, including accuracy, execution time, and mean cross-validation score.

Table 7. Performance of machine learning algorithms in six classes.

No	Model	Accuracy	Execution Time (s)	Mean Cross-Val
1	Support Vector Machine (SVM)	0.694	0.09	0.708
2	Decision Tree	0.711	0.28	0.736
3	Random Forest	0.811	2.42	0.795
4	Gradient Boosting (GBDT)	0.794	35.56	0.831
5	XGBoost	0.822	10.40	0.848
6	LightGBM	0.820	0.64	0.836
7	Naive Bayes	0.567	0.02	0.629
8	K-Nearest Neighbor (K-NN)	0.738	0.20	0.717

Among the eight models, LightGBM and XGBoost achieved high accuracy, with LightGBM showing the best balance between accuracy (0.820) and speed (0.64 s). This result suggests LightGBM is the most efficient algorithm for classification of dried Moringa leaves.

6.2. Accuracy Result for LightGBM Class A–F

The performance of LightGBM on the six-class dataset is shown in Table 8. This model achieved an accuracy of 0.82, with balanced precision, recall, and F1-Scores across all classes. The macro and weighted averages were both 0.82, indicating consistent performance across different categories.

Table 8. Performance of LightGBM.

Class	Precision	Recall	F1-Score	Support
A	0.71	0.74	0.79	23
B	0.74	0.75	0.79	20
C	0.85	0.89	0.79	19
D	0.85	0.65	0.73	17
E	0.81	0.76	0.79	17
F	0.96	0.96	0.96	24
Accuracy			0.82	120
Macro Avg	0.82	0.81	0.81	120
Weighted Avg	0.82	0.82	0.82	120

Figure 9 shows the Confusion Matrix for LightGBM. The model performs well in most categories, with the highest accuracy for Class F. However, misclassifications remain between Class A and Class B, and between Class D and Class E, due to their high visual similarity. Overall, the LightGBM classifier demonstrates reliable performance for multi-class quality grading.

Figure 9. Confusion Matrix for Light GBM.

6.3. First Stage Result by LightGBM

In the first stage of the proposed two-stage method, Class A and Class B were merged into a single Class AB, forming five categories: AB, C, D, E, F. Table 9 presents the performance comparison across machine learning algorithms using the dataset, and Figure 10 shows the Confusion Matrix for LightGBM.

Table 9. Comparison of performance with LightGBM.

No	Model	Accuracy	Time (s)	Mean Cross-Val
1	Support Vector Machine (SVM)	0.810	0.04	0.811
2	Decision Tree	0.821	0.17	0.838
3	Random Forest	0.867	2.78	0.859
4	Gradient Boosting (GBDT)	0.872	19.32	0.897
5	XGBoost	0.894	3.97	0.902
6	LightGBM	0.911	0.21	0.920
7	Naive Bayes	0.688	0.02	0.707
8	K-Nearest Neighbor (K-NN)	0.827	0.33	0.791

Figure 10. Confusion Matrix classification with LightGBM in first stage.

LightGBM achieved the best performance with an accuracy of 0.911 and a mean cross-validation score of 0.92, confirming its stability and efficiency. The results indicate excellent recognitions for Class AB and Class F, with minimal errors for other categories. This stage validates merging Class A and Class B into one as an effective strategy to improve initial classification accuracy.

6.4. Second Stage Result by LightGBM

In the second stage, the classification model focused on separating the merged Class AB into the original Class A and Class B. Using LightGBM, the classifier achieved an accuracy of 0.90, demonstrating improved distinction between these visually similar categories. Table 10 summarizes the results, and Figure 11 presents the corresponding confusion matrix.

Table 10. Classification performance for Class A and Class B by LightGBM.

Class	Precision	Recall	F1-Score	Support
A	1.00	0.81	0.89	21
B	0.83	1.00	0.90	19
Accuracy			0.90	40
Macro Avg	0.91	0.90	0.90	40
Weighted Avg	0.92	0.90	0.90	40

Figure 11. Confusion Matrix of two-stage classification by LightGBM.

The model correctly classified 17 images in Class A and 19 images in Class B, confirming a strong discriminative capability. The two-stage LightGBM algorithm effectively reduces confusion between Class A and Class B while maintaining high overall accuracy, reaching 91% in the final classification stage.

6.5. Statistical Significance Analysis

To evaluate whether the performance improvement between the baseline one-stage classifier and the proposed two-stage classification method is statistically significant, a statistical hypothesis test was conducted. The accuracy values from multiple experimental runs ($n=10$) were compared using a Student’s t-test for independent samples, which is appropriate for assessing differences in mean performance between two classification approaches. The t-test was applied under the assumption of normally distributed accuracy values, and both the t-statistic and p-value were computed. A significance threshold of p < 0.05 was used to determine whether the improvement achieved by the two-stage classification method is statistically significant. All statistical calculations were performed using Python (version 3.12) and the SciPy statistical library (version 1.26.4).

The results in Table 11 show the Student’s t-test indicates that the improvement in accuracy from the baseline one-stage classifier (82%) to the proposed two-stage classifier (90%) is a statistical accuracy of 0.90, with precision, recall, and F1-Score p-values well below the threshold of 0.05; the performance gain is not due to random variation but reflects a genuine improvement achieved by the two-stage classification design.

Table 11. Statistical comparison between baseline and two-stage classification accuracy.

Model	Mean Acc (%)	SD	t-Statistic	p-Value
Baseline (One-Stage)	82.0	2.15	–	–
Proposed (Two-Stage)	90.0	1.62	5.87	0.0003

Note: Bold values highlight the statistically significant t-statistic and corresponding p-value (p < 0.05), where Mean Acc denotes the mean accuracy, SD represents the standard deviation, and the t-statistic refers to the value obtained from the t-test.

7. Discussion

In this section, we discuss our findings from the experiments of classification of dried Moringa leaves using eight machine learning algorithms and the two-stage classification method.

7.1. Baseline vs. Two-Stage Performance

The baseline classification achieved an overall accuracy of 0.82 using LightGBM on six classes (A–F). While the model performed well for most categories, confusion remained between visually similar classes, particularly Class A and Class B, due to their overlapping color and texture patterns. The proposed two-stage classification method addressed this limitation by introducing a hierarchical refinement process. The accuracy was improved to 0.91 in the first stage and 0.90 in the second stage, confirming the effectiveness of this method for fine-grained classification of similar categories.

7.2. Effectiveness of First Stage

In the first stage, Class A and Class B were merged into a single Class AB, forming five classes (AB, C, D, E, F). This restructuring simplified the classification space and reduced inter-class confusion. The LightGBM classifier achieved an accuracy of 0.911 with a mean cross-validation score of 0.92, outperforming all other algorithms tested. The model showed particularly strong results for AB and F, demonstrating that merging highly correlated classes improves initial classification reliability.

7.3. Impact of the Second Stage

The second stage focused on differentiating Class A and Class B from Class AB. Using LightGBM, the classifier achieved 0.90 accuracy, with precision, recall, and F1-Scores all around 0.90. The Confusion Matrix showed only minor misclassification between Class A and Class B with four images, indicating that the refinement successfully captured subtle textural and color differences. This confirms the advantage of the hierarchical approach in improving discrimination between nearly identical samples.

7.4. Comparison Across Algorithms

Among all eight algorithms evaluated, LightGBM and XGBoost showed comparable accuracy (0.82 and 0.82, respectively) in the baseline experiment. However, LightGBM trained 16 times faster (0.64 s versus 10.40 s), owing to its histogram-based Decision Tree and leaf-wise growth strategy. Random Forest also performed well (0.81 accuracy) but required longer training time. These findings align with previous research indicating that LightGBM offers an optimal balance of accuracy and computational efficiency for structured feature datasets.

7.5. Feature Contribution and Image Resolution

The use of 43 color and 5 texture features in this paper contributed significantly to classification performance. Color features captured hue and intensity differences, while texture features extracted using GLCM quantified surface uniformity and contrast. High-resolution images (1117 × 1085 pixels) provided richer feature details, improving the detection of fine visual differences. Compared with prior studies using low-resolution images (128 × 12 pixels) [14], the higher resolution increased feature diversity and model precision, especially for Class A and Class B. Previous related studies did not compare Class A and Class B separately, as these two categories were typically merged into a single group due to their highly similar color and morphological characteristics.

7.6. Manual Feature Extraction over End-to-End Deep Learning

We used manual feature extraction instead of an end-to-end deep learning model because our dataset is relatively small (600 images). Deep learning methods such as CNNs usually require large datasets to avoid overfitting and often do not perform well with limited data [64,65]. In contrast, traditional machine learning models with handcrafted features are more stable and reliable in small-data conditions [66]. The most difficult part of this study is distinguishing Class A and Class B, which look very similar in color and shape. Texture features extracted using GLCM can capture subtle differences—such as stem content and surface smoothness—that deep learning may fail to learn with limited samples [67,68].

Finally, the industrial partner requires a lightweight model that can run on standard CPU-based computers without a GPU. Manual feature extraction combined with traditional ML provides fast and practical performance for real-world deployment [69].

7.7. Practical Implications and Limitations

The two-stage LightGBM-based algorithm demonstrates high reliability and speed, making it suitable for automated grading in agricultural industries where real-time quality assessment is required. This hierarchical design can also be adapted to other agricultural products with overlapping visual features. However, the dataset size of 600 images remains limited. Thus, future studies should incorporate larger datasets under varying lighting and background conditions. Additionally, integrating deep learning feature extraction may further enhance robustness and reduce dependence on handcrafted features. The evaluation was conducted in a controlled research environment. The system has not yet been tested under real production-line conditions where noise, dust, motion, and strict real-time constraints are present.

8. Conclusions

This study presented a two-stage classification method using the LightGBM algorithm to automatically classify the quality of dried Moringa leaves into six categories. The method combines color and texture features to accurately classify them while addressing the difficulty of distinguishing visually similar classes. Experimental results show that this two-stage approach improved classification performance, increasing accuracy from 82% in the baseline model to 91% in the first stage and 90% in the second stage for fine-grained classes. LightGBM provided the best trade-off between accuracy and computational efficiency compared with other algorithms. Future work will focus on expanding the dataset under varied lighting and environmental conditions and integrating deep learning models, such as convolutional neural networks (CNNs), to further enhance robustness and reduce reliance on handcrafted features for real-time industrial applications.

In the other future work, we plan to incorporate additional texture descriptors such as Local Binary Patterns (LBP) to further improve the model’s ability to capture fine morphological differences between closely related classes, this study will incorporate additional color spaces such as HSV and Lab to enrich the feature representation and improve fine-grained class separation, especially for visually similar classes like A and B. This study will incorporate hyperparameter optimization for the LightGBM model—using techniques such as grid search, random search, or Bayesian optimization to tune parameters like learning_rate, num_leaves, n_estimators, feature_fraction, and bagging_fraction—with the aim of improving classification accuracy and reducing processing time. Future work will include larger-scale benchmarking and real-time testing to more accurately assess the model’s suitability for industrial implementation. For a limited dataset, in future research, we expand the dataset with additional samples and also explore data augmentation techniques to increase sample diversity and the dataset based on actual production lines under different environmental settings.