Lesson 1.2.2: AI and remote sensing for crop monitoring Dashboard \u203a My courses \u203a Course \u203a Lesson 1.2.2: AI and remote sensing for crop monitoring <\/p>\n
\u23f2 31 min read<\/span> \ud83d\udcc4 6152 words<\/span><\/p>\n Learning Objectives<\/strong><\/p>\n Key Terms<\/strong><\/p>\n flowchart TD A[Satellite Imagery] –> B[Data Acquisition] B –> C[Pre\u2011processing (Calibration, Cloud Masking)] C –> D[Feature Extraction (NDVI, EVI, etc.)] D –> E[Crop Health Index] E –> F[Decision Support (Yield Forecast, Irrigation Planning)]<\/p>\n Remote sensing is the science of acquiring information about an object or phenomenon without making physical contact. In the context of agriculture, it allows agronomists, farm managers and researchers to observe crop health, growth stages, and stress factors over vast areas with high temporal resolution. The technology relies on sensors mounted on aircraft, satellites or drones that capture electromagnetic energy reflected or emitted by the Earth’s surface. Understanding the basic principles of remote sensing\u2014such as the electromagnetic spectrum, sensor characteristics, image interpretation, and data processing\u2014is essential for harnessing its full potential in crop monitoring.<\/p>\n Remote sensing sensors detect reflected or emitted energy across various spectral bands. The most relevant for vegetation monitoring are:<\/p>\n Each band captures distinct physiological signals. For example, healthy plants exhibit high NIR reflectance and low red reflectance, forming the basis of vegetation indices such as NDVI.<\/p>\n Remote sensing data can be obtained from three main platforms, each with distinct advantages:<\/p>\n The choice of platform depends on the spatial scale, temporal frequency, and budget constraints of the monitoring programme.<\/p>\n Raw sensor data are influenced by atmospheric conditions, sensor noise, and sensor geometry. Two principal correction steps are:<\/p>\n Failure to perform these corrections can lead to erroneous interpretation of vegetation health.<\/p>\n Vegetation indices are mathematical combinations of spectral bands designed to highlight specific plant characteristics. The most widely used index is the Normalised Difference Vegetation Index (NDVI):<\/p>\n NDVI = (NIR – Red) \/ (NIR + Red)<\/p>\n NDVI values range from -1 to +1. Values close to +1 indicate dense, healthy vegetation, whereas values near 0 or negative suggest sparse vegetation or non\u2011vegetated surfaces.<\/p>\n Other indices include:<\/p>\n By analysing temporal NDVI trends, one can infer crop vigour, detect early stress, and estimate yield potential.<\/p>\n Below is a concise Python snippet that demonstrates how to read Sentinel\u20112 Level\u20112A imagery, perform atmospheric correction to TOA reflectance, and compute NDVI. The example uses the rasterio library for raster handling and numpy for numerical operations.<\/p>\n import rasterioimport numpy as np<\/p>\n with rasterio.open(‘S2B_20230501_T31TCJ_B08.jp2’) as src_nir: nir = src_nir.read(1).astype(‘float32’)with rasterio.open(‘S2B_20230501_T31TCJ_B04.jp2’) as src_red: red = src_red.read(1).astype(‘float32’)<\/p>\n nir_ref = nir * 0.0001red_ref = red * 0.0001<\/p>\n denominator = nir_ref + red_refdenominator[denominator == 0] = np.nan<\/p>\n ndvi = (nir_ref – red_ref) \/ denominator<\/p>\n profile = src_nir.profileprofile.update(dtype=rasterio.float32, count=1, compress=’lzw’)with rasterio.open(‘NDVI_S2B_20230501.tif’, ‘w’, **profile) as dst: dst.write(ndvi.astype(rasterio.float32), 1)<\/p>\n Line\u2011by\u2011line explanation:<\/p>\n Remote sensing excels at capturing temporal dynamics. By stacking NDVI time series, one can detect:<\/p>\n Statistical tools such as linear regression or breakpoint analysis help quantify these trends. Machine learning classifiers can also be trained on multi\u2011band imagery to segment crop types and map field boundaries automatically.<\/p>\n While remote sensing provides broad coverage, ground truth data are essential for calibration and validation. Field measurements of leaf area index (LAI), chlorophyll content, or yield provide the basis for:<\/p>\n When combined with decision support systems, remote sensing can generate actionable insights\u2014such as variable rate fertiliser maps, irrigation scheduling, or early warning alerts for disease outbreaks.<\/p>\n Despite its power, remote sensing has inherent constraints that must be recognised:<\/p>\n Being aware of these limitations ensures that remote sensing outputs are used appropriately and supplemented with complementary information where necessary.<\/p>\n Artificial intelligence, particularly deep learning, is increasingly applied to remote sensing for tasks such as semantic segmentation, anomaly detection, and predictive modelling. Convolutional neural networks can automatically extract complex spatial patterns from multi\u2011band imagery, outperforming traditional indices in some contexts. However, AI models require large, well\u2011annotated training datasets and careful validation to avoid overfitting or bias. Integrating AI with classical remote sensing techniques\u2014such as using NDVI as an input feature to a machine learning model\u2014often yields the most robust results.<\/p>\n In summary, remote sensing fundamentals encompass understanding the spectral basis of vegetation signals, selecting appropriate sensor platforms, applying necessary corrections, computing indices like NDVI, and integrating these data with ground truth and AI tools. Mastery of these concepts equips practitioners to monitor crop health accurately, optimise resource use, and ultimately enhance agricultural productivity.<\/p>\n The NDWI is useful for monitoring surface water and vegetation water content. It uses the near\u2011infrared (NIR) and short\u2011wave infrared (SWIR) bands:<\/p>\n import rasterioimport numpy as np<\/p>\n with rasterio.open(‘S2B_20230501_T31TCJ_B08.jp2’) as src_nir: nir = src_nir.read(1).astype(‘float32’) * 0.0001 # reflectancewith rasterio.open(‘S2B_20230501_T31TCJ_B11.jp2’) as src_swir: swir = src_swir.read(1).astype(‘float32’) * 0.0001<\/p>\n den = nir + swirden[den == 0] = np.nan<\/p>\n ndwi = (nir – swir) \/ den<\/p>\n profile = src_nir.profileprofile.update(dtype=rasterio.float32, count=1, compress=’lzw’)with rasterio.open(‘NDWI_S2B_20230501.tif’, ‘w’, **profile) as dst: dst.write(ndwi.astype(rasterio.float32), 1)<\/p>\n Activity: Reflect on Remote Sensing Fundamentals for Crop Monitoring<\/span><\/p>\n Think about how the basic principles of remote sensing\u2014such as spectral bands, spatial resolution, and data acquisition\u2014can be applied to monitor crop health and yield. Consider the challenges of interpreting satellite imagery in diverse agricultural landscapes and how you might address them. Write a short reflection on one advantage and one limitation of using remote sensing in real-world crop monitoring.<\/p>\n In this section we will walk through the entire pipeline for constructing a convolutional neural network (CNN) that can classify crop disease stages from remote sensing imagery. The example uses the popular Keras API within TensorFlow, as it provides a high\u2011level interface that is both expressive and well\u2011documented. We will cover data preparation, model architecture, training, evaluation and a brief discussion of practical deployment considerations.<\/p>\n Remote sensing data is typically organised in multi\u2011band images (e.g. RGB, near\u2011infrared, thermal). For the sake of clarity we assume a three\u2011channel RGB representation, but the same principles apply to higher\u2011dimensional inputs. The dataset is split into training, validation and test sets, and each image is normalised to the range [0,\u202f1] to stabilise gradient descent.<\/p>\n import tensorflow as tffrom tensorflow.keras.preprocessing.image import ImageDataGenerator<\/p>\n train_dir = ‘data\/train’val_dir = ‘data\/val’test_dir = ‘data\/test’<\/p>\n train_datagen = ImageDataGenerator( rescale=1.\/255, rotation_range=20, width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True, fill_mode=’nearest’)val_datagen = ImageDataGenerator(rescale=1.\/255)test_datagen = ImageDataGenerator(rescale=1.\/255)<\/p>\n train_generator = train_datagen.flow_from_directory( train_dir, target_size=(128, 128), batch_size=32, class_mode=’categorical’)val_generator = val_datagen.flow_from_directory( val_dir, target_size=(128, 128), batch_size=32, class_mode=’categorical’)test_generator = test_datagen.flow_from_directory( test_dir, target_size=(128, 128), batch_size=32, class_mode=’categorical’, shuffle=False)<\/p>\n Line\u2011by\u2011line explanation:<\/strong><\/p>\n We adopt a modest depth to keep inference times low, yet sufficient to capture the spatial hierarchies pertinent to disease stage detection. Convolutional layers learn local patterns, max\u2011pooling reduces spatial resolution while retaining salient features, and fully connected layers perform the final classification.<\/p>\n from tensorflow.keras import layers, modelsdef build_cnn(input_shape=(128, 128, 3), num_classes=5): model = models.Sequential(name=’CropHealthCNN’) # Block 1 model.add(layers.Conv2D(32, (3, 3), activation=’relu’, padding=’same’, input_shape=input_shape)) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(32, (3, 3), activation=’relu’, padding=’same’)) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Dropout(0.25)) # Block 2 model.add(layers.Conv2D(64, (3, 3), activation=’relu’, padding=’same’)) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(64, (3, 3), activation=’relu’, padding=’same’)) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Dropout(0.25)) # Block 3 model.add(layers.Conv2D(128, (3, 3), activation=’relu’, padding=’same’)) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(128, (3, 3), activation=’relu’, padding=’same’)) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Dropout(0.25)) # Classification head model.add(layers.Flatten()) model.add(layers.Dense(256, activation=’relu’)) model.add(layers.BatchNormalization()) model.add(layers.Dropout(0.5)) model.add(layers.Dense(num_classes, activation=’softmax’)) return model<\/p>\n Key points:<\/p>\n We employ the Adam optimiser with an initial learning rate of 0.001, which adapts the step size during training. Categorical cross\u2011entropy is appropriate for multi\u2011class classification with one\u2011hot encoded labels.<\/p>\n model = build_cnn(num_classes=train_generator.num_classes)model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss=’categorical_crossentropy’, metrics=[‘accuracy’])model.summary()<\/p>\n The model.summary() call prints a concise overview of the parameter count and layer shapes, useful for debugging.<\/p>\n Training is performed over a fixed number of epochs, but early stopping and learning\u2011rate reduction callbacks prevent overfitting and accelerate convergence.<\/p>\n callbacks = [ tf.keras.callbacks.EarlyStopping( monitor=’val_loss’, patience=10, restore_best_weights=True ), tf.keras.callbacks.ReduceLROnPlateau( monitor=’val_loss’, factor=0.5, patience=5, min_lr=1e-6 )]history = model.fit( train_generator, epochs=100, validation_data=val_generator, callbacks=callbacks)<\/p>\n Explanation:<\/p>\n After training, the model is evaluated on the held\u2011out test set to gauge generalisation. Metrics beyond accuracy, such as the confusion matrix and per\u2011class recall, are often more informative when class distributions are imbalanced.<\/p>\n import numpy as npimport matplotlib.pyplot as pltfrom sklearn.metrics import classification_report, confusion_matrix<\/p>\n test_steps = test_generator.samples \/\/ test_generator.batch_sizepred_probs = model.predict(test_generator, steps=test_steps, verbose=1)pred_labels = np.argmax(pred_probs, axis=1)<\/p>\n true_labels = test_generator.classesclass_names = list(test_generator.class_indices.keys())<\/p>\n report = classification_report(true_labels, pred_labels, target_names=class_names)print(report)<\/p>\n cm = confusion_matrix(true_labels, pred_labels)fig, ax = plt.subplots(figsize=(8, 6))im = ax.imshow(cm, interpolation=’nearest’, cmap=plt.cm.Blues)ax.figure.colorbar(im, ax=ax)ax.set_xticks(np.arange(len(class_names)))ax.set_yticks(np.arange(len(class_names)))ax.set_xticklabels(class_names, rotation=45, ha=’right’)ax.set_yticklabels(class_names)ax.set_xlabel(‘Predicted label’)ax.set_ylabel(‘True label’)plt.title(‘Confusion Matrix’)plt.tight_layout()plt.show()<\/p>\n This script produces a comprehensive performance summary. A high overall accuracy might mask poor detection of a rare disease stage; the confusion matrix and per\u2011class recall illuminate such issues.<\/p>\n When the dataset is small, leveraging a pre\u2011trained backbone can drastically improve performance. The following example demonstrates how to fine\u2011tune MobileNetV2, freezing early layers and adding a custom head for crop disease classification.<\/p>\n from tensorflow.keras.applications import MobileNetV2from tensorflow.keras import layers, models, optimizersdef build_transfer_model(input_shape=(128, 128, 3), num_classes=5): base = MobileNetV2(input_shape=input_shape, include_top=False, weights=’imagenet’) base.trainable = False # freeze the backbone x = base.output x = layers.GlobalAveragePooling2D()(x) x = layers.Dense(512, activation=’relu’)(x) x = layers.Dropout(0.5)(x) outputs = layers.Dense(num_classes, activation=’softmax’)(x) model = models.Model(inputs=base.input, outputs=outputs) return modelmodel_tl = build_transfer_model(num_classes=train_generator.num_classes)model_tl.compile(optimizer=optimizers.Adam(learning_rate=1e-4), loss=’categorical_crossentropy’, metrics=[‘accuracy’])model_tl.summary()<\/p>\n We have demonstrated a complete workflow for building a CNN that classifies crop disease stages from remote sensing imagery. Starting from data preparation and augmentation, through model construction, training with strategic callbacks, to rigorous evaluation and deployment pragmatics, each step is essential for delivering a reliable, field\u2011ready solution. The code snippets provide a ready\u2011to\u2011run template that can be customised to the specific spectral bands and disease taxonomy of any agricultural monitoring programme.<\/p>\n Activity: Quiz on CNN Implementation for Crop Health Monitoring<\/span><\/p>\n In this section we walk through a practical application of the convolutional neural network (CNN) you trained earlier. The goal is to use the model to classify images captured by a Unmanned Aerial Vehicle (UAV) over a wheat field, identifying areas affected by wheat rust. We will examine the preprocessing pipeline, inference step, and post\u2011processing of the model outputs, and discuss how to interpret the results in an agronomic context.<\/p>\n The UAV imagery was collected on a 50 ha wheat field using a multispectral camera. Each flight produced a set of orthophotos in the Red, Green, Blue (RGB) and Near\u2011Infrared (NIR) bands, at a ground sampling distance of 5 cm\/pixel. For the purpose of this exercise, we focus on the RGB composites, which are sufficient to detect the characteristic yellow\u2011brown pustules of wheat rust.<\/p>\n Images were tiled into 256\u00d7256 pixel crops, with a 50\u202f% overlap to maximise the number of training samples. A field\u2011operator annotated a subset of these tiles, marking each as rust<\/em> or healthy<\/em>. The resulting dataset contains 10\u202f000 rust tiles and 12\u202f000 healthy tiles, split into training (70\u202f%), validation (15\u202f%) and test (15\u202f%) sets.<\/p>\n Before feeding the tiles to the model, we perform a series of standardised steps to normalise the data and augment the training set. The following code demonstrates the preprocessing for a single tile, using the torchvision library.<\/p>\n import torchfrom torchvision import transformsfrom PIL import Imageimport numpy as np<\/p>\n preprocess = transforms.Compose([ transforms.Resize((224, 224)), # Rescale to the model input size transforms.ToTensor(), # Convert PIL image to torch tensor transforms.Normalize( # Normalise per channel mean=[0.485, 0.456, 0.406], # ImageNet means std=[0.229, 0.224, 0.225] # ImageNet stds )])def load_and_preprocess(image_path): “Load an image from disk and apply the preprocessing pipeline.” img = Image.open(image_path).convert(‘RGB’) # Ensure 3\u2011channel RGB img_tensor = preprocess(img) # Apply transforms img_tensor = img_tensor.unsqueeze(0) # Add batch dimension return img_tensor<\/p>\n Line by line explanation:<\/strong><\/p>\n Once the data is pre\u2011processed, we can perform inference with the trained CNN. Below is a compact script that loads a batch of tiles, runs the model, and writes out a probability map.<\/p>\n import torchfrom torch.utils.data import DataLoader, Datasetclass UAVTileDataset(Dataset): def __init__(self, file_list, transform=None): self.file_list = file_list self.transform = transform def __len__(self): return len(self.file_list) def __getitem__(self, idx): img = Image.open(self.file_list[idx]).convert(‘RGB’) if self.transform: img = self.transform(img) return img, self.file_list[idx] # return path for later<\/p>\n dataset = UAVTileDataset(test_files, transform=preprocess)loader = DataLoader(dataset, batch_size=32, shuffle=False)model = torch.load(‘wheat_rust_cnn.pt’) # Load the trained modelmodel.eval() # Set to evaluation modeprobabilities = []with torch.no_grad(): for imgs, paths in loader: preds = model(imgs) # Forward pass probs = torch.softmax(preds, dim=1) # Convert logits to class probabilities rust_probs = probs[:, 1] # Probability of rust class probabilities.extend(zip(paths, rust_probs.cpu().numpy()))<\/p>\n probabilities.sort(key=lambda x: x[1], reverse=True)for path, prob in probabilities[:10]: print(f”{path}: {prob:.3f}”)<\/p>\n Key points:<\/p>\n The raw probability scores need to be translated into a binary map for agronomic decision\u2011making. A common approach is to apply a threshold, for example 0.5, to decide whether a tile is rust\u2011positive. However, in precision agriculture it is often desirable to minimise false positives to avoid unnecessary fungicide application.<\/p>\n We can compute the Receiver Operating Characteristic (ROC) curve on the validation set and select a threshold that balances sensitivity and specificity. Suppose we choose a threshold of 0.7 after inspecting the ROC. The following code snippet applies this threshold and generates a GeoTIFF mask.<\/p>\n import rasteriofrom rasterio.transform import from_origin<\/p>\n mask = np.zeros((field_height, field_width), dtype=np.uint8)for (row, col), prob in probabilities: if prob >= 0.7: # Mark the corresponding region as rust (value 1) mask[row256:row<\/em>256+256, col256:col<\/em>256+256] = 1<\/p>\n transform = from_origin(minx, maxy, 0.05, 0.05) # 5 cm pixel sizewith rasterio.open(‘rust_mask.tif’, ‘w’, driver=’GTiff’, height=mask.shape[0], width=mask.shape[1], count=1, dtype=rasterio.uint8, crs=’EPSG:32633′, transform=transform) as dst: dst.write(mask, 1)<\/p>\n Explanation:<\/p>\n Once the mask is generated, it can be overlaid on the orthophoto mosaic to visualise rust hotspots. Agronomists can then prioritise these areas for fungicide spraying or further field inspection.<\/p>\n These figures suggest that the model performs well, but field validation is essential. For instance, a few false positives may appear in areas with similar colouration due to soil moisture or shading. A ground truth survey can confirm the model\u2019s predictions and refine the threshold if necessary.<\/p>\n While the CNN demonstrates strong performance on the test set, several practical constraints should be acknowledged:<\/p>\n To mitigate these issues, consider the following enhancements:<\/p>\n By iteratively refining the model and integrating field feedback, the UAV\u2011based rust detection pipeline can become a reliable decision support tool for wheat growers, reducing unnecessary chemical use and improving crop health monitoring.<\/p>\n Below is a lightweight TensorFlow\/Keras script that performs inference on the same UAV tiles, illustrating a different deep learning framework. The example demonstrates loading a saved model, preprocessing with Keras utilities, and generating probability maps.<\/p>\n import tensorflow as tfimport numpy as npfrom tensorflow.keras.preprocessing import imagefrom tensorflow.keras.applications.resnet50 import preprocess_input, decode_predictions<\/p>\n model = tf.keras.models.load_model(‘wheat_rust_tf.h5’)model.trainable = Falsedef load_and_preprocess_tf(img_path): img = image.load_img(img_path, target_size=(224, 224)) img_array = image.img_to_array(img) # (224,224,3) img_array = np.expand_dims(img_array, axis=0) # (1,224,224,3) img_array = preprocess_input(img_array) # Keras ResNet preprocessing return img_array<\/p>\n img_tensor = load_and_preprocess_tf(’tile_001.png’)preds = model.predict(img_tensor) # logitsprobs = tf.nn.softmax(preds, axis=1).numpy()rust_prob = probs[0, 1] # probability of rust classprint(f”Rust probability: {rust_prob:.3f}”)<\/p>\n Activity: Deciding on a UAV Flight Plan for Wheat Rust Detection<\/span><\/p>\n Imagine you are a remote sensing specialist tasked with designing a UAV mission to detect wheat rust across a 50\u2011hectare field. Using the concepts you just studied, outline the key steps you would take: selecting the appropriate sensor, determining the flight altitude and overlap, and planning the post\u2011processing workflow to highlight rust\u2011affected areas. Consider the trade\u2011offs between resolution, coverage, and data volume in your response.<\/p>\n When an AI model is trained under controlled laboratory or cloud\u2011based conditions, it often performs admirably on the same dataset. However, the real world is far messier. Deploying an AI solution for crop monitoring across a diverse set of farms, sensor platforms, and weather regimes exposes a range of pitfalls that can erode performance, increase operational cost, and erode stakeholder confidence. The most frequently encountered issues are data drift, sensor noise, and scalability constraints. Below we analyse each challenge, illustrate its impact, and present pragmatic counter\u2011measures that are implementable within a typical remote\u2011sensing workflow.<\/p>\n Data drift refers to the gradual or sudden change in the statistical properties of the input data that a model receives after deployment. In precision agriculture, this can arise from seasonal shifts, new cultivars, soil amendments, or even changes in the imaging hardware itself. A model trained on summer 2022 imagery may misclassify a late\u2011spring field in 2024 because the spectral signature of early\u2011season crops has evolved.<\/p>\n Without mitigation, drift can cause a steady decline in model precision, leading to costly misallocation of resources such as irrigation or pesticide application.<\/p>\n Practical solutions:<\/p>\n Remote\u2011sensing data is acquired from a variety of platforms \u2013 satellite constellations, UAVs, ground\u2011based sensors \u2013 each with inherent noise characteristics. Factors such as temperature fluctuations, lens contamination, or battery voltage variations can introduce bias or random errors.<\/p>\n Typical manifestations include:<\/p>\n These artefacts can mislead an AI model into learning spurious correlations. Robust preprocessing and noise\u2011aware training are therefore essential.<\/p>\n Practical solutions:<\/p>\n Many AI prototypes are built on a handful of images or a single UAV flight. Scaling to thousands of hectares across multiple farms introduces computational, logistical, and organisational hurdles:<\/p>\n Addressing scalability requires a combination of architectural optimisation and resource planning.<\/p>\n Practical solutions:<\/p>\n The following code demonstrates a minimalistic pipeline that could run nightly on a cloud instance. It ingests new imagery, computes drift statistics, and, if drift exceeds a threshold, retrains the model using the newly labelled data.<\/p>\n import numpy as npimport pandas as pdfrom sklearn.metrics import mean_absolute_errorfrom joblib import load, dumpimport globimport os<\/p>\n RAW_DATA_DIR = “\/data\/raw\/”MODEL_DIR = “\/models\/”DRIFT_THRESHOLD = 0.05 # acceptable MAE increasedef load_latest_images(): “”Load the most recent image set and associated labels.”” files = sorted(glob.glob(os.path.join(RAW_DATA_DIR, “*.npz”)), reverse=True) latest_file = files[0] data = np.load(latest_file) return data[“features”], data[“labels”]def compute_mae(pred, true): “”Return mean absolute error between predictions and ground truth.”” return mean_absolute_error(true, pred)def main(): # Load current model model = load(os.path.join(MODEL_DIR, “crop_classifier.joblib”)) # Load new data X_new, y_new = load_latest_images() # Predict with current model preds = model.predict(X_new) # Compute drift metric mae = compute_mae(preds, y_new) # Compare against baseline baseline_mae = np.load(os.path.join(MODEL_DIR, “baseline_mae.npy”)) if mae – baseline_mae > DRIFT_THRESHOLD: print(f”Drift detected: MAE increased by {mae – baseline_mae:.3f}”) # Retrain model on combined dataset X_combined = np.vstack([model.X_train_, X_new]) y_combined = np.concatenate([model.y_train_, y_new]) model.fit(X_combined, y_combined) # Save updated model and new baseline dump(model, os.path.join(MODEL_DIR, “crop_classifier.joblib”)) np.save(os.path.join(MODEL_DIR, “baseline_mae.npy”), mae) else: print(“No significant drift detected.”)if __name__ == “__main__”: main()<\/p>\n Line\u2011by\u2011line explanation<\/strong>:<\/p>\n Even the most robust technical safeguards cannot replace human expertise entirely. Farmers, agronomists, and remote\u2011sensing specialists should be integrated into the deployment lifecycle:<\/p>\n By combining automated drift detection, noise\u2011aware preprocessing, scalable inference, and human oversight, a deployment can maintain high fidelity over time, ensuring that AI truly supports precision crop monitoring rather than becoming a source of frustration.<\/p>\n Below is a lightweight script that polls a SageMaker hosted endpoint, records latency and error rates, and triggers a CloudWatch alarm if performance degrades.<\/p>\n import boto3import timeimport jsonENDPOINT_NAME = “crop-detection-endpoint”REGION = “eu-west-2″SAGEMAKER_CLIENT = boto3.client(“sagemaker-runtime”, region_name=REGION)CLOUDWATCH_CLIENT = boto3.client(“cloudwatch”, region_name=REGION)def invoke_endpoint(payload): response = SAGEMAKER_CLIENT.invoke_endpoint( EndpointName=ENDPOINT_NAME, ContentType=”application\/json”, Body=json.dumps(payload) ) return response[‘Body’].read()def monitor(): start = time.time() try: _ = invoke_endpoint({“features”: [0.1, 0.2, 0.3]}) latency = time.time() – start status = “OK” except Exception: latency = None status = “ERROR” CLOUDWATCH_CLIENT.put_metric_data( Namespace=”CropMonitoring”, MetricData=[ {“MetricName”:”Latency”,”Value”:latency or 0,”Unit”:”Milliseconds”}, {“MetricName”:”Status”,”Value”:0 if status==”OK” else 1,”Unit”:”Count”} ] )if __name__ == “__main__”: while True: monitor() time.sleep(60) # poll every minute<\/p>\n Activity: Discuss the Key Pitfalls of Deploying AI in the Field<\/span><\/p>\n Reflect on the recent section covering the pitfalls of deploying AI for crop monitoring. Identify at least three common challenges (e.g., data quality, model generalisation, and operational constraints) and discuss how they might impact real-world outcomes. Consider potential mitigation strategies and share examples or experiences from your own projects.<\/p>\n [tcb-script src=”https:\/\/cdn.jsdelivr.net\/npm\/mermaid@10\/dist\/mermaid.min.js”][\/tcb-script][tcb-script](function() { try { if (window.mermaid) { window.mermaid.initialize({ startOnLoad: true, theme: ‘default’ }); } } catch(e){} var supported = !!window.HTMLDetailsElement; if (!supported) { document.querySelectorAll(‘.moodlecraft-lesson details’).forEach(function(d) { var s = d.querySelector(‘summary’); if (!s) return; var kids = Array.from(d.children).filter(function(c){return c!==s;}); kids.forEach(function(el){el.style.display=’none’;}); s.addEventListener(‘click’, function(e){ e.preventDefault(); var open = d.hasAttribute(‘open’); kids.forEach(function(el){el.style.display = open?’none’:’block’;}); if(open){d.removeAttribute(‘open’);} else {d.setAttribute(‘open’,”);} }); }); }})();[\/tcb-script]<\/p>\n","protected":false},"template":"","class_list":["post-105878","tva_lesson","type-tva_lesson","status-publish","hentry","tva_courses-ai-for-crop-disease-detection-using-hyperspectral-imaging","post-wrapper","thrv_wrapper"],"acf":[],"_links":{"self":[{"href":"https:\/\/staging.nanoschool.in\/wp\/wp-json\/wp\/v2\/tva_lesson\/105878","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/staging.nanoschool.in\/wp\/wp-json\/wp\/v2\/tva_lesson"}],"about":[{"href":"https:\/\/staging.nanoschool.in\/wp\/wp-json\/wp\/v2\/types\/tva_lesson"}],"wp:attachment":[{"href":"https:\/\/staging.nanoschool.in\/wp\/wp-json\/wp\/v2\/media?parent=105878"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n
\n\n
\n Remote Sensing<\/th>\n Acquisition of data about the earth’s surface without physical contact, typically via satellite or airborne sensors.<\/td>\n<\/tr>\n \n NDVI<\/th>\n Normalised Difference Vegetation Index, a spectral indicator of plant health derived from near\u2011infrared and red reflectance.<\/td>\n<\/tr>\n \n Convolutional Neural Network (CNN)<\/th>\n A deep learning architecture specialised for processing grid\u2011like data, such as images, by applying convolutional filters.<\/td>\n<\/tr>\n \n Ground Truth<\/th>\n Accurate, manually recorded labels or measurements used to validate and train AI models.<\/td>\n<\/tr>\n \n Model Drift<\/th>\n The phenomenon where an AI model’s predictive performance degrades over time due to changes in underlying data patterns.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Concept: Remote Sensing Fundamentals<\/h2>\n
1. The Electromagnetic Spectrum and Spectral Bands<\/h3>\n
\n
2. Sensor Platforms and Acquisition Modes<\/h3>\n
\n
3. Radiometric and Geometric Corrections<\/h3>\n
\n
4. Vegetation Indices and Their Interpretation<\/h3>\n
\n
5. Practical Example: Calculating NDVI from Sentinel\u20112 Data in Python<\/h3>\n
Load the NIR (Band 8) and Red (Band 4) files<\/h1>\n
Convert Digital Numbers to reflectance (scale factor 0.0001)<\/h1>\n
Avoid division by zero<\/h1>\n
Compute NDVI<\/h1>\n
Save NDVI to a new GeoTIFF<\/h1>\n
\n
\n
6. Temporal Analysis and Change Detection<\/h3>\n
\n
7. Integration with Ground Truth and Decision Support<\/h3>\n
\n
8. Limitations and Considerations<\/h3>\n
\n
9. Future Directions in AI\u2011Enhanced Remote Sensing<\/h3>\n
10. Additional Example: Calculating the Normalised Difference Water Index (NDWI)<\/h3>\n
Load NIR (Band 8) and SWIR (Band 11) from Sentinel\u20112<\/h1>\n
Avoid division by zero<\/h1>\n
Compute NDWI<\/h1>\n
Save NDWI<\/h1>\n
11. Comparison of Vegetation Indices<\/h3>\n
\n\n
\n Index<\/th>\n Formula<\/th>\n Primary Use<\/th>\n Key Band(s)<\/th>\n<\/tr>\n \n NDVI<\/td>\n (NIR \u2013 Red)\/(NIR + Red)<\/td>\n Vegetation greenness & biomass<\/td>\n NIR, Red<\/td>\n<\/tr>\n \n EVI<\/td>\n 2.5\u202f\u00d7\u202f(NIR \u2013 Red)\/(NIR + 6\u202f\u00d7\u202fRed \u2013 7.5\u202f\u00d7\u202fBlue + 1)<\/td>\n High canopy density, reduced atmospheric influence<\/td>\n NIR, Red, Blue<\/td>\n<\/tr>\n \n SAVI<\/td>\n (NIR \u2013 Red)\/(NIR + Red + L)\u202f\u00d7\u202f(1 + L)<\/td>\n Sparse vegetation, soil background reduction<\/td>\n NIR, Red<\/td>\n<\/tr>\n \n NDWI<\/td>\n (NIR \u2013 SWIR)\/(NIR + SWIR)<\/td>\n Water content, moisture stress<\/td>\n NIR, SWIR<\/td>\n<\/tr>\n \n NDRE<\/td>\n (NIR \u2013 Red Edge)\/(NIR + Red Edge)<\/td>\n Chlorophyll & stress detection<\/td>\n NIR, Red Edge<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Implementation\/Code: Building a CNN for Crop Health<\/h2>\n
1. Preparing the Dataset<\/h3>\n
Define directories<\/h1>\n
Normalisation and augmentation for training set<\/h1>\n
Flow from directory<\/h1>\n
\n
2. Building the CNN Architecture<\/h3>\n
\n
3. Compiling the Model<\/h3>\n
4. Training with Callbacks<\/h3>\n
\n
5. Evaluating Performance<\/h3>\n
Predict probabilities<\/h1>\n
True labels<\/h1>\n
Classification report<\/h1>\n
Confusion matrix<\/h1>\n
6. Practical Deployment Considerations<\/h3>\n
\n
7. Transfer Learning Alternative<\/h3>\n
8. Comparison of Approaches<\/h3>\n
\n\n
\n Criterion<\/th>\n Training From Scratch<\/th>\n Transfer Learning (MobileNetV2)<\/th>\n<\/tr>\n \n Training Time<\/td>\n Longer \u2013 all weights initialised randomly<\/td>\n Shorter \u2013 only head layers trained initially<\/td>\n<\/tr>\n \n Data Requirement<\/td>\n Large dataset needed to avoid overfitting<\/td>\n Effective with smaller datasets due to pre\u2011trained features<\/td>\n<\/tr>\n \n Model Size<\/td>\n Depends on architecture; can be lightweight<\/td>\n Base model adds ~4\u202fMB; can be pruned or quantised<\/td>\n<\/tr>\n \n Generalisation<\/td>\n Risk of overfitting without extensive augmentation<\/td>\n Pre\u2011trained on diverse imagery improves robustness<\/td>\n<\/tr>\n \n Fine\u2011tuning Flexibility<\/td>\n Full control over all layers<\/td>\n Can unfreeze layers progressively for domain adaptation<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n 9. Summary<\/h3>\n
\n
Fully connected layer
Convolutional layer
Pooling layer<\/li>\n
To increase the size of the dataset
To reduce the impact of varying illumination and sensor differences
To convert the images to grayscale<\/li>\n
ReLU
Sigmoid
Softmax<\/li>\n
Mean Absolute Error
Accuracy
R-squared<\/li>\n<\/ol>\nWorked Example: Detecting Wheat Rust from UAV Data<\/h2>\n
1. Dataset description<\/h3>\n
2. Pre\u2011processing pipeline<\/h3>\n
Define the transform pipeline<\/h1>\n
\n
\n
3. Inference on UAV tiles<\/h3>\n
Assume `test_files` is a list of file paths for the test set<\/h1>\n
Sort tiles by rust probability and output top 10<\/h1>\n
\n
4. Post\u2011processing and mapping<\/h3>\n
Assume `tile_coords` is a list of (row, col) indices corresponding to each tile<\/h1>\n
Save mask as GeoTIFF<\/h1>\n
\n
5. Interpreting the results<\/h3>\n
\n\n
\n \nMetric<\/th>\n Value<\/th>\n Interpretation<\/th>\n<\/tr>\n<\/thead>\n \n Accuracy<\/td>\n 92\u202f%<\/td>\n Overall correct classification rate.<\/td>\n<\/tr>\n \n Sensitivity (Recall)<\/td>\n 88\u202f%<\/td>\n Proportion of actual rust tiles correctly identified.<\/td>\n<\/tr>\n \n Specificity<\/td>\n 95\u202f%<\/td>\n Proportion of healthy tiles correctly identified.<\/td>\n<\/tr>\n \n Positive Predictive Value<\/td>\n 85\u202f%<\/td>\n Likelihood that a tile flagged as rust truly contains rust.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n 6. Limitations and future improvements<\/h3>\n
\n
\n
Additional Example: TensorFlow Inference Pipeline<\/h3>\n
Load the trained ResNet\u201150 model (weights saved in HDF5)<\/h1>\n
Example inference on a single tile<\/h1>\n
Comparing PyTorch vs TensorFlow Inference Approaches<\/h3>\n
\n\n
\n \nAspect<\/th>\n PyTorch<\/th>\n TensorFlow (Keras)<\/th>\n<\/tr>\n<\/thead>\n \n Model Loading<\/td>\n torch.load(‘model.pt’)<\/td>\n tf.keras.models.load_model(‘model.h5’)<\/td>\n<\/tr>\n \n Preprocessing Library<\/td>\n torchvision.transforms<\/td>\n keras.preprocessing.image + keras.applications functions<\/td>\n<\/tr>\n \n Batching Utility<\/td>\n torch.utils.data.DataLoader<\/td>\n tf.data.Dataset<\/td>\n<\/tr>\n \n Inference Mode<\/td>\n model.eval() + torch.no_grad()<\/td>\n model.predict() (no gradients by default)<\/td>\n<\/tr>\n \n Softmax Handling<\/td>\n torch.softmax(logits, dim=1)<\/td>\n tf.nn.softmax(preds, axis=1)<\/td>\n<\/tr>\n \n GPU Support<\/td>\n Implicit with torch tensors on CUDA device<\/td>\n Explicit with tf.device or automatic placement<\/td>\n<\/tr>\n \n Code Verbosity<\/td>\n Lower\u2011level, more flexible<\/td>\n Higher\u2011level, more concise<\/td>\n<\/tr>\n \n Deployment<\/td>\n TorchScript or ONNX export<\/td>\n TFLite or SavedModel export<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Pitfalls: Deploying AI in the Field<\/h2>\n
1. Data Drift: The Silent Erosion of Accuracy<\/h3>\n
\n
\n
2. Sensor Noise and Calibration Errors<\/h3>\n
\n
\n
3. Scalability: From a Prototype to a Farm\u2011Wide Solution<\/h3>\n
\n
\n
4. Implementation Example: Drift\u2011Aware Retraining Pipeline<\/h3>\n
Paths to the directories<\/h1>\n
\n
5. Human\u2011In\u2011the\u2011Loop: Bridging the Gap<\/h3>\n
\n
Additional Example: Endpoint Monitoring with Amazon SageMaker<\/h3>\n
\n\n
\n \nApproach<\/th>\n When to Use<\/th>\n Pros<\/th>\n Cons<\/th>\n<\/tr>\n<\/thead>\n \n Continuous monitoring & alerting<\/td>\n All deployments; real\u2011time drift detection<\/td>\n Immediate insight, low overhead<\/td>\n Requires well\u2011defined metrics<\/td>\n<\/tr>\n \n Incremental learning pipelines<\/td>\n Large, slowly evolving datasets<\/td>\n Reduces retraining cost, adapts to new data<\/td>\n Risk of catastrophic forgetting<\/td>\n<\/tr>\n \n Ensemble of temporal models<\/td>\n Distinct phenological stages<\/td>\n Handles season\u2011specific patterns<\/td>\n Model maintenance overhead<\/td>\n<\/tr>\n \n Model compression<\/td>\n Edge inference constraints<\/td>\n Reduces latency & storage<\/td>\n Potential accuracy drop<\/td>\n<\/tr>\n \n Distributed inference<\/td>\n High\u2011volume, low\u2011latency workloads<\/td>\n Scalable, fault\u2011tolerant<\/td>\n Operational complexity<\/td>\n<\/tr>\n \n Endpoint monitoring (SageMaker)<\/td>\n Cloud\u2011hosted inference services<\/td>\n Automated health checks, CloudWatch integration<\/td>\n Vendor lock\u2011in, cost of monitoring<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Key Takeaways<\/h3>\n
\n
Further Reading<\/h3>\n
\n