AI in Precision Agriculture with Satellite Imagery

Agriculture feeds eight billion people. It also consumes 70% of global freshwater, accounts for roughly 25% of greenhouse gas emissions, and remains highly vulnerable to climate variability. The pressure to produce more food with less land, water, and chemical input has made farming one of the most data-hungry industries on the planet.

Artificial intelligence combined with satellite remote sensing is enabling a new era of precision agriculture — managing crops at field or even sub-field resolution, applying exactly the right input (water, fertilizer, pesticide) to exactly the right place at exactly the right time. This post surveys how this is done, what technologies are involved, and where the field is heading.

The Satellite Data Revolution

Before AI can help, there must be data. The satellite revolution has democratized access to agricultural data in ways unimaginable a decade ago.

Key Satellite Data Sources

Sentinel-2 (ESA Copernicus Programme)

• 10m spatial resolution for visible/NIR bands
• Free and open access
• 5-day revisit time
• 13 spectral bands covering visible, NIR, and SWIR

Landsat 8/9 (USGS/NASA)

• 30m resolution
• Free and open
• 16-day revisit
• Key data source for long-term change detection going back to 1972

PlanetScope (Planet Labs)

• 3m resolution (commercial)
• Near-daily global coverage
• Critical for detecting rapid changes (disease outbreak, hail damage)

SAR (Synthetic Aperture Radar): Sentinel-1

• Cloud-penetrating radar backscatter
• Works in any weather, day or night
• Sensitive to soil moisture, crop structure, and biomass

The combination of frequent, high-resolution, multi-spectral imagery — much of it freely available — is the foundation of AI-driven precision agriculture.

Vegetation Indices: Translating Pixels to Crop Health

Raw satellite bands are transformed into vegetation indices that are more directly meaningful for agriculture:

NDVI (Normalized Difference Vegetation Index): $$\text{NDVI} = \frac{\rho_{NIR} - \rho_{Red}}{\rho_{NIR} + \rho_{Red}}$$

NDVI ranges from -1 to +1. Healthy vegetation absorbs red light (chlorophyll) and reflects NIR strongly. Bare soil, water, and stressed crops all have lower NDVI values. It is the most widely used index globally.

EVI (Enhanced Vegetation Index): $$\text{EVI} = 2.5 \times \frac{\rho_{NIR} - \rho_{Red}}{\rho_{NIR} + 6\rho_{Red} - 7.5\rho_{Blue} + 1}$$

EVI reduces atmospheric and soil background noise, performing better in dense canopy and high-biomass conditions where NDVI saturates.

NDWI (Normalized Difference Water Index): $$\text{NDWI} = \frac{\rho_{Green} - \rho_{NIR}}{\rho_{Green} + \rho_{NIR}}$$

Sensitive to water content in vegetation canopy — useful for irrigation stress monitoring.

SAVI (Soil-Adjusted Vegetation Index): Adds a soil brightness correction factor, important for sparse vegetation in arid regions.

Crop Type Mapping

Before analyzing crop health, you need to know what crop is growing where. Crop type classification is a fundamental remote sensing problem.

Time Series Classification

The key insight: different crops have distinct phenological signatures — unique temporal patterns of NDVI and other indices as they grow, mature, and are harvested. Corn looks different from soybeans looks different from winter wheat — not necessarily on any single date, but across the growing season.

import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader

class CropTimeSeriesDataset(Dataset):
    """
    Dataset of pixel-level time series from satellite imagery.
    Each sample is a temporal sequence of spectral bands for one pixel.
    """
    def __init__(self, time_series: np.ndarray, labels: np.ndarray):
        # time_series: (N_pixels, T_timesteps, B_bands)
        # labels: (N_pixels,) crop type classes
        self.X = torch.FloatTensor(time_series)
        self.y = torch.LongTensor(labels)
    
    def __len__(self):
        return len(self.y)
    
    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]


class TemporalConvClassifier(nn.Module):
    """
    1D temporal convolution for crop type classification.
    Operates on (batch, time, bands) → class logits.
    """
    def __init__(self, n_bands: int, n_classes: int, n_filters: int = 64):
        super().__init__()
        
        self.temporal_conv = nn.Sequential(
            # Temporal convolution: captures seasonal patterns
            nn.Conv1d(n_bands, n_filters, kernel_size=5, padding=2),
            nn.BatchNorm1d(n_filters),
            nn.ReLU(),
            nn.Conv1d(n_filters, n_filters * 2, kernel_size=5, padding=2),
            nn.BatchNorm1d(n_filters * 2),
            nn.ReLU(),
            nn.AdaptiveAvgPool1d(1),  # Global temporal pooling
        )
        
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(n_filters * 2, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, n_classes),
        )
    
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: (batch, time, bands) → (batch, bands, time) for Conv1d
        x = x.permute(0, 2, 1)
        features = self.temporal_conv(x)
        return self.classifier(features)

