\n| Precision\u2011Recall Curve<\/th>\n | A performance metric that is more informative than accuracy in the presence of class imbalance.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n flowchart TD A[Data Collection] –> B[Imbalance Detected] B –> C[Resampling Strategies] C –> D[Cost-sensitive Learning] D –> E[Model Training] E –> F[Evaluation] F –> G[Deployment] C –> E D –> E<\/p>\n Concept: Why Imbalance Matters in Crop Disease Models<\/h2>\nIn supervised learning for crop disease detection, the distribution of disease classes often deviates markedly from an even split. For example, a dataset of leaf images might contain 95\u202f% healthy specimens and only 5\u202f% of a particular fungal infection. This skew in the class distribution\u2014known as class imbalance<\/em>\u2014has a cascade of effects that influence the statistical bias of the model, distort evaluation metrics, and, ultimately, jeopardise the reliability of crop yield forecasts used by agronomists and policy makers.<\/p>\n1. Model Bias Induced by Imbalance<\/h3>\nWhen the training data are dominated by a majority class, the learning algorithm tends to minimise error on that class, often at the expense of minority classes. In a typical cross\u2011entropy loss, each misclassification contributes equally to the total loss. If 95\u202f% of the samples belong to the healthy class, the optimiser will prioritise reducing errors on healthy instances simply because they are more plentiful. Consequently, the decision boundary is pulled towards the minority class, leading to a systematic bias that manifests as high false\u2011negative rates for rare diseases<\/strong>.<\/p>\nBias is not merely a statistical artefact; it translates into tangible agricultural costs. A model that consistently misclassifies a rust infection as healthy will allow the disease to spread unchecked, potentially reducing crop yield by up to 30\u202f% in affected regions. Conversely, over\u2011sensitivity to the majority class can cause over\u2011diagnosis, leading to unnecessary pesticide application and economic waste.<\/p>\n 2. Evaluation Metrics Skewed by Imbalance<\/h3>\nAccuracy is an intuitive metric, but in highly imbalanced settings it can be misleading. Consider a model that predicts every instance as healthy. With a 95\u202f% healthy prevalence, the accuracy would be 95\u202f%, yet the model offers no practical value. More informative metrics include precision, recall, F1\u2011score, and the area under the receiver operating characteristic curve (AUC\u2011ROC). However, these too can be affected by imbalance:<\/p>\n \n- Precision<\/strong> may appear high if the model rarely predicts the minority class, but this does not guarantee that the minority class is correctly identified.<\/li>\n
- Recall<\/strong> is especially sensitive to minority class performance; a low recall indicates that many disease instances remain undetected.<\/li>\n
- AUC\u2011ROC<\/strong> is robust to class imbalance in many cases, but when the minority class is extremely rare, the curve can flatten, giving an overly optimistic view of performance.<\/li>\n<\/ul>\n
To illustrate, the following Python snippet computes these metrics for a binary classifier on an imbalanced dataset. The code explicitly demonstrates how the minority class can be overlooked if we rely solely on accuracy.<\/p>\n import numpy as npfrom sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score<\/p>\n True labels: 0 = healthy, 1 = disease<\/h1>\ny_true = np.array([0]95 + [1]<\/em>5) # 95 healthy, 5 diseased<\/p>\nPredicted probabilities from a model<\/h1>\ny_pred_prob = np.array([0.05]95 + [0.95]<\/em>5) # perfect predictions<\/p>\nThreshold at 0.5 to get class predictions<\/h1>\ny_pred = (y_pred_prob >= 0.5).astype(int)print(“Accuracy:”, accuracy_score(y_true, y_pred))print(“Precision:”, precision_score(y_true, y_pred))print(“Recall:”, recall_score(y_true, y_pred))print(“F1-Score:”, f1_score(y_true, y_pred))print(“AUC-ROC:”, roc_auc_score(y_true, y_pred_prob))<\/p>\n Line\u2011by\u2011line explanation:<\/strong><\/p>\n\n- Import required libraries from numpy and sklearn.metrics.<\/li>\n
- Define the true labels: 95 instances of class\u202f0 (healthy) followed by 5 instances of class\u202f1 (disease).<\/li>\n
- Simulate model outputs: low probability (0.05) for healthy, high probability (0.95) for diseased, representing a perfectly discriminative model.<\/li>\n
- Convert probabilities to binary predictions using a 0.5 threshold.<\/li>\n
- Compute and display accuracy, precision, recall, F1\u2011score, and AUC\u2011ROC.<\/li>\n<\/ol>\n
Even with perfect discrimination, the class imbalance forces us to interpret each metric carefully. In real\u2011world scenarios, models rarely achieve perfect discrimination; hence the risk of misclassifying minority disease instances is far greater.<\/p>\n 3. Real\u2011World Implications for Crop Yield Forecasting<\/h3>\nYield forecasting models often integrate disease prevalence estimates as a key input. If disease detection is biased, the forecast will under\u2011estimate the impact of a pathogen, leading to insufficient resource allocation. For instance, a misjudged outbreak of wheat mildew could cause a 15\u202f% yield loss, yet the forecast might predict a 2\u202f% reduction, misleading stakeholders.<\/p>\n Moreover, public policy decisions\u2014such as issuing disease alerts or allocating subsidies\u2014rely on accurate disease prevalence data. An imbalanced model that systematically under\u2011reports a rare but devastating disease could delay intervention measures, exacerbating losses.<\/p>\n 4. Mitigation Strategies and Their Trade\u2011offs<\/h3>\nBelow is a concise table summarising common techniques to address class imbalance, along with their pros and cons in the context of crop disease modelling.<\/p>\n \n\n\n| Technique<\/th>\n | How It Works<\/th>\n | Benefits<\/th>\n | Drawbacks<\/th>\n<\/tr>\n<\/thead>\n | \n\n| Resampling (Oversampling Minority)<\/td>\n | Duplicate minority instances or create synthetic samples (SMOTE)<\/td>\n | Balances class distribution; simple to implement<\/td>\n | Risk of overfitting; synthetic data may not capture real variation<\/td>\n<\/tr>\n | \n| Resampling (Undersampling Majority)<\/td>\n | Remove majority instances to match minority count<\/td>\n | Reduces training time; prevents majority bias<\/td>\n | Loss of potentially valuable information; may discard rare healthy patterns<\/td>\n<\/tr>\n | \n| Cost\u2011Sensitive Learning<\/td>\n | Assign higher misclassification cost to minority class<\/td>\n | Maintains full dataset; directly penalises false negatives<\/td>\n | Requires careful tuning of cost matrix; may destabilise training<\/td>\n<\/tr>\n | \n| Ensemble Methods (Balanced Bagging)<\/td>\n | Train multiple models on balanced bootstraps and aggregate<\/td>\n | Improves robustness; mitigates variance<\/td>\n | Computationally intensive; complex model management<\/td>\n<\/tr>\n | \n| Threshold Adjustment<\/td>\n | Move classification threshold away from 0.5 to favour minority class<\/td>\n | Simple post\u2011processing step; no retraining needed<\/td>\n | May increase false positives; requires domain\u2011specific calibration<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Choosing the appropriate strategy depends on the severity of imbalance, the cost of false negatives versus false positives, and the computational resources available. In many agricultural settings, a hybrid approach\u2014combining SMOTE with cost\u2011sensitive loss functions\u2014has proven effective.<\/p>\n 5. Conclusion<\/h3>\nClass imbalance is not a peripheral issue; it sits at the heart of reliable crop disease modelling. It biases the learning process, distorts evaluation metrics, and undermines the credibility of yield forecasts that inform critical agronomic decisions. By recognising the multifaceted effects of imbalance and applying targeted mitigation techniques, practitioners can develop models that are both statistically sound and practically valuable for sustaining crop productivity.<\/p>\n # Example: Using Weighted Cross\u2011Entropy Loss in PyTorch to Handle Imbalanceimport torchimport torch.nn as nnimport torch.optim as optim<\/p>\n Assume binary classification: 0 = healthy, 1 = disease<\/h1>\nCompute class weights inversely proportional to class frequencies<\/h1>\nclass_counts = torch.tensor([950, 50], dtype=torch.float32) # 950 healthy, 50 diseasedclass_weights = 1.0 \/ class_countsclass_weights = class_weights \/ class_weights.sum() # normalisecriterion = nn.CrossEntropyLoss(weight=class_weights)optimizer = optim.Adam(model.parameters(), lr=1e-3)<\/p>\n Dummy training loop<\/h1>\nfor inputs, targets in dataloader: optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, targets) loss.backward() optimizer.step()<\/p>\n \n\n\n| Approach<\/th>\n | Weighting Scheme<\/th>\n | Typical Use\u2011case<\/th>\n | Pros<\/th>\n | Cons<\/th>\n<\/tr>\n<\/thead>\n | \n\n| Class\u2011Balanced Sampling<\/td>\n | Oversample minority or undersample majority<\/td>\n | When data size permits<\/td>\n | Simple, effective<\/td>\n | Risk of overfitting or information loss<\/td>\n<\/tr>\n | \n| Cost\u2011Sensitive Loss<\/td>\n | Weighted loss functions (e.g., focal loss)<\/td>\n | When preserving data is critical<\/td>\n | Retains all samples<\/td>\n | Requires careful tuning<\/td>\n<\/tr>\n | \n| Ensemble Balancing<\/td>\n | Multiple balanced models aggregated<\/td>\n | High\u2011variance problems<\/td>\n | Robustness<\/td>\n | Computational cost<\/td>\n<\/tr>\n | \n| Threshold Tuning<\/td>\n | Adjust decision threshold post\u2011training<\/td>\n | When model is already trained<\/td>\n | No retraining<\/td>\n | May inflate false positives<\/td>\n<\/tr>\n | \n| Synthetic Data Generation (SMOTE)<\/td>\n | Create synthetic minority samples<\/td>\n | When minority samples are scarce<\/td>\n | Enriches dataset<\/td>\n | Synthetic noise may mislead model<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Activity: Reflect on Class Imbalance Impact<\/span><\/p>\nThink back to the section on why imbalance matters in crop disease models. Consider how a skewed distribution of disease labels could affect model accuracy, precision, and recall. Write a brief reflection (2-4 sentences) on how you would identify imbalance in a new dataset and what initial steps you might take to mitigate its effects.<\/p>\n Implementation\/Code: Resampling and SMOTE with scikit\u2011learn<\/h2>\nWhen working with crop disease data the most common stumbling block is class imbalance. A single outbreak can generate thousands of images of diseased leaves while healthy samples are scarce, or vice versa. If left unchecked, machine\u2011learning models will happily learn to predict the majority class and neglect the minority. Resampling techniques \u2013 both undersampling the majority and oversampling the minority \u2013 provide a straightforward way of re\u2011balancing the training data. The Synthetic Minority Over-sampling Technique (SMOTE) takes this further by generating synthetic examples rather than merely duplicating existing ones, which can reduce overfitting.<\/p>\n 1. Preparing the dataset for resampling<\/h3>\nAssume we have already extracted features from crop leaf images and stored them in a Pandas DataFrame called df. The target variable is named label and contains categorical values such as ‘healthy’, ‘rust’, ‘blight’. Before resampling we must convert the categorical labels into numeric form, split the data into training and testing sets, and standardise the features because SMOTE is sensitive to feature scales.<\/p>\n import pandas as pdfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import StandardScalerfrom sklearn.preprocessing import LabelEncoder<\/p>\n Load the feature matrix<\/h1>\ndf = pd.read_csv(‘crop_features.csv’)<\/p>\n Separate features and target<\/h1>\nX = df.drop(columns=[‘label’])y = df[‘label’]<\/p>\n Encode labels as integers<\/h1>\nle = LabelEncoder()y_encoded = le.fit_transform(y)<\/p>\n Train\u2013test split (80\/20)<\/h1>\nX_train, X_test, y_train, y_test = train_test_split( X, y_encoded, test_size=0.2, stratify=y_encoded, random_state=42)<\/p>\n Feature scaling \u2013 SMOTE requires the same scale across features<\/h1>\nscaler = StandardScaler()X_train_scaled = scaler.fit_transform(X_train)X_test_scaled = scaler.transform(X_test)<\/p>\n Explanation of each line:<\/strong><\/p>\n\n- import pandas as pd \u2013 imports the Pandas library for data manipulation.<\/li>\n
- from sklearn.model_selection import train_test_split \u2013 brings in the function that will split our data.<\/li>\n
- from sklearn.preprocessing import StandardScaler \u2013 provides a simple way to standardise features.<\/li>\n
- from sklearn.preprocessing import LabelEncoder \u2013 converts string labels into integer codes.<\/li>\n
- df = pd.read_csv(‘crop_features.csv’) \u2013 reads the pre\u2011processed feature file.<\/li>\n
- X = df.drop(columns=[‘label’]) \u2013 creates a DataFrame with all columns except the target.<\/li>\n
- y = df[‘label’] \u2013 extracts the target column.<\/li>\n
- le = LabelEncoder() \u2013 initialises the encoder.<\/li>\n
- y_encoded = le.fit_transform(y) \u2013 fits the encoder to the labels and transforms them into numeric form.<\/li>\n
- train_test_split(…, stratify=y_encoded, …) \u2013 splits the data while preserving the class proportions in both sets.<\/li>\n
- scaler = StandardScaler() \u2013 creates a scaler object.<\/li>\n
- X_train_scaled = scaler.fit_transform(X_train) \u2013 learns the mean and variance from the training set and applies the transformation.<\/li>\n
- X_test_scaled = scaler.transform(X_test) \u2013 applies the same transformation to the test set to keep the scaling consistent.<\/li>\n<\/ol>\n
2. Undersampling the majority class<\/h3>\nUndersampling removes instances from the majority class until the class distribution matches that of the minority. This is useful when the majority class is overwhelmingly large and the dataset is still of manageable size. The RandomUnderSampler from the imblearn library offers a simple implementation.<\/p>\n from imblearn.under_sampling import RandomUnderSamplerrus = RandomUnderSampler(sampling_strategy=’auto’, random_state=42)X_res_undersampled, y_res_undersampled = rus.fit_resample( X_train_scaled, y_train)print(f’Original training set: {len(y_train)} samples’)print(f’Undersampled set: {len(y_res_undersampled)} samples’)print(‘Class distribution after undersampling:’, pd.Series(y_res_undersampled).value_counts())<\/p>\n In the snippet:<\/p>\n \n- RandomUnderSampler is initialised with sampling_strategy=’auto’, which automatically balances all classes to the count of the minority class.<\/li>\n
- fit_resample performs the undersampling and returns the resampled feature matrix and labels.<\/li>\n
- Printing the sizes and class counts confirms that the majority class has been trimmed.<\/li>\n<\/ul>\n
3. Oversampling the minority class<\/h3>\nOversampling duplicates minority instances until the desired balance is achieved. The RandomOverSampler is a quick way to do this, but it can lead to over\u2011fitting because it creates exact copies. Nevertheless, it is still widely used as a baseline.<\/p>\n from imblearn.over_sampling import RandomOverSamplerros = RandomOverSampler(sampling_strategy=’auto’, random_state=42)X_res_oversampled, y_res_oversampled = ros.fit_resample( X_train_scaled, y_train)print(‘Class distribution after oversampling:’, pd.Series(y_res_oversampled).value_counts())<\/p>\n Here the logic mirrors undersampling: the sampler is fitted to the training data and returns a new dataset where each class contains an equal number of samples.<\/p>\n 4. Applying SMOTE \u2013 generating synthetic minority samples<\/h3>\nSMOTE constructs new minority samples by interpolating between existing minority instances. It mitigates the duplication problem inherent in plain oversampling. The standard SMOTE implementation from imblearn.over_sampling can be combined with a preprocessing pipeline for cleaner code.<\/p>\n from imblearn.over_sampling import SMOTEfrom sklearn.pipeline import Pipelinefrom sklearn.ensemble import RandomForestClassifierfrom sklearn.metrics import classification_report<\/p>\n Define SMOTE with a 1:1 target ratio<\/h1>\nsmote = SMOTE(sampling_strategy=’auto’, random_state=42)<\/p>\n Build a pipeline: SMOTE \u2192 classifier<\/h1>\npipeline = Pipeline(steps=[ (‘smote’, smote), (‘clf’, RandomForestClassifier(n_estimators=200, random_state=42))])<\/p>\n Train the pipeline on the original training data<\/h1>\npipeline.fit(X_train_scaled, y_train)<\/p>\n Predict on the untouched test set<\/h1>\ny_pred = pipeline.predict(X_test_scaled)<\/p>\n Evaluate<\/h1>\nprint(classification_report(y_test, y_pred, target_names=le.classes_))<\/p>\n Explanation of the pipeline:<\/p>\n \n- SMOTE is configured to resample until each class has the same number of instances.<\/li>\n
- The RandomForestClassifier is a robust baseline model that tolerates noisy data.<\/li>\n
- During fit, the pipeline first applies SMOTE to the training set, generating synthetic samples, then trains the classifier on this balanced data.<\/li>\n
- Prediction is performed on the unaltered test set to assess real\u2011world performance.<\/li>\n
- The classification_report shows precision, recall, f1\u2011score per class, allowing us to verify that the minority class has improved without an unacceptable drop in majority performance.<\/li>\n<\/ol>\n
5. Comparing resampling strategies<\/h3>\nIt is useful to visualise the effect of each approach. The following table summarises the class distribution after each method, assuming a hypothetical dataset with three classes: healthy (10,000 samples), rust (1,200 samples), blight (800 samples).<\/p>\n \n\n\n| Method<\/th>\n | healthy<\/th>\n | rust<\/th>\n | blight<\/th>\n | Total<\/th>\n<\/tr>\n<\/thead>\n | \n\n| Original<\/td>\n | 10,000<\/td>\n | 1,200<\/td>\n | 800<\/td>\n | 12,000<\/td>\n<\/tr>\n | \n| Undersampling (to minority)<\/td>\n | 800<\/td>\n | 800<\/td>\n | 800<\/td>\n | 2,400<\/td>\n<\/tr>\n | \n| Oversampling (to majority)<\/td>\n | 10,000<\/td>\n | 10,000<\/td>\n | 10,000<\/td>\n | 30,000<\/td>\n<\/tr>\n | \n| SMOTE (to majority)<\/td>\n | 10,000<\/td>\n | 10,000<\/td>\n | 10,000<\/td>\n | 30,000<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n As seen, SMOTE and plain oversampling produce identical class counts but differ in the nature of the minority samples \u2013 synthetic versus duplicated. Undersampling drastically reduces data volume, which may be undesirable if the dataset is already small.<\/p>\n 6. Practical recommendations for crop disease datasets<\/h3>\n\n- Start with SMOTE.<\/strong> Synthetic samples tend to improve generalisation because they introduce slight variations that mimic real disease spread.<\/li>\n
- Keep the test set untouched.<\/strong> Resampling should never be applied to the test material; otherwise you risk inflating performance metrics.<\/li>\n
- Check for feature leakage.<\/strong> When scaling before SMOTE, ensure that the scaler is fitted only on the training data; the code above follows this principle.<\/li>\n
- Monitor over\u2011fitting.<\/strong> If you observe a large gap between training and test f1\u2011scores, consider reducing the number of synthetic samples or switching to a more conservative oversampling method such as BorderlineSMOTE.<\/li>\n
- Use stratified cross\u2011validation.<\/strong> When evaluating models, stratify splits to preserve the original imbalance, then apply SMOTE within each fold.<\/li>\n<\/ul>\n
By integrating these resampling steps into your workflow, you can mitigate the detrimental effects of class imbalance on crop disease classifiers and achieve more reliable, deployable models.<\/p>\n 7. Example: Adversarially Generated Synthetic Samples with ADASYN<\/h3>\nWhile SMOTE interpolates between existing minority points, ADASYN (Adaptive Synthetic) focuses on difficult-to-learn examples by weighting the generation process towards samples that are harder to classify. This can improve performance when the minority class is highly heterogeneous.<\/p>\n from imblearn.over_sampling import ADASYN<\/p>\n ADASYN with a target ratio of 1:1<\/h1>\nadasyn = ADASYN(sampling_strategy=’auto’, random_state=42)X_res_adasyn, y_res_adasyn = adasyn.fit_resample( X_train_scaled, y_train)print(‘Class distribution after ADASYN:’, pd.Series(y_res_adasyn).value_counts())<\/p>\n Train a simple SVM on the ADASYN\u2011balanced data<\/h1>\nfrom sklearn.svm import SVCsvm_clf = SVC(kernel=’rbf’, class_weight=’balanced’, random_state=42)svm_clf.fit(X_res_adasyn, y_res_adasyn)y_pred_adasyn = svm_clf.predict(X_test_scaled)print(classification_report(y_test, y_pred_adasyn, target_names=le.classes_))<\/p>\n Features of ADASYN:<\/p>\n \n- Generates more synthetic samples in regions where the minority class is sparse.<\/li>\n
- Can reduce bias towards majority class by concentrating effort on hard cases.<\/li>\n
- Often yields higher recall for the minority class at the cost of a modest precision drop.<\/li>\n<\/ul>\n
8. Comparative Summary of Resampling Methods<\/h3>\nThe table below contrasts the key characteristics of undersampling, oversampling, SMOTE, BorderlineSMOTE, and ADASYN when applied to crop disease datasets.<\/p>\n \n\n\n| Method<\/th>\n | Data Volume Change<\/th>\n | Risk of Over\u2011fitting<\/th>\n | Complexity of Synthetic Samples<\/th>\n | Typical Use\u2011case<\/th>\n<\/tr>\n<\/thead>\n | \n\n| Random Undersampling<\/td>\n | \u2193 (reduces majority)<\/td>\n | Low<\/td>\n | None (removes real samples)<\/td>\n | Very large majority class, limited data<\/td>\n<\/tr>\n | \n| Random Oversampling<\/td>\n | \u2191 (duplicates minority)<\/td>\n | High (exact duplicates)<\/td>\n | None (copies)<\/td>\n | Baseline, quick test<\/td>\n<\/tr>\n | \n| SMOTE<\/td>\n | \u2191 (generates synthetic minority)<\/td>\n | Medium (interpolated)<\/td>\n | Linear interpolation<\/td>\n | Standard balanced training<\/td>\n<\/tr>\n | \n| BorderlineSMOTE<\/td>\n | \u2191 (focuses on borderline samples)<\/td>\n | Medium (synthetic near decision boundary)<\/td>\n | Weighted interpolation<\/td>\n | When minority has hard boundaries<\/td>\n<\/tr>\n | \n| ADASYN<\/td>\n | \u2191 (adaptive generation)<\/td>\n | Medium (focus on hard examples)<\/td>\n | Adaptive weighted interpolation<\/td>\n | Highly heterogeneous minority class<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Activity: Quick quiz on Resampling and SMOTE<\/span><\/p>\n\n- Which resampling technique can help to balance the majority and minority classes by duplicating minority samples?<\/li>\n
- What does SMOTE stand for and how does it create synthetic samples?<\/li>\n
- When using SMOTE, why is it important to apply it only to the training set and not to the test set?<\/li>\n
- Which scikit\u2011learn function is used to perform random undersampling?<\/li>\n<\/ol>\n
9. Alternative Mitigation: Synthetic Minority Over\u2011Sampling Technique (SMOTE)<\/h3>\nSMOTE generates synthetic minority samples by interpolating between existing points in feature space. For image data it is usually applied after feature extraction (e.g. after the flattening step) rather than directly on pixel arrays.<\/p>\n from imblearn.over_sampling import SMOTE<\/p>\n Assume X_train_features is already defined<\/h1>\nsmote = SMOTE(random_state=42)X_smote, y_smote = smote.fit_resample(X_train_features, y_res)print(‘After SMOTE:’, Counter(y_smote))<\/p>\n SMOTE can increase diversity compared to simple duplication, but may introduce noise if the feature space is not well\u2011represented by a linear interpolation.<\/p>\n \n\n\n| Approach<\/th>\n | How it Works<\/th>\n | Pros<\/th>\n | Cons<\/th>\n<\/tr>\n<\/thead>\n | \n\n| Random Under\u2011Sampling<\/td>\n | Remove majority samples to balance<\/td>\n | Simple, reduces training time<\/td>\n | Potential loss of useful information<\/td>\n<\/tr>\n | \n| Random Over\u2011Sampling<\/td>\n | Duplicate minority samples<\/td>\n | Preserves all data, easy to implement<\/td>\n | Risk of overfitting, larger training set<\/td>\n<\/tr>\n | \n| SMOTE<\/td>\n | Generate synthetic minority points via interpolation<\/td>\n | More diverse than duplication, less overfitting<\/td>\n | Assumes linearity in feature space, may create noisy samples<\/td>\n<\/tr>\n | \n| Class\u2011Weighting<\/td>\n | Adjust loss function to penalise minority errors more<\/td>\n | No change to data size, works with any model<\/td>\n | Requires careful tuning, may still be biased if imbalance severe<\/td>\n<\/tr>\n | \n| Focal Loss<\/td>\n | Modifies cross\u2011entropy to focus on hard examples<\/td>\n | Effective for deep learning, handles imbalance implicitly<\/td>\n | More complex to implement, hyperparameter tuning needed<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Activity: Choosing the Right Resampling Strategy for Tomato Blight<\/span><\/p>\nYou have just completed the end\u2011to\u2011end pipeline for the tomato blight dataset, including preprocessing, feature engineering, and model training. Now, you need to decide how to handle the pronounced class imbalance (few infected leaves compared to healthy ones). Based on the techniques discussed in this lesson, outline which resampling method (undersampling, oversampling, SMOTE, or class\u2011weighting) you would apply, justify your choice, and describe how you would integrate it into the existing pipeline. Think about the impact on model performance, training time, and potential overfitting.<\/p>\n Pitfalls: Common Mistakes and How to Avoid Them<\/h2>\nHandling class imbalance is a delicate balancing act. While resampling strategies, synthetic data generation and cost\u2011sensitive learning can greatly improve model performance, they also open the door to subtle errors that can undermine the entire project. In this section we dissect the most frequent mistakes that crop disease researchers make, analyse why they occur, and provide concrete guidance on how to sidestep them. By understanding these pitfalls we can design robust pipelines that genuinely improve detection of rare diseases rather than artefacts of data engineering.<\/p>\n 1. Data Leakage During Resampling<\/h3>\nData leakage is arguably the most insidious source of over\u2011optimistic performance estimates. When resampling is performed without strict separation of training and test data, the model is inadvertently exposed to information that would not be available at inference time. This is particularly problematic in crop disease datasets where images are often grouped by field, time, or even camera. If the split is performed at the image level rather than at the field level, synthetic or augmented samples can leak across the boundary.<\/p>\n Consider a scenario where a field contains 200 healthy and 20 diseased images. If we randomly select 10% of the images for the test set, we might end up with 2 diseased images in the test set. If we then apply SMOTE to the training data, SMOTE will generate synthetic samples based on the 18 diseased training images. Because the 2 test images share the same field and possibly the same visual characteristics, the synthetic samples will be highly correlated with the test set, leading to inflated performance metrics.<\/p>\n To avoid leakage:<\/p>\n \n- Split at the highest level of granularity<\/strong> (e.g. field, plot, or time period) before any resampling or augmentation.<\/li>\n
- Apply resampling only to the training split<\/strong> and keep the test set untouched.<\/li>\n
- Use nested cross\u2011validation<\/strong> where the inner loop performs resampling and hyper\u2011parameter optimisation, while the outer loop evaluates on a held\u2011out set that has never seen the resampled data.<\/li>\n<\/ul>\n
2. Overfitting to Synthetic Samples<\/h3>\nGenerating synthetic data, whether through SMOTE, ADASYN or GANs, is often a double\u2011edged sword. While it can provide a more balanced class distribution, it can also create samples that are unnaturally similar to each other, especially when the minority class is very small. Models trained on such data may learn to recognise artefacts of the generation process rather than genuine disease markers.<\/p>\n For example, a GAN trained on 30 diseased leaf images may produce synthetic leaves that share a specific texture pattern or colour gradient that is not present in real diseased samples. A convolutional neural network will then pick up on this artefact, yielding high accuracy on the synthetic\u2011augmented training set but poor generalisation to real field images.<\/p>\n Mitigation strategies:<\/p>\n \n- Limit the number of synthetic samples<\/strong> to a reasonable proportion of the minority class, e.g. 2\u20133 times the minority count, rather than oversaturating the training set.<\/li>\n
- Introduce diversity in augmentation<\/strong> by varying rotation, scaling, brightness, and contrast within realistic bounds.<\/li>\n
- Validate on a separate hold\u2011out set of real minority samples<\/strong> that were never used for synthetic generation.<\/li>\n
- Inspect synthetic samples visually<\/strong> and with domain experts to ensure they are plausible.<\/li>\n<\/ol>\n
Below is a concise example that demonstrates how to generate synthetic samples with SMOTE while carefully monitoring for overfitting. The code uses scikit\u2011learn\u2019s SMOTE and a simple logistic regression classifier. The training and validation loops are annotated to emphasise the separation of synthetic data from the test set.<\/p>\n import numpy as npfrom sklearn.model_selection import train_test_splitfrom imblearn.over_sampling import SMOTEfrom sklearn.linear_model import LogisticRegressionfrom sklearn.metrics import classification_report, confusion_matrix<\/p>\n Assume X, y are pre\u2011processed feature matrices and labels<\/h1>\nSplit into train+val and test at the field level<\/h1>\nX_train_val, X_test, y_train_val, y_test = train_test_split( X, y, test_size=0.2, stratify=y, random_state=42)<\/p>\n Further split training+validation into training and validation<\/h1>\nX_train, X_val, y_train, y_val = train_test_split( X_train_val, y_train_val, test_size=0.25, stratify=y_train_val, random_state=42)<\/p>\n 1. Apply SMOTE only on the training data<\/h1>\nsmote = SMOTE(sampling_strategy=’auto’, random_state=42)X_train_res, y_train_res = smote.fit_resample(X_train, y_train)<\/p>\n 2. Train a simple model on the resampled data<\/h1>\nclf = LogisticRegression(max_iter=1000, random_state=42)clf.fit(X_train_res, y_train_res)<\/p>\n 3. Evaluate on the untouched validation set<\/h1>\nprint(“Validation performance:”)print(classification_report(y_val, clf.predict(X_val)))<\/p>\n 4. Final evaluation on the hold\u2011out test set<\/h1>\nprint(“Test performance:”)print(classification_report(y_test, clf.predict(X_test)))<\/p>\n Line\u2011by\u2011line explanation:<\/strong><\/p>\n\n- Lines 1\u20134 import the necessary libraries.<\/li>\n
- Line 7 performs a field\u2011level split, ensuring that images from the same field are never shared between training and test sets.<\/li>\n
- Line 12 further splits the training data into a smaller training set and a validation set, again preserving field boundaries.<\/li>\n
- Line 17 instantiates SMOTE with the default strategy of balancing all classes to the majority count.<\/li>\n
- Line 18 applies SMOTE only to the training subset, producing a new feature matrix X_train_res and labels y_train_res.<\/li>\n
- Line 21 trains a logistic regression model on the resampled data.<\/li>\n
- Lines 24\u201326 evaluate the model on the validation set, which contains no synthetic samples.<\/li>\n
- Lines 29\u201331 provide the final test set evaluation, guaranteeing that the test data has never seen any synthetic or augmented samples.<\/li>\n<\/ul>\n
3. Misinterpreting Accuracy on Imbalanced Data<\/h3>\nAccuracy is a seductive metric: it is easy to compute and interpret. However, on highly imbalanced datasets it can give a misleading picture of model performance. Suppose a crop disease dataset contains 95% healthy leaves and 5% diseased leaves. A na\u00efve classifier that simply predicts every leaf as healthy will achieve 95% accuracy, yet it will miss all diseased cases.<\/p>\n When using accuracy as a primary metric, one often overlooks the following:<\/p>\n | | | | | |