README.md

---
dataset_info:
  features:
  - name: image
    dtype: image
  - name: idx
    dtype: int64
  - name: label
    dtype: string
  - name: longitude
    dtype: float64
  - name: latitude
    dtype: float64
  - name: easting
    dtype: float64
  - name: northing
    dtype: float64
  - name: elevation
    dtype: float64
  - name: time
    dtype: int64
  - name: cluster
    dtype: int64
configs:
- config_name: labelled
  drop_labels: false
  data_files:
  - split: train
    path:
    - data/train/**/*.tif
    - data/train/metadata.csv
  - split: test
    path:
    - data/test/**/*.tif
    - data/test/metadata.csv
- config_name: unlabelled
  data_files:
  - split: train
    path:
    - "data/orthomosaic/*.tif"
---
<img src="https://huggingface.co/datasets/mpg-ranch/leafy_spurge/resolve/main/doc_figures/spurge_photo_2_panel.png" width="100%">

# Background

Leafy Spurge Dataset is a collection of top-down aerial images of grasslands in western Montana, USA. We surveyed a 150-hectare study area with a DJI Mavic 3M Drone from 50m above the ground surface and we assembled the images into a contiguous orthomosaic using Drone Deploy software. Many scenes in the study area contain a weed plant, leafy spurge (*Euphorbia esula*), which upsets the ecology of areas throughout North America. Botanists visited 1000 sites in the study area and gathered ground truth of leafy spurge presence/absence within 0.5 x 0.5 m plots. The position of these plots was referenced within the orthomosaic and these areas were cropped from the larger image. The resulting processed data are 1024 x 1024 pixel .tif files, though note the labelled areas correspond to the 39 x 39 pixel square (half-meter side length) found at the center of these crops. We include the context around the ground truth areas for experimental purposes. Our primary objective in serving these data is to invite the research community to develop classifiers that are effective early warning systems of spurge invasion at the highest spatial resolution possible. 

