Upload README.md with huggingface_hub

README.md

@@ -79,8 +79,154 @@ We gathered ground truth at multiple sites and observations within a site were g
 
 ```python
  #define holdout sets with ground truth clusters; 6 and 7 overlap geographically
-holdout_sets = [[0], [1], [2], [4], [5], [6,7], [8]]
+holdout_sets = [[0], [1], [2], [4], [5], [6,7], [8]] #spatial clusters of ground truth define holdout sets; 6 and 7
 
 set_0 = ds.filter(lambda example: example['cluster'] in holdout_sets[0])
-set_0['cluster']
-```
+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 lets format set the format of the dataset to torch format 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%">