Kaggle Image2Biomass: Pasture Biomass Prediction

Build models that predict pasture biomass from images, ground-truth measurements, and publicly available datasets. Farmers will use these models to determine when and how to graze their livestock.

🏆 Competition Overview

The Image2Biomass competition challenges participants to develop machine learning models that can accurately predict pasture biomass from RGB images of Australian pastures. The goal is to help farmers optimize grazing times and methods by providing reliable biomass estimates.

Key Objectives

Predict five biomass components per pasture image:

• Dry_Green_g: Dry green vegetation biomass (grams)
• Dry_Dead_g: Dry dead material biomass (grams)
• Dry_Clover_g: Dry clover biomass (grams)
• GDM_g: Green dry matter (calculated as Dry_Green_g + Dry_Clover_g)
• Dry_Total_g: Total dry biomass (calculated as Dry_Green_g + Dry_Dead_g + Dry_Clover_g)

Evaluation Metric

Models are evaluated using a globally weighted coefficient of determination (R²) across all predictions:

R² = 1 - (SS_res / SS_tot)

Where:

• SS_res (Residual Sum of Squares) = Σ(w_j × (y_j - ŷ_j)²)
• SS_tot (Total Sum of Squares) = Σ(w_j × (y_j - ȳ_w)²)

Target Weights:

• Dry_Green_g: 0.1
• Dry_Dead_g: 0.1
• Dry_Clover_g: 0.1
• GDM_g: 0.2
• Dry_Total_g: 0.5 (most important!)

📊 Dataset

Training Data

• 357 unique pasture images (1,785 rows in CSV)
• Format: Long format with 5 rows per image (one per biomass target)
• Images: RGB JPEGs (2000×1000 pixels, resized to 1024×512 for training)
• Metadata: State, species, NDVI, average height
• Targets: Continuous values in grams (0.0 to 185.7g, mean ~24.8g)

Test Data

• ~800 images (hidden during development)
• Same format as training data but without target values
• Metadata available at test time

Data Structure

sample_id,image_path,Sampling_Date,State,Species,Pre_GSHH_NDVI,Height_Ave_cm,target_name,target
ID1011485656__Dry_Clover_g,train/ID1011485656.jpg,2015/9/4,Tas,Ryegrass_Clover,0.62,4.6667,Dry_Clover_g,0.0
ID1011485656__Dry_Dead_g,train/ID1011485656.jpg,2015/9/4,Tas,Ryegrass_Clover,0.62,4.6667,Dry_Dead_g,31.9984
...

🚀 Quick Start

1. Environment Setup

# Clone repository
git clone <repository-url>
cd kaggle-image2biomass

# Create virtual environment
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

2. Test Pipeline

python test_pipeline.py

3. Train Model

python train.py

4. Evaluate Model

python evaluate.py <experiment_name>

5. Create Submission

python create_submission.py models/<experiment_name>/model_best.pth

📁 Project Structure

kaggle-image2biomass/
├── config.py              # Hyperparameters and configuration
├── dataloader.py          # Data loading and preprocessing
├── model.py               # SimpleCNN model architecture
├── train.py               # Training loop with WandB logging
├── evaluate.py            # Model evaluation and metrics
├── create_submission.py   # Kaggle submission generation
├── test_pipeline.py       # Pipeline testing and validation
├── eda.ipynb             # Exploratory data analysis notebook
├── QUICK_REFERENCE.py     # Quick reference guide
├── requirements.txt       # Python dependencies
├── README.md             # This file
├── LICENSE               # GNU AGPL v3 License
├── diagrams/             # Architecture diagrams (SVG)
├── dataset/
│   ├── train.csv         # Training data (long format)
│   ├── test.csv          # Test data (long format)
│   ├── sample_submission.csv
│   ├── train/            # Training images
│   └── test/             # Test images
└── models/               # Saved model checkpoints (created during training)

🧠 Model Architecture

Architecture Diagrams

Standard vs Conditioned Architectures

Standard Architecture (Multi-Output): Predicts all 3 biomass targets simultaneously from a single forward pass.

Conditioned Architecture (Single-Output): Predicts one biomass target at a time, conditioned on which target to predict. Requires 3 forward passes per image (one per target).

Auxiliary Task Integration

Auxiliary Metadata Prediction: Optional additional prediction heads for metadata (species, state, NDVI, height) trained jointly with biomass targets.

Backbone Types

Feature Extractors: Choice between custom SimpleCNN or pretrained Timm models (ResNet, EfficientNet, etc.).

Standard Architectures

SimpleCNN

