Spaces:
Sleeping
Sleeping
| title: NATO ASI AI Disaster Management | |
| emoji: 🌍 | |
| colorFrom: blue | |
| colorTo: red | |
| sdk: gradio | |
| sdk_version: 6.0.0 | |
| app_file: app.py | |
| pinned: false | |
| license: mit | |
| tags: | |
| - disaster-response | |
| - geospatial-ai | |
| - nato | |
| - education | |
| - satellite-imagery | |
| short_description: Interactive educational platform for AI in Disaster Response | |
| # 🌍 NATO ASI - AI for Disaster Management: Interactive Gradio App | |
| **A state-of-the-art interactive web application for exploring AI-powered disaster management techniques.** | |
| --- | |
| ## 📖 Overview | |
| This Gradio application provides an **interactive learning platform** for participants of the NATO Advanced Study Institute on *"AI for Disaster Management"*. It showcases the key concepts, models, and techniques taught throughout the 7-day curriculum. | |
| ### 🎯 Key Features | |
| - **📚 Curriculum Explorer**: Navigate through the complete 7-day course structure | |
| - **🏗️ Building Damage Detection**: Interactive CNN-based damage classification demo | |
| - **🌊 Flood Mapping**: Semantic segmentation with U-Net for flood extent mapping | |
| - **🚀 Transfer Learning**: Compare pre-trained models (ResNet50, EfficientNet, etc.) | |
| - **⚖️ Deployment & Ethics**: Learn about production deployment and responsible AI | |
| - **📚 Resources**: Comprehensive links to datasets, papers, and learning materials | |
| --- | |
| ## 🚀 Quick Start | |
| ### Prerequisites | |
| - Python 3.8 or higher | |
| - pip package manager | |
| ### Installation | |
| 1. **Clone the repository** (if you haven't already): | |
| ```bash | |
| git clone https://github.com/AI4DM/Geospatial-AI-for-Humanitarian-Response.git | |
| cd Geospatial-AI-for-Humanitarian-Response | |
| ``` | |
| 2. **Install dependencies**: | |
| ```bash | |
| pip install -r requirements.txt | |
| ``` | |
| 3. **Launch the app**: | |
| ```bash | |
| python gradio_app.py | |
| ``` | |
| 4. **Access the app**: | |
| - Open your browser and navigate to: `http://localhost:7860` | |
| - Or use the public Gradio link that appears in the terminal (if sharing is enabled) | |
| ### Docker Installation (Alternative) | |
| ```bash | |
| # Build the Docker image | |
| docker build -t nato-asi-gradio . | |
| # Run the container | |
| docker run -p 7860:7860 nato-asi-gradio | |
| ``` | |
| --- | |
| ## 🎨 Application Structure | |
| ### Tab 1: Welcome 🏠 | |
| - Overview of the NATO ASI curriculum | |
| - Learning philosophy and objectives | |
| - Quick links to different sections | |
| ### Tab 2: Curriculum 📚 | |
| - Detailed day-by-day breakdown | |
| - Learning outcomes for each module | |
| - Key concepts and techniques | |
| ### Tab 3: Damage Detection 🏗️ | |
| - **Functionality**: Upload building images or generate samples | |
| - **Model**: CNN-based classification (4 damage levels) | |
| - **Output**: Damage level prediction with confidence scores | |
| - **Learning**: Days 2-3 content (CNN basics and production systems) | |
| ### Tab 4: Flood Mapping 🌊 | |
| - **Functionality**: Upload satellite imagery or generate flood scenarios | |
| - **Model**: U-Net semantic segmentation | |
| - **Output**: Pixel-wise flood extent maps with IoU scores | |
| - **Learning**: Days 4-5 content (semantic segmentation) | |
| ### Tab 5: Transfer Learning 🚀 | |
| - **Functionality**: Compare different pre-trained architectures | |
| - **Models**: ResNet50, VGG16, MobileNetV2, EfficientNetB0 | |
| - **Output**: Performance metrics and training time comparisons | |
| - **Learning**: Day 6 content (transfer learning techniques) | |
| ### Tab 6: Deployment & Ethics ⚖️ | |
| - Model optimization techniques (TFLite, quantization) | |
| - Deployment strategies (cloud, edge, hybrid) | |
| - Human-in-the-loop workflows | |
| - Ethical AI principles for disaster management | |
| ### Tab 7: Resources 📚 | |
| - Curated datasets for practice | |
| - Online courses and tutorials | |
| - Academic papers and research | |
| - Humanitarian organizations and communities | |
| --- | |
| ## 🔧 Customization & Extension | |
| ### Integrating Your Trained Models | |
| The app currently uses **simulated predictions** for demonstration purposes. To integrate your actual trained models: | |
| #### 1. Load Your Model | |
| ```python | |
| import tensorflow as tf | |
| # Load your trained model | |
| damage_model = tf.keras.models.load_model('path/to/your/damage_model.h5') | |
| flood_model = tf.keras.models.load_model('path/to/your/flood_model.h5') | |
| ``` | |
| #### 2. Replace Simulation Functions | |
| Update the `simulate_damage_detection()` and `simulate_flood_segmentation()` functions: | |
| ```python | |
| def real_damage_detection(image, confidence_threshold=0.7): | |
| """Real damage detection using trained model""" | |
| # Preprocess image | |
| img_array = np.array(image.resize((224, 224))) / 255.0 | |
| img_array = np.expand_dims(img_array, axis=0) | |
| # Predict | |
| predictions = damage_model.predict(img_array) | |
| damage_level = np.argmax(predictions[0]) | |
| confidence = predictions[0][damage_level] | |
| # Visualize results | |
| result_img = create_visualization(image, damage_level, confidence) | |
| return result_img, damage_level, confidence | |
| ``` | |
| #### 3. Update Gradio Interface | |
| Replace the function calls in the Gradio interface: | |
| ```python | |
| detect_btn.click( | |
| fn=real_damage_detection, # Changed from simulate_damage_detection | |
| inputs=[input_image, confidence_slider], | |
| outputs=[output_image, damage_output, confidence_output] | |
| ) | |
| ``` | |
| ### Adding New Features | |
| **Example: Add a New Tab for Temporal Analysis** | |
| ```python | |
| def create_temporal_analysis_tab(): | |
| with gr.Column(): | |
| gr.Markdown("# 📅 Temporal Change Detection") | |
| with gr.Row(): | |
| before_image = gr.Image(type="pil", label="Before Disaster") | |
| after_image = gr.Image(type="pil", label="After Disaster") | |
| analyze_btn = gr.Button("Analyze Changes") | |
| change_map = gr.Image(type="pil", label="Change Detection Map") | |
| analyze_btn.click( | |
| fn=detect_changes, | |
| inputs=[before_image, after_image], | |
| outputs=[change_map] | |
| ) | |
| # Add to main app | |
| with gr.Tab("📅 Change Detection"): | |
| create_temporal_analysis_tab() | |
| ``` | |
| --- | |
| ## 🎓 Educational Use | |
| ### For Instructors | |
| This app is designed to complement the Jupyter notebooks: | |
| 1. **Pre-Session**: Show the app during course introduction to demonstrate what students will build | |
| 2. **During Session**: Use interactive demos to visualize concepts before coding | |
| 3. **Post-Session**: Let students experiment with different parameters and scenarios | |
| 4. **Assessment**: Have students integrate their trained models into the app | |
| ### For Students | |
| Recommended learning workflow: | |
| 1. **Explore** → Use the app to understand what you'll be building | |
| 2. **Learn** → Work through the corresponding Jupyter notebook | |
| 3. **Build** → Train your own models using the notebooks | |
| 4. **Deploy** → Integrate your models into this Gradio app | |
| 5. **Share** → Demonstrate your results to peers and instructors | |
| --- | |
| ## 🌐 Deployment Options | |
| ### Local Development | |
| ```bash | |
| python gradio_app.py | |
| # Access at http://localhost:7860 | |
| ``` | |
| ### Public Sharing (Gradio) | |
| The app automatically creates a public link when launched: | |
| ```bash | |
| python gradio_app.py | |
| # Look for: "Running on public URL: https://xxxxx.gradio.live" | |
| ``` | |
| ### Hugging Face Spaces | |
| Deploy to Hugging Face Spaces for permanent hosting: | |
| 1. Create a new Space at https://huggingface.co/spaces | |
| 2. Upload `gradio_app.py` and `requirements.txt` | |
| 3. Space will automatically detect and run the Gradio app | |
| ### Google Cloud Run | |
| ```bash | |
| # Build container | |
| gcloud builds submit --tag gcr.io/PROJECT_ID/nato-asi-app | |
| # Deploy | |
| gcloud run deploy nato-asi-app \ | |
| --image gcr.io/PROJECT_ID/nato-asi-app \ | |
| --platform managed \ | |
| --region us-central1 \ | |
| --allow-unauthenticated | |
| ``` | |
| ### AWS EC2 | |
| ```bash | |
| # SSH into EC2 instance | |
| ssh -i your-key.pem ec2-user@your-instance-ip | |
| # Install dependencies | |
| sudo yum update -y | |
| sudo yum install python3 -y | |
| pip3 install -r requirements.txt | |
| # Run with nohup for persistent execution | |
| nohup python3 gradio_app.py > gradio.log 2>&1 & | |
| ``` | |
| --- | |
| ## 🛠️ Technical Details | |
| ### Architecture | |
| ``` | |
| gradio_app.py | |
| ├── CONSTANTS & CONFIGURATION | |
| │ ├── CURRICULUM_DAYS (course structure) | |
| │ └── DAMAGE_LEVELS (classification labels) | |
| │ | |
| ├── UTILITY FUNCTIONS | |
| │ ├── create_sample_building_image() - Generate synthetic buildings | |
| │ ├── create_flood_map_sample() - Generate flood scenarios | |
| │ ├── simulate_damage_detection() - Mock AI predictions | |
| │ └── simulate_flood_segmentation() - Mock segmentation | |
| │ | |
| ├── GRADIO INTERFACE COMPONENTS | |
| │ ├── create_welcome_tab() | |
| │ ├── create_curriculum_tab() | |
| │ ├── create_damage_detection_tab() | |
| │ ├── create_flood_mapping_tab() | |
| │ ├── create_transfer_learning_tab() | |
| │ ├── create_deployment_tab() | |
| │ └── create_resources_tab() | |
| │ | |
| └── MAIN APPLICATION | |
| └── create_app() - Assembles all components | |
| ``` | |
| ### Dependencies | |
| **Core** (Required): | |
| - `gradio` - Web interface framework | |
| - `numpy` - Numerical computations | |
| - `Pillow` - Image processing | |
| **Optional** (For real model integration): | |
| - `tensorflow` / `keras` - Deep learning | |
| - `rasterio` - Geospatial raster data | |
| - `geopandas` - Vector geospatial data | |
| ### Performance | |
| - **Launch Time**: ~2-3 seconds | |
| - **Inference** (simulated): <100ms | |
| - **Inference** (real TensorFlow model): 50-200ms on CPU, 10-50ms on GPU | |
| - **Memory**: ~200MB base, +2-4GB with loaded models | |
| --- | |
| ## 🐛 Troubleshooting | |
| ### Issue: Port 7860 already in use | |
| ```bash | |
| # Kill existing process | |
| lsof -ti:7860 | xargs kill -9 | |
| # Or use a different port | |
| python gradio_app.py --server-port 7861 | |
| ``` | |
| ### Issue: Module not found errors | |
| ```bash | |
| # Ensure all dependencies are installed | |
| pip install --upgrade -r requirements.txt | |
| # If using conda | |
| conda install -c conda-forge gradio numpy pillow | |
| ``` | |
| ### Issue: Images not displaying | |
| - Check that PIL/Pillow is properly installed | |
| - Verify image file paths are correct | |
| - Ensure uploaded images are in supported formats (JPG, PNG) | |
| ### Issue: Slow performance | |
| - Use GPU acceleration for model inference (requires TensorFlow GPU) | |
| - Reduce image resolution before processing | |
| - Enable model caching for repeated predictions | |
| --- | |
| ## 📊 Usage Analytics | |
| To track how participants use the app, you can integrate analytics: | |
| ```python | |
| import gradio as gr | |
| def track_interaction(action, details): | |
| timestamp = datetime.now().isoformat() | |
| log_entry = f"{timestamp} | {action} | {details}\n" | |
| with open("usage_analytics.log", "a") as f: | |
| f.write(log_entry) | |
| # Example usage | |
| detect_btn.click( | |
| fn=lambda img, threshold: ( | |
| track_interaction("damage_detection", f"threshold={threshold}"), | |
| detect_damage(img, threshold) | |
| )[1], | |
| inputs=[input_image, confidence_slider], | |
| outputs=[output_image, damage_output, confidence_output] | |
| ) | |
| ``` | |
| --- | |
| ## 🤝 Contributing | |
| We welcome contributions from the community! | |
| ### How to Contribute | |
| 1. **Fork** the repository | |
| 2. **Create** a feature branch: `git checkout -b feature/new-demo` | |
| 3. **Make** your changes | |
| 4. **Test** thoroughly | |
| 5. **Commit**: `git commit -m "Add new demo for landslide detection"` | |
| 6. **Push**: `git push origin feature/new-demo` | |
| 7. **Open** a Pull Request | |
| ### Contribution Ideas | |
| - 🆕 **New Demos**: Landslide detection, wildfire mapping, infrastructure damage | |
| - 🎨 **UI Improvements**: Better visualizations, responsive design | |
| - 📚 **Documentation**: Tutorials, video guides, translations | |
| - 🔧 **Features**: Real-time inference, batch processing, API endpoints | |
| - 🐛 **Bug Fixes**: Report issues or submit fixes | |
| --- | |
| ## 📄 License | |
| This project is licensed under the **MIT License**. See [LICENSE](LICENSE) for details. | |
| --- | |
| ## 🙏 Acknowledgments | |
| **Developed for**: NATO Advanced Study Institute on AI for Disaster Management | |
| **Special Thanks**: | |
| - Disaster response professionals who provided real-world insights | |
| - Open-source contributors of Gradio, TensorFlow, and geospatial libraries | |
| - Organizations sharing satellite imagery and disaster datasets | |
| --- | |
| ## 📞 Support | |
| ### Questions or Issues? | |
| - **GitHub Issues**: [Report bugs or request features](https://github.com/AI4DM/Geospatial-AI-for-Humanitarian-Response/issues) | |
| - **Email**: Contact the course instructor | |
| - **Slack/Discord**: Join the NATO ASI community channel | |
| ### Citation | |
| If you use this application in your work: | |
| ```bibtex | |
| @software{nato_asi_gradio_2025, | |
| title={NATO ASI - AI for Disaster Management: Interactive Gradio App}, | |
| author={Bulent Soykan}, | |
| year={2025}, | |
| url={https://github.com/AI4DM/Geospatial-AI-for-Humanitarian-Response} | |
| } | |
| ``` | |
| --- | |
| ## 🌟 Final Note | |
| This application demonstrates that **AI for disaster management** is not just about algorithms—it's about creating accessible, interpretable, and actionable tools that empower humanitarian responders to save lives. | |
| **Every feature in this app reflects a real-world need in disaster response.** | |
| <div align="center"> | |
| **Built with ❤️ for humanitarian AI applications** | |
| *Making the world more resilient to disasters, one model at a time.* | |
| </div> |