DLSCA Test Dataset

A Hugging Face dataset for Deep Learning Side Channel Analysis (DLSCA) with streaming support for large trace files using zarr format.

Features

• Streaming Support: Large trace data is converted to zarr format with chunking for efficient streaming access
• Caching: Uses Hugging Face cache instead of fsspec cache for better integration
• Zip Compression: Zarr chunks are stored in zip files to minimize file count
• Memory Efficient: Only loads required chunks, not the entire dataset

Dataset Structure

• Labels: 1000 examples with 4 labels each (int32)
• Traces: 1000 examples with 20,971 features each (int8)
• Index: Sequential index for each example

Usage

Local Development

from test import TestDataset

# Load dataset locally
dataset = TestDataset()
dataset.download_and_prepare()
dataset_dict = dataset.as_dataset(split="train")

# Access examples
example = dataset_dict[0]
print(f"Labels: {example['labels']}")
print(f"Traces length: {len(example['traces'])}")

Streaming Usage (for large datasets)

from test import TestDownloadManager, TestDataset

# Initialize streaming dataset
dl_manager = TestDownloadManager()
traces_path = "data/traces.npy"
zarr_zip_path = dl_manager.download_zarr_chunks(traces_path, chunk_size=100)

# Access zarr data efficiently
dataset = TestDataset()
zarr_array = dataset._load_zarr_from_zip(zarr_zip_path)

# Access specific chunks
chunk_data = zarr_array[0:100]  # First chunk

Chunk Selection

# Select specific ranges for training
selected_range = slice(200, 300)
selected_traces = zarr_array[selected_range]
selected_labels = labels[selected_range]

Implementation Details

Custom DownloadManager

The TestDownloadManager extends datasets.DownloadManager to:

• Convert numpy arrays to zarr format with chunking
• Store zarr data in zip files for compression
• Use Hugging Face cache directory
• Support streaming access patterns

Custom Dataset Builder

The TestDataset extends datasets.GeneratorBasedBuilder to:

• Handle both local numpy files and remote zarr chunks
• Provide efficient chunk-based data access
• Maintain compatibility with Hugging Face datasets API

Zarr Configuration

• Format: Zarr v2 (for better fsspec compatibility)
• Chunks: (100, 20971) - 100 examples per chunk
• Compression: ZIP format for the zarr store
• Storage: Hugging Face cache directory

Performance

The zarr-based approach provides:

• Memory efficiency: Only loads required chunks
• Streaming capability: Can work with datasets larger than RAM
• Compression: Zip storage reduces file size
• Cache optimization: Leverages Hugging Face caching mechanism

Requirements

datasets
zarr<3
fsspec
numpy
zipfile36

File Structure

test/
├── data/
│   ├── labels.npy          # Label data (small, kept as numpy)
│   └── traces.npy          # Trace data (large, converted to zarr)
├── test.py                 # Main dataset implementation
├── example_usage.py        # Usage examples
├── requirements.txt        # Dependencies
└── README.md              # This file

Notes

• The original traces.npy is ~20MB, which demonstrates the zarr chunking approach
• For even larger datasets (GB/TB), this approach scales well
• The zarr v2 format is used for better compatibility with fsspec
• Chunk size can be adjusted based on memory constraints and access patterns

Future Enhancements

• Support for multiple splits (train/test/validation)
• Dynamic chunk size based on available memory
• Compression algorithms for zarr chunks
• Metadata caching for faster dataset initialization