Transformer-based approaches (TSViT, SITS-BERT) have become state-of-the-art for satellite time series classification by capturing long-range temporal dependencies more effectively than convolutions.

Handling Cloud Cover

A critical challenge: clouds obscure optical imagery. Solutions include:

• Gap-filling: Interpolate missing values using temporal smoothing (Savitzky-Golay filter, harmonic analysis)
• SAR fusion: Sentinel-1 radar imagery penetrates clouds and can substitute for optical data during cloudy periods
• Cloud-robust models: Train models specifically on incomplete time series with missing timestamps

Crop Yield Prediction

Predicting yield before harvest — with weeks to months lead time — has enormous economic value for farmers, insurers, commodity traders, and food security planners.

Deep Learning Yield Models

Modern yield prediction models ingest time series of satellite indices, weather data, and soil properties:

import torch
import torch.nn as nn

class MultiModalYieldPredictor(nn.Module):
    """
    Combines satellite time series with weather and soil data
    to predict crop yield at field level.
    """
    def __init__(
        self,
        satellite_bands: int = 10,
        weather_features: int = 8,
        soil_features: int = 12,
        hidden_dim: int = 128,
    ):
        super().__init__()
        
        # Satellite time series encoder (LSTM)
        self.satellite_encoder = nn.LSTM(
            input_size=satellite_bands,
            hidden_size=hidden_dim,
            num_layers=2,
            batch_first=True,
            dropout=0.3,
        )
        
        # Weather time series encoder
        self.weather_encoder = nn.LSTM(
            input_size=weather_features,
            hidden_size=hidden_dim // 2,
            num_layers=1,
            batch_first=True,
        )
        
        # Static soil feature encoder
        self.soil_encoder = nn.Sequential(
            nn.Linear(soil_features, 64),
            nn.ReLU(),
            nn.Linear(64, hidden_dim // 4),
        )
        
        # Fusion and prediction head
        fusion_dim = hidden_dim + hidden_dim // 2 + hidden_dim // 4
        self.yield_head = nn.Sequential(
            nn.Linear(fusion_dim, 256),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(256, 1),  # Single yield value (e.g., tons/hectare)
        )
    
    def forward(
        self,
        satellite_ts: torch.Tensor,   # (batch, time, bands)
        weather_ts: torch.Tensor,      # (batch, time, weather_features)
        soil_static: torch.Tensor,     # (batch, soil_features)
    ) -> torch.Tensor:
        
        # Encode time series — use final hidden state
        _, (sat_h, _) = self.satellite_encoder(satellite_ts)
        sat_features = sat_h[-1]  # Last layer hidden state
        
        _, (wx_h, _) = self.weather_encoder(weather_ts)
        wx_features = wx_h[-1]
        
        soil_features = self.soil_encoder(soil_static)
        
        # Fuse modalities
        fused = torch.cat([sat_features, wx_features, soil_features], dim=-1)
        
        return self.yield_head(fused)

State-of-the-art approaches use attention mechanisms to weight the contribution of different time steps — the model learns that certain growth stages (e.g., silking in corn, grain fill in wheat) are more predictive of final yield than others.

Transfer Learning Across Geographies

A maize yield model trained in the US Corn Belt may perform poorly in sub-Saharan Africa due to different cultivars, climate, and farming practices. Transfer learning and domain adaptation techniques address this:

• Pre-train on data-rich regions (US, EU), fine-tune on data-sparse regions
• Use satellite indices as a universal feature space that partially bridges geographic differences
• Meta-learning (MAML) to enable fast adaptation to new geographies with few samples

Disease and Pest Detection

Early detection of crop disease can prevent catastrophic losses. AI on satellite imagery enables surveillance at continental scale — something impossible with field scouts.

Rust Detection in Wheat

Wheat rust (stem rust, leaf rust, yellow rust) spreads rapidly and has historically caused famine-scale crop losses. Infected wheat shows characteristic changes in NIR reflectance and canopy temperature.

Key signatures detectable from satellite:

• Reduced NDVI in infected patches (yellowing)
• Increased surface temperature (stressed transpiration)
• Changes in texture and spatial heterogeneity (spotty vs. uniform canopy)

Deep learning models (U-Net for spatial segmentation, LSTM for temporal progression) can detect infection weeks before visible symptoms become apparent to human observers.

Distinguishing Disease from Stress

A major challenge: nutrient deficiency, water stress, and disease can produce similar NDVI patterns. Multi-spectral analysis using SWIR bands (Sentinel-2 bands 11 and 12) helps discriminate:

Combining spectral signatures with spatial patterns (clustered disease spread vs. uniform stress) and temporal dynamics (rapid onset vs. gradual) allows more reliable discrimination.

Irrigation Management

Water is the most constrained agricultural input in many regions. AI-driven irrigation management reduces water use by 20–50% compared to schedule-based irrigation.

Evapotranspiration Estimation

Evapotranspiration (ET) is the combined water loss from soil evaporation and crop transpiration. Estimating ET from satellites enables field-by-field water balance calculations.

The SEBAL (Surface Energy Balance Algorithm for Land) and METRIC models estimate ET from the surface energy balance:

$$\lambda ET = R_n - G - H$$

Where $R_n$ is net radiation, $G$ is soil heat flux, $H$ is sensible heat flux, and $\lambda ET$ is latent heat flux (proportional to ET).

All terms can be estimated from satellite data (thermal infrared for surface temperature, shortwave reflectance for albedo, vegetation indices for canopy properties).

Deep learning ET models trained on eddy covariance tower measurements generalize better across diverse conditions than physics-based models.

Soil Moisture from SAR

Sentinel-1 C-band SAR backscatter is sensitive to surface soil moisture. The dielectric constant of soil changes dramatically with water content, affecting how much radar energy is reflected back to the sensor.

Machine learning models (random forests, deep learning) trained on SAR data + ancillary inputs (soil texture, slope, vegetation cover) can estimate volumetric soil moisture with 5–7% volumetric accuracy.

Field Boundary Delineation

Knowing where individual farm fields are is fundamental — it defines the unit for all analysis. Global field boundary data is sparse, and automated delineation from satellite imagery is an active research problem.

Instance segmentation models (Mask R-CNN, SAM2, custom U-Net variants with boundary detection heads) identify individual field parcels from high-resolution imagery.

Challenges include:

• Fragmentation: Smallholder agriculture in South Asia and Africa has millions of tiny fields (often <0.1 ha)
• Boundary ambiguity: Adjacent same-crop fields may have no visible boundary
• Temporal variability: Fallow fields look different from growing-season fields

A Full Precision Agriculture Pipeline

Putting it all together, a precision agriculture platform operates this pipeline:

1. Data Ingestion
   ├── Satellite imagery (Sentinel-2, Planet) → cloud-filtered, atmospherically corrected
   ├── Weather data (ERA5 reanalysis, weather stations)
   └── Soil data (SoilGrids, local surveys)

2. Preprocessing
   ├── Field boundary detection (segmentation model)
   ├── Cloud masking (ML cloud detector)
   ├── Gap-filling (temporal interpolation)
   └── Spectral index computation (NDVI, EVI, NDWI, etc.)

3. Analysis Models
   ├── Crop type classification (time series classifier)
   ├── Crop health monitoring (anomaly detection vs. historical baseline)
   ├── Yield forecasting (multi-modal regression)
   └── Irrigation demand (ET estimation + soil moisture)

4. Advisory Generation
   ├── Field-level reports with spatial maps
   ├── Prescriptions (variable-rate irrigation/fertilizer maps)
   └── Alerts (disease risk, drought stress, frost)

5. Feedback Loop
   └── Harvest yield measurements → model retraining

Real-World Platforms

Several companies and research initiatives have built production systems:

The Climate Corporation (Bayer): FieldView platform uses satellite imagery and weather modeling for crop planning and yield forecasting across millions of US acres.

NASA Harvest: Freely available global crop monitoring and food security analysis using Landsat and MODIS, producing global crop area and yield estimates.

CGIAR Big Data Platform: Research-grade tools for food security monitoring, focusing on smallholder agriculture in the Global South.

aWhere, Descartes Labs: Commercial platforms providing satellite analytics APIs for agricultural decision-making.

FAO CropMonitor: Operational global crop monitoring system informing food security decisions.

Challenges and Limitations

Small farm accuracy: Most models are validated on large, uniform fields in North America and Europe. Performance degrades significantly on fragmented smallholder landscapes, which cover most agricultural land in Asia and Africa.

Label scarcity: Yield measurements from official statistics are available at county or national level, not field level. Crowdsourced yield surveys and crop cut experiments are expensive and sparse.

Model interpretability: Farmers and agronomists need to understand and trust model recommendations. Black-box predictions without clear explanatory factors are poorly adopted.

Connectivity barriers: Satellite imagery analysis requires internet and computing resources that are unavailable to many smallholder farmers who could benefit most.

Rare event detection: Disease outbreaks are rare in historical data, creating severe class imbalance problems for training reliable early-warning models.

The Opportunity Ahead

Global agriculture generates petabytes of satellite imagery every day, but most fields worldwide are still managed without data-driven decision support. The technical barriers — algorithmic, hardware, and connectivity — are falling rapidly.

AI on satellite imagery is already proving its value in commodity crop surveillance, food security monitoring, and carbon credit quantification for regenerative agriculture programs. The next decade will see these tools reach smallholder farmers through mobile platforms, bringing the precision agriculture revolution to the farms that feed most of the world’s population.