[Please refer to our data release paper on Arxiv for further details.](https://arxiv.org)

# Data loading and pre-processing

As a Hugging Face dataset, you may load the Leafy Spurge training set as follows:
```python 
from datasets import load_dataset

ds = load_dataset('mpg-ranch/leafy_spurge', 'labelled', split='train')
ds['image'][405]
```
<img src="https://huggingface.co/datasets/mpg-ranch/leafy_spurge/resolve/main/doc_figures/full_size_tile.png" width="1024px" height="1024px">

We will now center crop the image to the size of the ground truth:

```python
from torchvision.transforms import CenterCrop, Compose

ground_truth_sz = 39

ccrop = Compose([CenterCrop(ground_truth_sz)])

def preproc_transforms(examples):
    examples["pixel_values"] = [ccrop(image.convert("RGB")) for image in examples["image"]]
    return examples

ds = ds.map(preproc_transforms, batched=True)
ds['pixel_values'][405]
```
<img src="https://huggingface.co/datasets/mpg-ranch/leafy_spurge/resolve/main/doc_figures/ground_truth_tile.png" width="39px" height="39px">

# Geographic splits within the training set
<img src="https://huggingface.co/datasets/mpg-ranch/leafy_spurge/resolve/main/doc_figures/train_clusters.png" width="75%" height="75%">

We gathered ground truth at multiple sites and observations within a site were geographically clustered. We suggest using the cluster feature to establish holdout sets for cross-validated hyperparameter tuning. This will simluate model performance when classifying leafy spurge at new sites (such as those of the test set). You can filter by cluster metadata as follows:

```python
 #define holdout sets with ground truth clusters; 6 and 7 overlap geographically
holdout_sets = [[0], [1], [2], [4], [5], [6,7], [8]] 

set_0 = ds.filter(lambda example: example['cluster'] in holdout_sets[0])
unq_vals = list(set(set_0['cluster']))
print(f'Unique cluster values in set 0: {unq_vals}')
```

# Example cross-validation loop
We will use the the geographic cluster feature to cross-validate performance. First let's reformat the dataset for torch and define some functions for our training loop:

```python
import torch.nn as nn
import torch.optim as optim
from torchvision.models import resnet50
from tqdm import tqdm
import pandas as pd

ds = ds.with_format("torch")

def train_one_epoch(model, train_loader, criterion, optimizer, device):
    model.train()
    running_loss = 0.0
    correct_predictions = 0
    total_predictions = 0
    for i, batch in enumerate(train_loader):
        inputs = batch['pixel_values'].permute(0,3,1,2).float().to(device)
        labels = batch['label'].to(device)

        optimizer.zero_grad()

        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total_predictions += labels.size(0)
        correct_predictions += (predicted == labels).sum().item()

        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    train_accuracy = correct_predictions / total_predictions
    train_loss = running_loss / len(train_loader)

    return train_loss, train_accuracy

def evaluate_one_epoch(model, test_loader, criterion, device):
    model.eval()
    running_loss = 0.0
    correct_predictions = 0
    total_predictions = 0
    with torch.no_grad():
        for batch in test_loader:
            inputs = batch['pixel_values'].permute(0,3,1,2).float().to(device)
            labels = batch['label'].to(device)

            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total_predictions += labels.size(0)
            correct_predictions += (predicted == labels).sum().item()

            loss = criterion(outputs, labels)
            running_loss += loss.item()

    test_accuracy = correct_predictions / total_predictions
    test_loss = running_loss / len(test_loader)

    return test_loss, test_accuracy

def cross_val(ds, holdout_set):
    train = ds.filter(lambda example: example['cluster'] not in holdout_set)
    test = ds.filter(lambda example: example['cluster'] in holdout_set)

    model = resnet50(pretrained=True)
    num_classes = len(ds['label'].unique())
    model.fc = nn.Linear(2048, num_classes)

    # Define the loss function and optimizer
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    # Define the data loaders
    train_loader = torch.utils.data.DataLoader(train, batch_size=32, shuffle=True)
    test_loader = torch.utils.data.DataLoader(test, batch_size=32, shuffle=False)

    # Train the model
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)

    results = []

    for epoch in range(5):
        train_loss, train_accuracy = train_one_epoch(model, train_loader, criterion, optimizer, device)
        test_loss, test_accuracy = evaluate_one_epoch(model, test_loader, criterion, device)

        results.append({
            'epoch': epoch + 1,
            'train_loss': train_loss,
            'train_accuracy': train_accuracy,
            'test_loss': test_loss,
            'test_accuracy': test_accuracy,
            'holdout_set': holdout_set
        })
    
    results_df = pd.DataFrame(results)

    return results_df

```

Next we'll sequentially holdout geographic clusters and store performance:
```python
results = []
pbar_holdout = tqdm(holdout_sets, desc="Holdout Sets")
for holdout_set in pbar_holdout:
    results.append(cross_val(ds, holdout_set))
    pbar_holdout.set_postfix_str(f"Completed holdout set {holdout_set}")

results_df = pd.concat(results)
```

Finally, we plot the results of geographic cross-validation:
```python
import numpy as np
import matplotlib.pyplot as plt

# Group the results by epoch
grouped_results = results_df.groupby('epoch')

# Compute the mean and standard deviation of the test accuracy at each epoch
mean_test_accuracy = grouped_results['test_accuracy'].mean()
std_test_accuracy = grouped_results['test_accuracy'].std()

# Compute the 68% confidence interval
lower_bound = mean_test_accuracy - std_test_accuracy
upper_bound = mean_test_accuracy + std_test_accuracy

# Plot the mean test accuracy
plt.plot(mean_test_accuracy.index, mean_test_accuracy)

# Plot the error ribbon
plt.fill_between(lower_bound.index, lower_bound, upper_bound, color='b', alpha=.1)

# Set the labels and title
plt.xlabel('Epoch')
plt.ylabel('Cross-validated Accuracy')

# Show the plot
plt.show()
```
<img src="https://huggingface.co/datasets/mpg-ranch/leafy_spurge/resolve/main/doc_figures/cluster_cv_fig.png" width="75%" height="75%">