SEAL 🦭
Segment Any Events with Language

Seungjun Lee · Gim Hee Lee
Department of Computer Science, National University of Singapore

ICLR 2026

Code | Paper | Project Page | Hugging Face

Our SEAL is the first Semantic-aware Segment Any Events model.

Table of Contents

1. TODO
2. Installation
3. Data Preparation
4. Training
5. Evaluation
6. Demo
7. Acknowledgement
8. Citation

News:

• [2026/01/26] SEAL is accepted to ICLR 2026 🔥. The code will be released before April.
• [2026/03/31] Code for SEAL and instance segmentation benchmarks are released 👊🏻! Interactive demo is coming soon.
• [2026/04/01] Interactive demo of SEAL is released 👊🏻! Enter the box, points and text, and interact with events stream by yourself!

TODO

• Release the code of SEAL
• Release the benchmarks for instance segmentation
• Release the interactive demo.
• Release the code of SEAL++
• Release the benchmarks for part segmentation

Installation

Dependencies 📝

The main dependencies of the project are the following:

python: 3.8
cuda: 11.8

You can set up a conda environment as follows:

conda create -n seal python=3.8
conda activate seal

pip install torch==2.4.1+cu118 torchvision==0.19.1+cu118 torchaudio==2.4.1+cu118 --extra-index-url https://download.pytorch.org/whl/cu118

pip install -r requirements.txt

pip install git+https://github.com/openai/CLIP.git

cd pointnet2
pip install . --force-reinstall --no-deps
cd ..

# For demo
pip install gradio

Data Preparation

The training datasets, benchmarks and pretrained weights are available here. You can easily download all the preprocessed data by running:

python download_data.py
python download_checkpoints.py

Once you run the above command, the downloaded files should be located to designated path. Refer to the file structure below:

cache
├── eventsam.pth                        <- pretrained weights of events backbone
├── seal.pt                             <- pretrained weights of seal
└── sam_vit_b_01ec64.pth                        

...

dataset
├── data                   
│   ├── ddd17                           <- DDD17 dataset
│   │   ├── dir0                        <- Driving scene
│   │   │   ├── imgs                    <- RGB images
│   │   │   ├── mhsg                    <- MHSG guidance
│   │   │   ├── recons_image            <- E2VID-reconstructed frames
│   │   │   ├── segmentation_masks      <- Semantic maps
│   │   │   └── voxel_image             <- Events frame
│   │   ├── dir1
│   │   └── ...
│   └── DSEC                            <- DSEC dataset
│       ├──test                         <- Test scene
│       │  ├── zurich_city_13_a         
│       │  │   ├── instance_gt          <- Ground-truth instance masks
│       │  │   ├── recons_image         <- E2VID-reconstructed frames
│       │  │   ├── rgb_image            <- RGB images
│       │  │   ├── semantic_gt          <- Semantic maps
│       │  │   └── voxel_image          <- Events frame
│       │  └── ...   
│       └── train
│           └── ...
└── metadata
    ├──ddd17_eval.txt                   <- Evaluation lists of DDD17-Instance
    ├──dsec11_eval.txt                  <- Evaluation lists of DSEC11-Instance
    ├──dsec19_eval.txt                  <- Evaluation lists of DSEC19-Instance
    └──train.txt                        <- Training list

Training

Training consists of two stages. We conduct the training in RTX A6000 Ada GPU.

1. Training events backbone

You need to train events backbone by following the EventSAM. Enter the path to store the checkpoints in here of event_encoder/train_eventsam.py.

python event_encoder/train_eventsam.py

Or, you may directly use the pretrained weights we provide in cache/eventsam.pth. In that case, skip Stage 1 and run Stage 2 directly.

2. Training SEAL

python event_encoder/train_seal.py --config-path=../configs/train --config-name=seal.yaml

The model weight and log will be stored in checkpoints and log folder, respectively. We also provide our training log in train.log.

Evaluation

We provide pretrained weights at cache/seal.pt. By running the commands below, the code will evaluate SEAL using the provided weights. To use your own weights, simply append general.checkpoint={YOUR_PATH} to the end of the command.

In the commands below, specify the dataset name: DDD17, DSEC11, or DSEC19 in {DATASET}.

Evaluate with box prompt

python event_encoder/test_seal.py --config-path=../configs/eval/{DATASET} --config-name=seal.yaml

Evaluate with point prompt

python event_encoder/test_seal.py --config-path=../configs/eval/{DATASET} --config-name=seal.yaml dataset.test.prompt=point

Demo

Try our interactive demo! If you click the thumbnail below, you can watch our demo video.

Our demo supports:

• Segment / classify instances with box prompts
• Segment / classify instances with point prompts
• Retrieve the masks based on the open-vocabulary queries. In this case, pre-defined box prompts are provided as candidates following Sec. B.5 of main paper.

Run the command and try by yourself!

python gradio_seal.py --config configs/eval/DSEC19/seal.yaml --checkpoint cache/seal.pt --data-root dataset/data/DSEC/test --server-port 7860

Acknowledgement

Our work is inspired a lot from the following works. We sincerely appreciate to their great contributions!

• EventSAM
• OpenESS
• DEOE
• RVT

Citation

If you find our code or paper useful, please cite

@article{lee2026segment,
  title={Segment Any Events with Language},
  author={Lee, Seungjun and Lee, Gim Hee},
  journal={arXiv preprint arXiv:2601.23159},
  year={2026}
}