OpenViSTAI · Agents · Blockchain · Crypto
Submit a project
Menu
AI Data & Analytics

Robosat

RoboSat is a Python 3 pipeline for preparing data, training segmentation models and extracting geospatial features from aerial and satellite imagery. It can produce masks, building outlines and simplified GeoJSON polygons.

Explore the practical guide ↓

Independent OpenViST project profile, based on linked sources.

Robosat — OpenViST project profile in AI Data & Analytics.
OpenViST project illustration. See the linked sources for product details.
Understand the project

Practical overview

When it fits

Use RoboSat when you need a configurable pipeline that connects imagery and training data preparation with segmentation and geospatial post-processing.

Who it is for

  • Geospatial developers building imagery-based feature extraction workflows
  • Mapping and data teams preparing training datasets from imagery and map geometries

Documented uses

  • Prepare image and mask datasets for model training
  • Train segmentation models to identify features such as buildings, roads, parking lots, water and clouds
  • Run model predictions on imagery using a GPU or CPU
  • Clean segmentation outputs and convert tile-based results into GeoJSON features
Before you choose

Requirements & limits

The repository is public and specifies the MIT license. It provides CPU and GPU Docker images. The repository says Mapbox no longer maintains or actively develops RoboSat.

  • Training is recommended on GPUs; prediction can run on GPUs or CPUs.
  • The documented pipeline uses Slippy Map tile format and requires dataset or model configuration adapted to the imagery and deployment setup.
  • OpenStreetMap geometries and Mapbox imagery endpoints are described as convenient data sources, while the project also supports bringing other imagery and masks.
  • GPU training with the example Docker setup requires the NVIDIA Docker runtime.
  • The project is no longer actively maintained or developed by Mapbox.

Check current requirements in the official documentation. Source-based guidance does not mean OpenViST has run or independently tested this project.

Source-based practical guide

Prepare a RoboSat imagery training dataset

Create imagery and feature-mask inputs for a RoboSat segmentation model.

Before you start

  • RoboSat tools, invoked as ./rs
  • OpenStreetMap .osm.pbf base-map data and feature geometries to use as training labels
  • An imagery endpoint and Slippy Map tiles if using the documented image-download workflow

Steps

  1. Run rs extract on OpenStreetMap .osm.pbf data to produce GeoJSON feature geometries.

  2. Run rs cover on the extracted GeoJSON to produce a list of covering (x, y, z) Slippy Map tiles.

  3. Run rs download with the tile list and a Slippy Map imagery endpoint to create a directory of aerial or satellite images.

  4. Use rs rasterize to rasterize GeoJSON features into masks for the imagery dataset.

Expected outcome

A dataset composed of aerial or satellite imagery and corresponding feature masks, ready for the model-training stage.

Guide limitations

  • The configuration files need to be adapted to the dataset, including tile resolution.
  • The documented download stage requires a Slippy Map endpoint; the Mapbox example URL includes an access-token placeholder.
  • The project is no longer maintained or actively developed by Mapbox.
Documentation 1 ↗
Source-based practical guide

Train a RoboSat segmentation model with the GPU container

Start model training using the documented RoboSat GPU Docker image and configuration files.

Before you start

  • Docker and nvidia-docker on the host for GPU access
  • model.toml and dataset.toml configuration files accessible from the current directory
  • Configuration files adapted to the dataset and deployment setup

Steps

  1. Place the model and dataset configuration files in the directory from which the container will be run.

  2. Run the documented GPU-container training command: the command below.

    Documented command
    docker run --runtime=nvidia -it --rm -v $PWD:/data --ipc=host mapbox/robosat:latest-gpu train --model /data/model.toml --dataset /data/dataset.toml --workers 4

  3. Use the resulting model checkpoint as the documented handoff to the prediction stage.

Expected outcome

The documented workflow starts training a model in the GPU container; RoboSat's overview describes saving a trained model checkpoint for subsequent prediction.

Guide limitations

  • The host must have nvidia-docker for GPU access; --ipc=host is required for shared-memory communication between workers.
  • The README recommends GPUs for training but does not document a guaranteed training result or duration.
  • The project is no longer maintained or actively developed by Mapbox.
Documentation 1 ↗
Evidence and transparency

Sources & review

Official repository ↗
Source record details
Source availability
Active
Sources checked
11 October 2026
Original website title
mapbox/robosat · Official homepage title · retained in its source language
How we review sourcesSuggest a correction