Upload folder using huggingface_hub

README.md

@@ -1,12 +1,58 @@
 ---
-title: Biomass App
-emoji: 📉
-colorFrom: red
+title: Biomass Prediction App
+emoji: 🌳
+colorFrom: green
 colorTo: blue
 sdk: gradio
-sdk_version: 5.29.1
+sdk_version: 3.40.1
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Biomass Prediction App
+
+This Gradio app demonstrates biomass prediction from satellite imagery using a StableResNet model.
+
+## Features
+
+- Upload a multi-band satellite image (GeoTIFF format)
+- View predicted biomass as a heatmap or RGB overlay
+- Get statistics on predicted biomass values
+
+## Usage
+
+1. Upload a multi-band satellite image (GeoTIFF)
+2. Choose display type (heatmap or RGB overlay)  
+3. Click "Generate Biomass Prediction"
+4. View the prediction map and statistics
+
+## Model Information
+
+- **Created by:** pokkiri
+- **Date:** 2025-05-17
+- **Architecture:** StableResNet
+- **Model Repository:** [pokkiri/biomass-model](https://huggingface.co/pokkiri/biomass-model)
+- **Input:** Multi-spectral satellite imagery
+- **Output:** Above-ground biomass (Mg/ha)
+
+## Requirements
+
+- GeoTIFF image file with multiple spectral bands
+- Image bands should match those used during model training
+
+## How It Works
+
+The app connects to the biomass prediction model hosted on HuggingFace Hub. When you upload a satellite image:
+
+1. The app loads your GeoTIFF file
+2. For each pixel, it extracts the spectral values
+3. These values are processed through the StableResNet model
+4. The model predicts biomass values for each pixel
+5. Results are visualized on a map with summary statistics
+
+## Citation
+
+```
+@misc{biomass_app, author = {pokkiri}, title = {Biomass Prediction App}, year = {2025}, publisher = {HuggingFace Spaces}, howpublished = {https://huggingface.co/spaces/pokkiri/biomass-app} }
+
+```

app.py

@@ -0,0 +1,285 @@
+"""
+Gradio App for Biomass Prediction
+Provides a web interface for making predictions with StableResNet
+
+Author: najahpokkiri
+Date: 2025-05-17
+"""
+import os
+import torch
+import numpy as np
+import gradio as gr
+import joblib
+import tempfile
+import matplotlib.pyplot as plt
+import matplotlib.colors as colors
+from PIL import Image
+import io
+from huggingface_hub import hf_hub_download
+
+# Import model architecture
+from model import StableResNet
+
+class BiomassPredictorApp:
+    """Gradio app for biomass prediction"""
+    
+    def __init__(self, model_repo="pokkiri/biomass-model"):
+        self.model = None
+        self.package = None
+        self.model_repo = model_repo
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        
+        # Load the model
+        self.load_model()
+    
+    def load_model(self):
+        """Load the model and preprocessing pipeline from HuggingFace Hub"""
+        try:
+            # Download files from HuggingFace
+            model_path = hf_hub_download(repo_id=self.model_repo, filename="model.pt")
+            package_path = hf_hub_download(repo_id=self.model_repo, filename="model_package.pkl")
+            
+            # Load package with metadata
+            self.package = joblib.load(package_path)
+            n_features = self.package['n_features']
+            
+            # Initialize model
+            self.model = StableResNet(n_features=n_features)
+            self.model.load_state_dict(torch.load(model_path, map_location=self.device))
+            self.model.to(self.device)
+            self.model.eval()
+            
+            print(f"Model loaded successfully from {self.model_repo}")
+            print(f"Number of features: {n_features}")
+            print(f"Using device: {self.device}")
+            
+            return True
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            return False
+    
+    def predict_biomass(self, image_file, display_type="heatmap"):
+        """Predict biomass from a satellite image"""
+        try:
+            # Create a temporary file to save the uploaded file
+            with tempfile.NamedTemporaryFile(suffix='.tif', delete=False) as tmp_file:
+                tmp_path = tmp_file.name
+                with open(image_file.name, 'rb') as f:
+                    tmp_file.write(f.read())
+            
+            try:
+                import rasterio
+            except ImportError:
+                return None, "Error: rasterio is required but not installed."
+            
+            # Open the image file
+            with rasterio.open(tmp_path) as src:
+                image = src.read()
+                height, width = image.shape[1], image.shape[2]
+                transform = src.transform
+                crs = src.crs
+                
+                # Check if number of bands matches expected features
+                if image.shape[0] < self.package['n_features']:
+                    return None, f"Error: Image has {image.shape[0]} bands, but model expects at least {self.package['n_features']} features."
+                
+                print(f"Processing image: {height}x{width} pixels, {image.shape[0]} bands")
+                
+                # Process in chunks to avoid memory issues
+                chunk_size = 1000
+                predictions = np.zeros((height, width), dtype=np.float32)
+                
+                # Create mask for valid pixels (not NaN or Inf)
+                valid_mask = np.all(np.isfinite(image), 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 for valid pixels
+                        pixel_features = []
+                        for i, j in zip(valid_y, valid_x):
+                            # Extract bands
+                            pixel_values = image[:, y_start+i, x_start+j]
+                            pixel_features.append(pixel_values)
+                        
+                        # Convert to array and scale features
+                        pixel_features = np.array(pixel_features)
+                        pixel_features_scaled = self.package['scaler'].transform(pixel_features)
+                        
+                        # Make predictions
+                        with torch.no_grad():
+                            batch_tensor = torch.tensor(pixel_features_scaled, dtype=torch.float32).to(self.device)
+                            batch_predictions = self.model(batch_tensor).cpu().numpy()
+                        
+                        # Convert from log scale if needed
+                        if self.package['use_log_transform']:
+                            batch_predictions = np.exp(batch_predictions) - self.package.get('epsilon', 1.0)
+                            batch_predictions = np.maximum(batch_predictions, 0)  # Ensure non-negative
+                        
+                        # 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]
+                
+                # Delete temporary file
+                os.unlink(tmp_path)
+                
+                # Create visualization
+                plt.figure(figsize=(12, 8))
+                
+                if display_type == "heatmap":
+                    # Create heatmap
+                    plt.imshow(predictions, cmap='viridis')
+                    plt.colorbar(label='Biomass (Mg/ha)')
+                    plt.title('Predicted Above-Ground Biomass')
+                    
+                elif display_type == "rgb_overlay":
+                    # Create RGB + overlay
+                    if image.shape[0] >= 3:
+                        # Use first 3 bands as RGB
+                        rgb = image[[0, 1, 2]].transpose(1, 2, 0)
+                        rgb = np.clip((rgb - np.percentile(rgb, 2)) / (np.percentile(rgb, 98) - np.percentile(rgb, 2)), 0, 1)
+                        
+                        plt.imshow(rgb)
+                        
+                        # Create mask for overlay (where we have predictions)
+                        mask = ~np.isclose(predictions, 0)
+                        overlay = np.zeros((height, width, 4))
+                        
+                        # Create colormap for biomass
+                        norm = colors.Normalize(vmin=np.percentile(predictions[mask], 5), 
+                                              vmax=np.percentile(predictions[mask], 95))
+                        cmap = plt.cm.viridis
+                        
+                        # Apply colormap
+                        overlay[..., :3] = cmap(norm(predictions))[..., :3]
+                        overlay[..., 3] = np.where(mask, 0.7, 0)  # Set alpha channel
+                        
+                        plt.imshow(overlay)
+                        plt.colorbar(plt.cm.ScalarMappable(norm=norm, cmap=cmap), 
+                                    label='Biomass (Mg/ha)')
+                        plt.title('Biomass Prediction Overlay')
+                    else:
+                        plt.imshow(predictions, cmap='viridis')
+                        plt.colorbar(label='Biomass (Mg/ha)')
+                        plt.title('Predicted Above-Ground Biomass')
+                
+                # Save figure to bytes buffer
+                buf = io.BytesIO()
+                plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
+                buf.seek(0)
+                
+                # Create summary statistics
+                valid_predictions = predictions[valid_mask]
+                stats = {
+                    'Mean Biomass': f"{np.mean(valid_predictions):.2f} Mg/ha",
+                    'Median Biomass': f"{np.median(valid_predictions):.2f} Mg/ha",
+                    'Min Biomass': f"{np.min(valid_predictions):.2f} Mg/ha",
+                    'Max Biomass': f"{np.max(valid_predictions):.2f} Mg/ha",
+                    'Total Biomass': f"{np.sum(valid_predictions) * (transform[0] * transform[0]) / 10000:.2f} Mg",
+                    'Area': f"{np.sum(valid_mask) * (transform[0] * transform[0]) / 10000:.2f} hectares"
+                }
+                
+                # Format statistics as markdown
+                stats_md = "### Biomass Statistics\n\n"
+                stats_md += "| Metric | Value |\n|--------|-------|\n"
+                for k, v in stats.items():
+                    stats_md += f"| {k} | {v} |\n"
+                
+                # Close the plot
+                plt.close()
+                
+                # Return visualization and statistics
+                return Image.open(buf), stats_md
+                
+        except Exception as e:
+            import traceback
+            return None, f"Error predicting biomass: {str(e)}\n\n{traceback.format_exc()}"
+
+    def create_interface(self):
+        """Create Gradio interface"""
+        with gr.Blocks(title="Biomass Prediction Model") as interface:
+            gr.Markdown("# Above-Ground Biomass Prediction")
+            gr.Markdown("""
+            Upload a multi-band satellite image to predict above-ground biomass (AGB) across the landscape.
+            
+            **Requirements:**
+            - Image must be a GeoTIFF with spectral bands
+            - For best results, image should contain similar bands to those used in training
+            """)
+            
+            with gr.Row():
+                with gr.Column():
+                    input_image = gr.File(
+                        label="Upload Satellite Image (GeoTIFF)",
+                        file_types=[".tif", ".tiff"]
+                    )
+                    
+                    display_type = gr.Radio(
+                        choices=["heatmap", "rgb_overlay"],
+                        value="heatmap",
+                        label="Display Type"
+                    )
+                    
+                    submit_btn = gr.Button("Generate Biomass Prediction")
+                
+                with gr.Column():
+                    output_image = gr.Image(
+                        label="Biomass Prediction Map",
+                        type="pil"
+                    )
+                    
+                    output_stats = gr.Markdown(
+                        label="Statistics"
+                    )
+            
+            with gr.Accordion("About", open=False):
+                gr.Markdown(f"""
+                ## About This Model
+                
+                This biomass prediction model uses the StableResNet architecture to predict above-ground biomass from satellite imagery.
+                
+                ### Model Details
+                
+                - Architecture: StableResNet
+                - Input: Multi-spectral satellite imagery
+                - Output: Above-ground biomass (Mg/ha)
+                - Creator: {pokkiri}
+                - Date: {2025-05-17}
+                - Model Repository: [{pokkiri/biomass-model}](https://huggingface.co/{pokkiri/biomass-model})
+                
+                ### How It Works
+                
+                1. The model extracts features from each pixel in the satellite image
+                2. These features are processed through the StableResNet model
+                3. The model outputs a biomass prediction for each pixel
+                4. Results are visualized as a heatmap or RGB overlay
+                """)
+            
+            submit_btn.click(
+                fn=self.predict_biomass,
+                inputs=[input_image, display_type],
+                outputs=[output_image, output_stats]
+            )
+        
+        return interface
+
+def launch_app():
+    """Launch the Gradio app"""
+    app = BiomassPredictorApp()
+    interface = app.create_interface()
+    interface.launch()
+
+if __name__ == "__main__":
+    launch_app()

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()

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
+gradio>=3.0.0
+pillow>=8.0.0