def calculate_ndvi(nir_band, red_band):

"""

Calculate NDVI from satellite imagery.

NDVI = (NIR - Red) / (NIR + Red)

Healthy vegetation has high NIR reflectance and low red reflectance.

"""

ndvi = (nir_band - red_band) / (nir_band + red_band + 1e-10)

return ndvi

def classify_crop_health(ndvi_image, thresholds=None):

"""

Classify crop health based on NDVI values.

"""

if thresholds is None:

thresholds = {

'stressed': 0.2,

'moderate': 0.4,

'healthy': 0.6

}

health_map = np.zeros_like(ndvi_image, dtype=np.uint8)

health_map[ndvi_image < thresholds['stressed']] = 1 # Stressed

health_map[(ndvi_image >= thresholds['stressed']) &

(ndvi_image < thresholds['moderate'])] = 2 # Moderate

health_map[(ndvi_image >= thresholds['moderate']) &

(ndvi_image < thresholds['healthy'])] = 3 # Good

health_map[ndvi_image >= thresholds['healthy']] = 4 # Healthy

return health_map

Change detection: Comparing images over time reveals developing problems—drought stress, pest damage, disease spread.

Yield estimation: Historical imagery correlates with yield data, enabling in-season yield predictions.

Commercial platforms like Planet Labs, Descartes Labs, and Satelligence provide agricultural satellite analytics as services.

Drone-Based Imaging

Drones offer higher resolution and more flexible timing than satellites:

RGB imaging: Standard cameras capture visible details—plant counts, weed coverage, physical damage.

Multispectral cameras: Specialized sensors capture multiple spectral bands for health assessment.

Thermal imaging: Temperature variations indicate water stress and irrigation problems.

LiDAR: Light detection and ranging creates 3D models for plant height and biomass estimation.

class DroneImageryAnalyzer:

def __init__(self):

self.plant_detector = load_model('plant_detection_model.h5')

self.disease_classifier = load_model('disease_classifier.h5')

def analyze_field(self, imagery):

"""

Comprehensive field analysis from drone imagery.

"""

results = {}

# Plant counting and spacing

plant_positions = self.detect_plants(imagery['rgb'])

results['plant_count'] = len(plant_positions)

results['spacing_uniformity'] = self.calculate_uniformity(plant_positions)

# Health assessment from multispectral

ndvi = calculate_ndvi(imagery['nir'], imagery['red'])

results['average_ndvi'] = np.mean(ndvi)

results['stress_percentage'] = (ndvi < 0.3).mean() * 100

# Disease detection

disease_map = self.detect_diseases(imagery['rgb'])

results['disease_detections'] = disease_map

# Water stress from thermal

thermal = imagery['thermal']

results['water_stress_zones'] = self.identify_water_stress(thermal)

return results

Disease and Pest Detection

Computer vision identifies diseases and pests from imagery:

Image classification: Trained models recognize disease symptoms in plant images.

from tensorflow.keras.applications import EfficientNetV2S

from tensorflow.keras.layers import Dense, GlobalAveragePooling2D

from tensorflow.keras.models import Model

def create_disease_classifier(num_classes):

"""

Create a disease classification model using transfer learning.

"""

base_model = EfficientNetV2S(

weights='imagenet',

include_top=False,

input_shape=(224, 224, 3)

)

# Freeze base layers

base_model.trainable = False

x = base_model.output

x = GlobalAveragePooling2D()(x)

x = Dense(256, activation='relu')(x)

predictions = Dense(num_classes, activation='softmax')(x)

model = Model(inputs=base_model.input, outputs=predictions)

return model

# Training on plant disease dataset

model = create_disease_classifier(num_classes=38) # PlantVillage has 38 classes

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

Object detection: Locating individual pests or disease lesions enables targeted treatment.

Severity estimation: Beyond presence/absence, models can assess disease severity for treatment decisions.

Public datasets like PlantVillage and PlantDoc provide training data for disease recognition models.

Weed Detection and Mapping

AI distinguishes crops from weeds for targeted management:

Species identification: Recognizing specific weed species informs herbicide selection.

Density mapping: Quantifying weed pressure guides treatment intensity.

Resistance monitoring: Tracking weed populations over time detects developing herbicide resistance.

class WeedDetector:

def __init__(self, crop_type):

self.crop_type = crop_type

self.model = load_weed_detection_model(crop_type)

def detect_weeds(self, image):

"""

Detect and classify weeds in field imagery.

"""

# Run detection model

detections = self.model.predict(image)

weeds = []

for detection in detections:

if detection['class'] != self.crop_type:

weeds.append({

'position': detection['bbox'],

'species': detection['class'],

'confidence': detection['score']

})

return weeds

def create_spray_map(self, weeds, treatment_radius=0.5):

"""

Create targeted spray map from weed detections.

"""

spray_zones = []

for weed in weeds:

center = weed['position']

spray_zones.append({

'center': center,

'radius': treatment_radius,

'herbicide': self.recommend_herbicide(weed['species'])

})

return spray_zones

Precision Application Technologies

Knowing field conditions enables precision application of inputs—water, fertilizers, pesticides—applying the right amount in the right place.

Variable Rate Technology

Variable Rate Technology (VRT) adjusts application rates across a field based on prescription maps:

Fertilizer application: Apply more fertilizer where nutrients are depleted, less where levels are adequate.

Seeding: Adjust planting density based on productivity zones—more seeds in high-yield areas.

Pesticides: Target applications where pest pressure exists rather than blanket spraying.

def create_fertilizer_prescription(soil_samples, yield_map, crop_requirement):

"""

Create variable rate fertilizer prescription.

"""