• 5 convolutional blocks: Conv2D → BatchNorm → ReLU → MaxPool
• Global Average Pooling
• Fully Connected layers: 256 → 128 → 3 outputs
• Total parameters: ~2.7M
• Input: 512×1024×3 RGB images
• Output: 3 biomass predictions (Dry_Green_g, Dry_Dead_g, Dry_Clover_g)

TimmModel

• Uses any pretrained backbone from the timm library (e.g., ResNet, EfficientNet)
• Custom regression head: Backbone features → 512 → 256 → 3 outputs
• Supports pretrained weights for transfer learning
• Optional backbone freezing for feature extraction only

Target-Conditioned Architectures (NEW!)

The target-conditioned architecture is a new approach where the model predicts one biomass component at a time, conditioned on which component it should predict.

ConditionedSimpleCNN

• Architecture: Same as SimpleCNN but with target conditioning
• Input:
  • RGB image (3 channels)
  • One-hot encoded target name (3-dimensional: Dry_Clover_g, Dry_Dead_g, Dry_Green_g)
• Output: Single biomass value (regression)
• Feature fusion: Target encoding is concatenated to conv features before FC layers

ConditionedTimmModel

• Architecture: Timm backbone + target conditioning
• Input: Same as ConditionedSimpleCNN
• Output: Single biomass value
• Feature fusion: Target encoding is concatenated to backbone features

How It Works

Training:

