I2E: Real-Time Image-to-Event Conversion for High-Performance Spiking Neural Networks

🚀 Introduction

This repository contains the I2E-Datasets for the paper "I2E: Real-Time Image-to-Event Conversion for High-Performance Spiking Neural Networks", which has been accepted for Oral Presentation at AAAI 2026.

I2E is a pioneering framework that bridges the data scarcity gap in neuromorphic computing. By simulating microsaccadic eye movements via highly parallelized convolution, I2E converts static images into high-fidelity event streams in real-time (>300x faster than prior methods).

✨ Key Highlights

• SOTA Performance: Achieves 60.50% top-1 accuracy on Event-based ImageNet.
• Sim-to-Real Transfer: Pre-training on I2E data enables 92.5% accuracy on real-world CIFAR10-DVS, setting a new benchmark.
• Real-Time Conversion: Enables on-the-fly data augmentation for deep SNN training.

💻 Usage

The generated I2E-Datasets are provided in the Files and versions section.

🚀 Quick Start (Copy & Paste)

You don't need to manually handle the bit-unpacking. Just use the following snippet to load the data directly into PyTorch tensors.

import io
import torch
import numpy as np
from datasets import load_dataset
from torch.utils.data import Dataset

def unpack_event_data(raw_data):
    """
    Inputs: raw_data (1D uint8 numpy array, from np.load)
    Outputs: (shape, event_tensor)
    """
    # 1. Parse Header (First 4*2=8 bytes)
    # Assume shape is 4D (T, C, H, W)
    header_size = 4 * 2 
    shape_header = raw_data[:header_size].view(np.uint16)
    original_shape = tuple(shape_header)
    
    # 2. Parse Body
    packed_body = raw_data[header_size:]
    
    # 3. Unpack
    unpacked = np.unpackbits(packed_body)
    
    # 4. Extract valid bits (Handle padding)
    num_elements = np.prod(original_shape)
    event_flat = unpacked[:num_elements]
    
    # 5. Reshape and convert to Float Tensor
    # Use copy() to avoid issues with negative strides or non-contiguous memory
    event_data = event_flat.reshape(original_shape).astype(np.float32).copy()
    
    return original_shape, event_data


class I2E_Dataset(Dataset):
    def __init__(self, split='train', transform=None, target_transform=None):
        self.ds = load_dataset("UESTC-BICS/I2E", "I2E-CIFAR10", split=split)
        self.transform = transform
        self.target_transform = target_transform

    def __len__(self):
        return len(self.ds)

    def __getitem__(self, idx):
        item = self.ds[idx]
        
        with io.BytesIO(item['data']) as f:
            raw_data = np.load(f)
        _, event = unpack_event_data(raw_data) # Returns [T, C, H, W] Tensor
        event = torch.from_numpy(event)
        label = item['label']

        if self.transform:
            event = self.transform(event)
        if self.target_transform:
            label = self.target_transform(label)
        
        return event, label

train_dataset = I2E_Dataset(split='train')
val_dataset = I2E_Dataset(split='validation')

This repository hosts the datasets only.

For the I2E dataset generation code, training scripts, and detailed usage instructions, please refer to our official GitHub repository.

To generate the I2E-Datasets yourself using the I2E algorithm, please follow the instructions in the GitHub README.

🏆 Model Zoo & Results

We provide pre-trained models for I2E-CIFAR and I2E-ImageNet. You can download the .pth files directly from the Files and versions tab in model repository.

Target Dataset	Architecture	Method	Top-1 Acc
CIFAR10-DVS (Real)	MS-ResNet18	Baseline	65.6%
	MS-ResNet18	Transfer-I	83.1%
	MS-ResNet18	Transfer-II (Sim-to-Real)	92.5%
I2E-CIFAR10	MS-ResNet18	Baseline-I	85.07%
	MS-ResNet18	Baseline-II	89.23%
	MS-ResNet18	Transfer-I	90.86%
I2E-CIFAR100	MS-ResNet18	Baseline-I	51.32%
	MS-ResNet18	Baseline-II	60.68%
	MS-ResNet18	Transfer-I	64.53%
I2E-ImageNet	MS-ResNet18	Baseline-I	48.30%
	MS-ResNet18	Baseline-II	57.97%
	MS-ResNet18	Transfer-I	59.28%
	MS-ResNet34	Baseline-II	60.50%

Method Legend:

• Baseline-I: Training from scratch with minimal augmentation.
• Baseline-II: Training from scratch with full augmentation.
• Transfer-I: Fine-tuning from Static ImageNet (or I2E-ImageNet for CIFAR targets).
• Transfer-II: Fine-tuning from I2E-CIFAR10.

👁️ Visualization

Below is the visualization of the I2E conversion process. We illustrate the high-fidelity conversion from static RGB images to dynamic event streams.

More than 200 additional visualization comparisons can be found in Visualization.md.

📜 Citation

If you find this work or the models useful, please cite our AAAI 2026 paper:

@article{ma2025i2e,
  title={I2E: Real-Time Image-to-Event Conversion for High-Performance Spiking Neural Networks},
  author={Ma, Ruichen and Meng, Liwei and Qiao, Guanchao and Ning, Ning and Liu, Yang and Hu, Shaogang},
  journal={arXiv preprint arXiv:2511.08065},
  year={2025}
}