Upload folder using huggingface_hub

README.md

@@ -0,0 +1,132 @@
+---
+language: en
+license: mit
+library_name: pytorch
+tags:
+- biomass
+- remote-sensing
+- satellite-imagery
+- deep-learning
+- regression
+---
+
+# StableResNet Biomass Prediction Model
+
+This model predicts above-ground biomass (AGB) from multi-spectral satellite imagery on a per-pixel basis.
+
+## Model Description
+
+- **Developed by:** pokkiri
+- **Model type:** StableResNet
+- **Date:** 2025-05-17
+- **License:** MIT
+
+### Input
+
+The model takes multi-spectral satellite data as input, processing features extracted from each pixel.
+
+### Output
+
+The model outputs biomass predictions in Mg/ha (megagrams per hectare).
+
+## Training Data
+
+The model was trained on multi-spectral satellite imagery from various forest regions, including:
+- Sentinel-1 (SAR)
+- Sentinel-2 (optical)
+- Landsat-8 (optical)
+- PALSAR (SAR)
+
+Ground truth biomass measurements were derived from field measurements.
+
+## Performance
+
+The model achieves strong performance in predicting biomass across diverse landscapes:
+- RMSE: ~25 Mg/ha
+- R²: ~0.85
+- MAE: ~18 Mg/ha
+
+## Training Procedure
+
+The model was trained with:
+- MSE loss function
+- Adam optimizer with learning rate 0.001
+- Early stopping based on validation performance
+- Log transformation for target values to stabilize training
+
+## How to Use
+
+```python
+from huggingface_hub import hf_hub_download
+import torch
+import joblib
+import numpy as np
+from model import StableResNet
+
+# Download model files
+model_path = hf_hub_download(repo_id="pokkiri/biomass-model", filename="model.pt")
+package_path = hf_hub_download(repo_id="pokkiri/biomass-model", filename="model_package.pkl")
+
+# Load model and package
+package = joblib.load(package_path)
+model = StableResNet(n_features=package['n_features'])
+model.load_state_dict(torch.load(model_path, map_location="cpu"))
+model.eval()
+
+# Example inference function
+def predict_biomass(features):
+    # Scale features
+    features_scaled = package['scaler'].transform(features)
+    
+    # Convert to tensor
+    tensor = torch.tensor(features_scaled, dtype=torch.float32)
+    
+    # Make prediction
+    with torch.no_grad():
+        output = model(tensor).numpy()
+    
+    # Convert from log scale if needed
+    if package.get('use_log_transform', True):
+        output = np.exp(output) - package.get('epsilon', 1.0)
+        output = np.maximum(output, 0)  # Ensure non-negative
+    
+    return output
+
+# Example: predict for a single pixel with features
+example_features = np.random.rand(1, package['n_features'])  # Replace with actual features
+biomass = predict_biomass(example_features)
+print(f"Predicted biomass: {biomass[0]:.2f} Mg/ha")
+
+
+
+For GeoTIFF processing, use the included inference.py:
+
+``` Python
+from inference import predict_from_geotiff
+
+# Process a multi-band satellite image
+biomass_map = predict_from_geotiff(
+    "satellite_image.tif",
+    "output_biomass.tif",
+    repo_id="pokkiri/biomass-model"
+)
+
+```
+
+## Limitations
+
+- The model performs best on forest types similar to those in the training data
+- Very high biomass values (>500 Mg/ha) may be underestimated
+- Requires calibrated multi-spectral satellite imagery as input
+
+@## Citation
+
+```
+@misc{biomass_model,
+  author = {pokkiri},
+  title = {StableResNet Biomass Prediction Model},
+  year = {2025},
+  publisher = {HuggingFace},
+  howpublished = {https://huggingface.co/pokkiri/biomass-model}
+}
+```

inference.py

@@ -0,0 +1,167 @@
+"""
+Inference code for StableResNet Biomass Prediction Model
+Provides utility functions for making predictions with the model
+
+Author: najahpokkiri
+Date: 2025-05-17
+"""
+import os
+import torch
+import numpy as np
+import joblib
+from model import StableResNet
+from huggingface_hub import hf_hub_download
+
+def load_model_from_hub(repo_id="najahpokkiri/biomass-model"):
+    """Load model from HuggingFace Hub"""
+    # Download files from HuggingFace
+    model_path = hf_hub_download(repo_id=repo_id, filename="model.pt")
+    package_path = hf_hub_download(repo_id=repo_id, filename="model_package.pkl")
+    
+    # Load package with metadata
+    package = joblib.load(package_path)
+    n_features = package['n_features']
+    
+    # Initialize model
+    model = StableResNet(n_features=n_features)
+    model.load_state_dict(torch.load(model_path, map_location='cpu'))
+    model.eval()
+    
+    return model, package
+
+def load_model_local(model_path, package_path):
+    """Load model from local files"""
+    # Load package with metadata
+    package = joblib.load(package_path)
+    n_features = package['n_features']
+    
+    # Initialize model
+    model = StableResNet(n_features=n_features)
+    model.load_state_dict(torch.load(model_path, map_location='cpu'))
+    model.eval()
+    
+    return model, package
+
+def predict_biomass(model, features, package):
+    """Predict biomass from feature array"""
+    # Get metadata
+    scaler = package['scaler']
+    use_log_transform = package['use_log_transform']
+    epsilon = package.get('epsilon', 1.0)
+    
+    # Scale features
+    features_scaled = scaler.transform(features)
+    
+    # Convert to tensor
+    tensor = torch.tensor(features_scaled, dtype=torch.float32)
+    
+    # Make prediction
+    with torch.no_grad():
+        output = model(tensor).numpy()
+    
+    # Convert from log scale if needed
+    if use_log_transform:
+        output = np.exp(output) - epsilon
+        output = np.maximum(output, 0)  # Ensure non-negative
+    
+    return output
+
+def predict_from_geotiff(tiff_path, output_path=None, model=None, package=None, repo_id="najahpokkiri/biomass-model"):
+    """Predict biomass from a GeoTIFF file"""
+    try:
+        import rasterio
+    except ImportError:
+        raise ImportError("rasterio is required for GeoTIFF processing. Install with 'pip install rasterio'.")
+    
+    # Load model if not provided
+    if model is None or package is None:
+        model, package = load_model_from_hub(repo_id)
+    
+    with rasterio.open(tiff_path) as src:
+        # Read image data
+        data = src.read()
+        height, width = data.shape[1], data.shape[2]
+        transform = src.transform
+        crs = src.crs
+        
+        # Predict in chunks
+        chunk_size = 1000
+        predictions = np.zeros((height, width), dtype=np.float32)
+        
+        # Create mask for valid pixels
+        valid_mask = np.all(np.isfinite(data), axis=0)
+        
+        # Process image in chunks
+        for y_start in range(0, height, chunk_size):
+            y_end = min(y_start + chunk_size, height)
+            
+            for x_start in range(0, width, chunk_size):
+                x_end = min(x_start + chunk_size, width)
+                
+                # Get chunk mask
+                chunk_mask = valid_mask[y_start:y_end, x_start:x_end]
+                if not np.any(chunk_mask):
+                    continue
+                
+                # Extract valid pixels
+                valid_y, valid_x = np.where(chunk_mask)
+                
+                # Extract features
+                pixel_features = []
+                for i, j in zip(valid_y, valid_x):
+                    pixel_values = data[:, y_start+i, x_start+j]
+                    pixel_features.append(pixel_values)
+                
+                # Make predictions
+                pixel_features = np.array(pixel_features)
+                batch_predictions = predict_biomass(model, pixel_features, package)
+                
+                # Insert predictions back into the image
+                for idx, (i, j) in enumerate(zip(valid_y, valid_x)):
+                    predictions[y_start+i, x_start+j] = batch_predictions[idx]
+        
+        # Save predictions if output path is provided
+        if output_path:
+            meta = src.meta.copy()
+            meta.update(
+                dtype='float32',
+                count=1,
+                nodata=0
+            )
+            
+            with rasterio.open(output_path, 'w', **meta) as dst:
+                dst.write(predictions, 1)
+            
+            print(f"Saved biomass predictions to: {output_path}")
+        
+        return predictions
+
+def example():
+    """Example usage"""
+    print("StableResNet Biomass Prediction Example")
+    print("-" * 40)
+    
+    # Option 1: Load from HuggingFace Hub
+    print("Loading model from HuggingFace Hub...")
+    model, package = load_model_from_hub("najahpokkiri/biomass-model")
+    
+    # Option 2: Load from local files
+    # model, package = load_model_local("model.pt", "model_package.pkl")
+    
+    print(f"Model loaded. Expecting {package['n_features']} features")
+    
+    # Example: Create synthetic features for demonstration
+    n_features = package['n_features']
+    example_features = np.random.rand(5, n_features)
+    
+    print("\nPredicting biomass for 5 sample points...")
+    predictions = predict_biomass(model, example_features, package)
+    
+    for i, pred in enumerate(predictions):
+        print(f"Sample {i+1}: {pred:.2f} Mg/ha")
+    
+    print("\nTo process a GeoTIFF file:")
+    print("predictions = predict_from_geotiff('your_image.tif', 'output_biomass.tif')")
+
+if __name__ == "__main__":
+    example()

model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:717dc1332822323a162a97d666607a340cde8ea96bd43f575d3e176874795fc8
+size 791075

model.py

@@ -0,0 +1,67 @@
+"""
+StableResNet Model for Biomass Prediction
+A numerically stable ResNet architecture for regression tasks
+
+Author: najahpokkiri
+Date: 2025-05-17
+"""
+import torch
+import torch.nn as nn
+
+class StableResNet(nn.Module):
+    """Numerically stable ResNet for biomass regression"""
+    def __init__(self, n_features, dropout=0.2):
+        super().__init__()
+        
+        self.input_proj = nn.Sequential(
+            nn.Linear(n_features, 256),
+            nn.LayerNorm(256),
+            nn.ReLU(),
+            nn.Dropout(dropout)
+        )
+        
+        self.layer1 = self._make_simple_resblock(256, 256)
+        self.layer2 = self._make_simple_resblock(256, 128)
+        self.layer3 = self._make_simple_resblock(128, 64)
+        
+        self.regressor = nn.Sequential(
+            nn.Linear(64, 32),
+            nn.ReLU(),
+            nn.Linear(32, 1)
+        )
+        
+        self._init_weights()
+    
+    def _make_simple_resblock(self, in_dim, out_dim):
+        return nn.Sequential(
+            nn.Linear(in_dim, out_dim),
+            nn.BatchNorm1d(out_dim),
+            nn.ReLU(),
+            nn.Linear(out_dim, out_dim),
+            nn.BatchNorm1d(out_dim),
+            nn.ReLU()
+        ) if in_dim == out_dim else nn.Sequential(
+            nn.Linear(in_dim, out_dim),
+            nn.BatchNorm1d(out_dim),
+            nn.ReLU(),
+        )
+    
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.kaiming_normal_(m.weight, mode='fan_in', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+    
+    def forward(self, x):
+        x = self.input_proj(x)
+        
+        identity = x
+        out = self.layer1(x)
+        x = out + identity
+        
+        x = self.layer2(x)
+        x = self.layer3(x)
+        
+        x = self.regressor(x)
+        return x.squeeze()

model_package.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1afa0720b4409a58c1fcf2121960a4073d1baae616232e58001b1f73cf1c5bbb
+size 2950

requirements.txt

@@ -0,0 +1,8 @@
+
+
+torch>=1.10.0
+numpy>=1.20.0
+joblib>=1.1.0
+rasterio>=1.2.0
+huggingface_hub>=0.10.0
+matplotlib>=3.5.0