prescription = {}

for zone in soil_samples['zones']:

# Current soil nutrient levels

current_n = zone['nitrogen_ppm']

current_p = zone['phosphorus_ppm']

current_k = zone['potassium_ppm']

# Expected yield for this zone

expected_yield = yield_map[zone['id']]

# Calculate required nutrients

n_required = crop_requirement['N_per_bushel'] * expected_yield

p_required = crop_requirement['P_per_bushel'] * expected_yield

k_required = crop_requirement['K_per_bushel'] * expected_yield

# Calculate fertilizer needed

prescription[zone['id']] = {

'N_lbs_per_acre': max(0, n_required - current_n * zone['mineralization_factor']),

'P_lbs_per_acre': max(0, p_required - current_p),

'K_lbs_per_acre': max(0, k_required - current_k)

}

return prescription

Smart Irrigation

AI optimizes irrigation timing and quantity:

Evapotranspiration modeling: Predict crop water use from weather data and growth stage.

Soil moisture monitoring: Sensors provide real-time soil water status.

Deficit irrigation: Strategic mild water stress improves quality for some crops.

class IrrigationScheduler:

def __init__(self, field_config, weather_api):

self.field = field_config

self.weather = weather_api

self.soil_moisture_sensors = field_config['sensors']

def calculate_irrigation_need(self):

"""

Determine irrigation need based on soil moisture and forecast.

"""

# Get current soil moisture

current_moisture = self.get_sensor_readings()

# Estimate upcoming water use

forecast = self.weather.get_forecast(days=7)

et_forecast = self.calculate_et(forecast)

# Calculate water balance

field_capacity = self.field['soil']['field_capacity']

wilting_point = self.field['soil']['wilting_point']

mad = 0.5 # Management allowed depletion

trigger_point = field_capacity - (field_capacity - wilting_point) * mad

# Check if irrigation needed

if current_moisture < trigger_point:

deficit = field_capacity - current_moisture

return {

'irrigate': True,

'amount_inches': deficit / self.field['soil']['water_holding_capacity'],

'urgency': 'high' if current_moisture < wilting_point else 'normal'

}

return {'irrigate': False}

Robotic Application

Autonomous robots apply treatments with centimeter precision:

Targeted spraying: Robots identify individual weeds and spray only those plants, reducing herbicide use by 90% or more.

Mechanical weeding: Robots remove weeds mechanically, eliminating herbicide use entirely.

Spot fertilization: Apply fertilizer to individual plants based on their specific needs.

Companies like Blue River Technology (John Deere), Ecorobotix, and Carbon Robotics are commercializing these systems.

Autonomous Farm Equipment

Full farm automation extends beyond individual tasks to comprehensive operation management.

Autonomous Tractors

Self-driving tractors operate without human operators:

GPS guidance: RTK GPS provides centimeter-level positioning for precise field operations.

Obstacle detection: Computer vision and LIDAR identify obstacles for safe operation.

Implement control: Autonomous systems manage implements for plowing, planting, spraying.

24/7 operation: Autonomous equipment can work through the night, expanding capacity during critical windows.

class AutonomousTractor:

def __init__(self, vehicle_config, field_boundary):

self.config = vehicle_config

self.boundary = field_boundary

self.perception = PerceptionSystem()

self.navigation = NavigationSystem(field_boundary)

def execute_field_operation(self, operation_type, prescription_map):

"""

Execute an autonomous field operation.

"""

# Generate coverage path

path = self.navigation.generate_coverage_path(

self.config['implement_width'],

operation_type

)

for waypoint in path:

# Navigate to waypoint

self.navigate_to(waypoint)

# Monitor for obstacles

obstacles = self.perception.detect_obstacles()

if obstacles:

self.handle_obstacles(obstacles)

# Apply prescription if applicable

if prescription_map:

zone = prescription_map.get_zone(waypoint)

self.adjust_application_rate(zone)

# Log operation data

self.log_operation(waypoint, self.get_sensor_readings())

Harvesting Robots

Robotic harvesting addresses labor challenges for hand-picked crops:

Strawberry harvesters: Vision systems identify ripe berries; gentle grippers pick without damage.

Apple harvesters: Vacuum-based picking at high speed.

Vegetable harvesters: Robotic systems for lettuce, broccoli, and other vegetables.

The challenge is achieving speed and gentleness comparable to human workers while operating economically.

Livestock Management

AI extends to animal agriculture:

Individual animal monitoring: Computer vision tracks each animal's behavior, health, and productivity.

Automated milking: Robotic milking systems manage dairy herds without human intervention.

Feed optimization: AI optimizes rations for individual animals based on production and health data.

Disease prediction: Behavioral changes detected by AI can indicate illness before visible symptoms.

Yield Prediction and Optimization

Predicting and maximizing yields are core agricultural challenges where AI excels.

Yield Prediction Models

Machine learning predicts yields from environmental and management data:

from sklearn.ensemble import RandomForestRegressor

import pandas as pd

def train_yield_model(historical_data):

"""

Train a yield prediction model.

"""

features = [

'precipitation_total',

'gdd_accumulated', # Growing degree days

'avg_temperature',

'soil_nitrogen',

'soil_organic_matter',

'ndvi_peak_season',

'planting_date_doy',

'seed_variety',

'fertilizer_applied'

]

X = historical_data[features]

y = historical_data['yield_bushels_per_acre']

model = RandomForestRegressor(

n_estimators=200,

max_depth=15,

random_state=42

)

model.fit(X, y)

# Feature importance for interpretation

importance = pd.Series(

model.feature_importances_,

index=features

).sort_values(ascending=False)

return model, importance