Ardea/Icarus-dataset

Icarus

A unified multi-modal curriculum dataset for evolutionary neural architecture search. Every row is one self-contained Task = {meta, support, query}, where support and query are lists of (input_Field, output_Field) pairs. The inner loop trains on support; fitness is scored on query. Support is non-empty for every task. Encoders read the Field descriptor (axes, valuetype, nclasses, valuerange, mask); `mask` is True where a value is padding/ignored. `meta.classnames`, when present, names the target classes (e.g. fsd50k sound events); it is viewer/eval metadata only, never read by the loader or encoder, so the dataset stays structural.

Built by the generator repo https://github.com/ArdeaAI/Icarus-Dataset, which also holds the explorer (uv run explore), the build pipeline, and the full reference tooling. This card and the one self-contained file shipped beside the data (icarus.py: the loader plus a reference encoder, no dependencies on this repo) are everything you need.

Rungs (18-rung difficulty ladder; one config rung_<N> each)

split is how support/query is formed: native rungs ship a built-in split (ARC train/test, XOR's degenerate support==query) and the loader keeps it as-is; bucketed rungs are pooled and the loader carves them at load time via support_fraction (so the same data streams at any ratio).

Explorer

Usage

Stream rows (the datasets library only)

Each row is a serialized task. icarus.py (shipped beside the data) reconstructs a whole Task:

from datasets import load_dataset
from icarus import deserialize_task  # the single file shipped with this dataset

stream = load_dataset("Ardea/Icarus-dataset", name="rung_6", streaming=True, split="train")
task = deserialize_task(next(iter(stream)))  # -> Task(meta, support, query)

Vendored loader (whole Task objects, MAXES selection)

from icarus import IcarusDataset

# n_samples is the TOTAL examples per task; support_fraction (bucketed rungs only) sets the support share.
dataset = IcarusDataset(rungs=(3, 6, 18), n_tasks=100, n_samples=50, support_fraction=0.8, hf_repo="Ardea/Icarus_dataset")
task = dataset[0]  # a whole Task split into support/query at load time

Reference encoder (structural Task -> tensors)

The encoder is a swappable reference living in the same icarus.py; a real consuming model brings its own featurization and loss.

from icarus import IcarusDataset, Level0Encoder, encode_task

task = IcarusDataset(rungs=(6,), n_tasks=1, n_samples=20, hf_repo="Ardea/Icarus_dataset")[0]
encoded = encode_task(task, Level0Encoder(max_flat_dim=4096))
# encoded.support_input -> (tensor, descriptor); encoded.support_target -> (tensor, mask, descriptor)

Images are stored as uint8 with value_range (0, 255); the reference encoder normalizes.

Sources, attribution & licensing

Ardea-authored material (the build pipeline, the vendored icarus.py, the schema, and the generated rungs 1-5) is released under the MIT License with Attribution (see LICENSE.md): redistribution must retain the copyright notice and state "This software is based on work originally developed by Ardea AI Corp."

Rungs 6-18 redistribute third-party data, and each source keeps its own upstream license (listed below and in SOURCES.md). You must comply with the upstream license of any rung you use or redistribute. Where a license shows as unknown or - it has not been verified for redistribution; confirm the upstream terms before relying on that rung.