1. Dataset filters out Dry_Total_g and GDM_g rows (we don't predict these directly)
2. Each training sample is one image + one target type
3. Model receives image and one-hot encoding of which target to predict
4. Model outputs a single biomass value
5. Training loss is computed on this single value

Inference/Evaluation:

1. For each image, run the model 3 times:
   • Once with target_name = "Dry_Clover_g"
   • Once with target_name = "Dry_Dead_g"
   • Once with target_name = "Dry_Green_g"
2. Calculate derived targets:
   • GDM_g = Dry_Green_g + Dry_Clover_g
   • Dry_Total_g = Dry_Green_g + Dry_Dead_g + Dry_Clover_g

Benefits:

• ✅ Better performance: R² 0.45 vs 0.30 for standard models
• ✅ More training data: 3x more samples per image
• ✅ Specialization: Model focuses on one component at a time
• ✅ Correct derived targets: GDM and Dry_Total are exact sums
• ✅ Flexible inference: Can predict any subset of targets

Key Features (All Architectures)

• ReLU Activation on the final layers since the target values are positive
• Dropout regularization (0.3) prevents overfitting
• Batch normalization for stable training
• Auxiliary task support for metadata prediction (optional)
• Mixed precision training with FP16/BF16 for faster training
• Gradient accumulation for large effective batch sizes

Performance Benchmarks

Architecture	Validation R² (5 epochs)	Training Speed	Model Size
ConditionedTimmModel	0.45	~5.8s/epoch	30.9M params
TimmModel	~0.30	~5.5s/epoch	30.9M params
ConditionedSimpleCNN	~0.25	~6.2s/epoch	11.2M params

ConditionedTimmModel with regnety_064 backbone achieves the best performance on validation set.

🎯 Training

Hyperparameters

BATCH_SIZE = 8
NUM_EPOCHS = 200
LEARNING_RATE = 1e-4
WEIGHT_DECAY = 1e-5
EARLY_STOPPING_PATIENCE = 20

Data Augmentation

• Horizontal/vertical flips
• Random rotations (±15°)
• Brightness/contrast adjustments
• ImageNet normalization

Experiment Tracking

• Weights & Biases integration with live training dashboard
• Real-time monitoring at: wandb.ai/animikhaich/kaggle-image2biomass
• Automatic logging of metrics, losses, and hyperparameters
• Model checkpoints saved every 5 epochs
• Best model saved based on validation R²

Training Command

python train.py

📈 Evaluation

Metrics

• Weighted R² (competition metric)
• MAE (Mean Absolute Error)
• RMSE (Root Mean Squared Error)
• MAPE (Mean Absolute Percentage Error)
• Per-target metrics for all 5 biomass components

Evaluation Commands

# Evaluate on validation set
python evaluate.py <experiment_name> val

# Evaluate on training set (check overfitting)
python evaluate.py <experiment_name> train

📤 Submission

Generate Kaggle Submission

python create_submission.py models/<experiment_name>/model_best.pth submission.csv

Submission Format

sample_id,target
ID1001187975__Dry_Clover_g,0.0
ID1001187975__Dry_Dead_g,15.2
ID1001187975__Dry_Green_g,8.7
ID1001187975__Dry_Total_g,23.9
ID1001187975__GDM_g,8.7

🔧 Configuration

All hyperparameters are centralized in config.py:

• Data settings: Image dimensions, batch size, splits
• Model settings: Architecture parameters, output dimensions
• Training settings: Learning rate, epochs, early stopping
• Augmentation: Transformation parameters
• WandB settings: Project name, entity

Model Architecture Selection

# Standard architectures (predict all 3 targets at once)
USE_TARGET_CONDITIONING = False
ARCHITECTURE = "SimpleCNN"  # Simple custom CNN
# or
ARCHITECTURE = "TimmModel"  # Pretrained backbone
TIMM_BACKBONE = "resnet34.a1_in1k"

# Target-conditioned architectures (RECOMMENDED - best performance)
USE_TARGET_CONDITIONING = True
ARCHITECTURE = "ConditionedTimmModel"  # Pretrained backbone with target conditioning
TIMM_BACKBONE = "regnety_064"  # Best performing backbone
# or
ARCHITECTURE = "ConditionedSimpleCNN"  # Simple CNN with target conditioning

Using Target-Conditioned Models

To use the new target-conditioned architecture:

1. Update config.py:

   USE_TARGET_CONDITIONING = True
   ARCHITECTURE = "ConditionedSimpleCNN"  # or "ConditionedTimmModel"
   
   # If using ConditionedTimmModel, also specify the backbone:
   TIMM_BACKBONE = "regnety_064"  # or any other timm model

   Important: The ARCHITECTURE and USE_TARGET_CONDITIONING settings must match:

   • If USE_TARGET_CONDITIONING = True, use "ConditionedSimpleCNN" or "ConditionedTimmModel"
   • If USE_TARGET_CONDITIONING = False, use "SimpleCNN" or "TimmModel"

   The training script will raise an error if these settings don't match.

2. Train the model:

   python train.py

   • Training data will automatically filter out Dry_Total_g and GDM_g rows
   • Each sample will be (image, target_name, single_biomass_value)
   • Model will learn to predict the correct component based on target_name input

3. Evaluate the model:

   python evaluate.py <experiment_name>

   • Evaluation will automatically run 3x inference per image
   • Derived targets (GDM_g, Dry_Total_g) will be calculated from predictions

4. Create submission:

   python create_submission.py --checkpoint models/<experiment_name>/model_best.pth

   • Submission generation will automatically run 3x inference
   • All 5 targets will be calculated correctly

Note: The conditioned architecture is fully compatible with:

• All training configurations (learning rate, batch size, etc.)
• Cross-validation
• Auxiliary metadata prediction
• All available backbones (for ConditionedTimmModel)
• Mixed precision training

Key Parameters to Tune

• LEARNING_RATE: Most important hyperparameter (start with 1e-4)
• BATCH_SIZE: 8 for RTX 3090, adjust based on GPU memory
• ARCHITECTURE: ConditionedTimmModel with regnety_064 is recommended
• USE_METADATA_AUX: Set to True for small performance boost
• MIXED_PRECISION_TYPE: Use "fp16" for faster training (if GPU supports)

Recommended Configuration (Best Performance)

# Target-conditioned setup - best performance
USE_TARGET_CONDITIONING = True
ARCHITECTURE = "ConditionedTimmModel"
TIMM_BACKBONE = "regnety_064"
USE_METADATA_AUX = True
MIXED_PRECISION_TYPE = "fp16"
LEARNING_RATE = 1e-4
BATCH_SIZE = 8

Quick Start (Best Results)

# 1. Configure for target conditioning
# Edit config.py with the settings above

# 2. Train model
python train.py

# 3. Evaluate on validation set  
python evaluate.py <experiment_name> val

# 4. Generate submission
python create_submission.py models/<experiment_name>/model_best.pth

This configuration typically achieves R² ≈ 0.45 on validation after just 5 epochs.

📊 Exploratory Data Analysis

Run the EDA notebook to understand the data:

jupyter notebook eda.ipynb

Key insights:

• Biomass distributions by state and species
• Correlation between targets
• Image characteristics
• Metadata relationships

🛠️ Dependencies

pandas
numpy
matplotlib
seaborn
pillow
opencv-python
wandb
ipython
scikit-learn
torch>=2.0
torchvision
albumentations

🔄 Reproducibility

• Fixed random seed (42) for all operations
• Deterministic PyTorch operations
• Same train/validation split
• Version-controlled code and data

🚀 Advanced Usage

Model Architecture Comparison

Feature	Standard Models	Target-Conditioned Models
Training samples	1 per image (357 total)	3 per image (1,071 total)
Model inputs	Image only	Image + target_name encoding
Model outputs	3 values at once	1 value at a time
Inference	1 forward pass per image	3 forward passes per image
Derived targets	Calculated from 3 predictions	Calculated from 3 predictions
Training time	Faster (fewer forward passes)	Slower (more samples, but simpler task)
Use case	Standard multi-output regression	Specialized per-component prediction

Custom Model Architecture

Modify model.py to implement:

• Transfer learning (ResNet, EfficientNet)
• Attention mechanisms
• Multi-scale features
• Advanced pooling strategies

Hyperparameter Tuning

Use WandB sweeps for systematic tuning:

# Example sweep configuration
sweep_config = {
    'method': 'bayes',
    'metric': {'name': 'val/weighted_r2', 'goal': 'maximize'},
    'parameters': {
        'learning_rate': {'min': 1e-5, 'max': 1e-3},
        'batch_size': {'values': [4, 8, 16]},
        'dropout': {'min': 0.1, 'max': 0.5}
    }
}

Ensemble Methods

• Train multiple models with different seeds
• Average predictions for improved performance
• Use different architectures

🔀 Cross-Validation Usage Guide

This implementation provides K-fold cross-validation for robust model evaluation.

Quick Start

1. Enable cross-validation in config.py:

   USE_CROSS_VALIDATION = True
   N_FOLDS = 5  # Number of folds

2. Train all folds:

   python train.py

3. Train specific fold only:

   FOLD_TO_TRAIN = 2  # Train fold 2 (0-indexed)

   python train.py

Configuration

config.py parameters:

• USE_CROSS_VALIDATION: bool (default: False)
  Set to True to enable K-fold cross-validation

• N_FOLDS: int (default: 5)
  Number of folds for cross-validation

• FOLD_TO_TRAIN: int or None (default: None)

  • None: Train all folds sequentially
  • 0 to N_FOLDS-1: Train only specific fold

• CROSS_VAL_SEED: int (default: same as SEED)
  Random seed for reproducible fold splits

• SAVE_FOLD_MODELS: bool (default: True)
  Save best model for each fold in separate directories

Output Structure

When USE_CROSS_VALIDATION = True:

models/
  └── experiment-name/
      ├── fold_0/
      │   ├── model_best.pth
      │   └── model_epoch_*.pth
      ├── fold_1/
      │   ├── model_best.pth
      │   └── model_epoch_*.pth
      ...
      └── cv_results.json  # Summary of all folds

WandB Logging

Cross-validation metrics are logged with fold-specific prefixes:

• fold_0/train/loss
• fold_0/val/weighted_r2
• fold_1/train/loss
• fold_1/val/weighted_r2 ...

Summary metrics:

• cv/avg_r2: Average R² across all folds
• cv/std_r2: Standard deviation of R²
• cv/min_r2: Minimum R² across folds
• cv/max_r2: Maximum R² across folds

Best Practices

1. Use same seed (CROSS_VAL_SEED = SEED) for reproducibility

2. For final model selection:

   • Train all folds to get robust performance estimate
   • Use average metrics across folds
   • Select best fold's model or ensemble predictions

3. For faster experimentation:

   • Set FOLD_TO_TRAIN to specific fold
   • Useful for hyperparameter tuning

4. Recommended folds:

   • Small dataset (<500 samples): N_FOLDS = 5
   • Medium dataset (500-5000): N_FOLDS = 5-10
   • Large dataset (>5000): N_FOLDS = 3-5

Ensemble Predictions

To create ensemble predictions from all folds:

1. Train all folds (FOLD_TO_TRAIN = None)
2. Load each fold's best model
3. Average predictions across folds

Example:

import torch
from model import load_model

fold_models = []
for fold_idx in range(N_FOLDS):
    checkpoint = f"models/experiment/fold_{fold_idx}/model_best.pth"
    model, *_ = load_model(checkpoint, device)
    fold_models.append(model)

# Make predictions
predictions = []
for model in fold_models:
    pred = model(images)
    predictions.append(pred)

# Ensemble (average)
final_pred = torch.mean(torch.stack(predictions), dim=0)

Comparison with Single Split

Single Split (USE_CROSS_VALIDATION = False):

• Faster training (train once)
• May overfit to specific validation set
• Less reliable performance estimate

Cross-Validation (USE_CROSS_VALIDATION = True):

• More robust performance estimate
• Reduces validation set selection bias
• Longer training time (train N_FOLDS models)
• Better for model selection and hyperparameter tuning

🤝 Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit changes (git commit -m 'Add amazing feature')
4. Push to branch (git push origin feature/amazing-feature)
5. Open a Pull Request

📄 License

This project is licensed under the GNU Affero General Public License v3.0 - see the LICENSE file for details.

🙏 Acknowledgments

• Kaggle for hosting the competition
• Agriculture Victoria for providing the dataset
• PyTorch and Albumentations communities

📞 Support

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Competition Forum: Kaggle Discussion

---

Happy modeling! 🌾