Stellaris: Global Disaster Risk Analyser and Map

Inspiration

With the increasing frequency and severity of natural disasters around the world, there is a critical need for intelligent systems that can help predict, visualise, and manage disaster risks. Stellaris was born from the idea of leveraging machine learning and modern deployment tools to build a scalable platform that provides actionable insights for disaster preparedness and mitigation.

What it does

Stellaris is a comprehensive machine learning platform that:

• Predicts disaster risks using a neural network trained on multi-source global disaster data.
• Loads and serves predictions via predictor.py, model_unpickler.py and model_loader.py.
• Visualises high-risk zones on an interactive global map using GeoPandas.
• Provides an intuitive Streamlit-based dashboard for user interaction and exploration.
• Automates scheduled tasks such as model updates using Python’s schedule library.
• Runs inside a Docker container and is orchestrated with Kubernetes for scalability and reliability.

How we built it

• Data: Integrated and processed 7 CSV files covering over 6 types of disasters, including floods, earthquakes, tsunamis, and forest fires.
• Model: Built a neural network model using PyTorch to predict disaster risk levels based on historical and geographical features.
• Prediction Pipeline: Implemented predictor.py and pickle_loader.py to handle model inference and loading of serialised model objects.
• Frontend: Developed a Streamlit dashboard for interacting with prediction outputs and viewing dynamic maps.
• Mapping: Used GeoPandas to render a global risk map highlighting vulnerable regions.
• Workflow: Employed the schedule library in Python to automate model retraining and log updates at defined intervals.
• Deployment: Containerised the application using Docker Desktop and managed deployment with Kubernetes to ensure reliability and scalability.

Challenges we ran into

• Integrating heterogeneous data sources with varying formats and missing values.
• Designing a generalisable model architecture that performs well across multiple disaster types.
• Efficiently rendering high-resolution geospatial data in a responsive web interface.
• Coordinating multiple layers—prediction scripts, frontend dashboard, and deployment tools.

Accomplishments that we're proud of

• Successfully deployed a fully containerised ML application using Docker and Kubernetes.
• Built a complete pipeline from data ingestion and model inference to interactive visualisation.
• Created a user-friendly and informative dashboard for disaster risk awareness.
• Developed a modular and maintainable architecture ready for future enhancements.

What we learned

• Effective use of PyTorch for structured data modelling in a real-world context.
• Practical deployment strategies using Docker and Kubernetes.
• Geospatial data handling and visualisation with GeoPandas.
• Scheduling and automation with Python’s built-in libraries.

What's next for Stellaris

• Integrate real-time data streams such as satellite imagery and live weather data.
• Extend the neural network to include temporal patterns using LSTM or GRU architectures.
• Add user authentication and role-based access control for secure dashboard use.
• Incorporate simulation tools to assist in disaster response and contingency planning.

Built With

• docker
• geopandas
• kubernetes
• neural-networks
• python
• streamlit
• torch