metadata

dataset_info:
  features:
    - name: episode_id
      dtype: int64
    - name: goal
      dtype: string
    - name: screenshots_b64
      sequence: string
    - name: actions
      list:
        - name: action_type
          dtype: string
        - name: app_name
          dtype: string
        - name: direction
          dtype: string
        - name: text
          dtype: string
        - name: x
          dtype: int64
        - name: 'y'
          dtype: int64
    - name: step_instructions
      sequence: string
  splits:
    - name: test
      num_bytes: 13222360728
      num_examples: 3051
    - name: train
      num_bytes: 54855940258
      num_examples: 12232
  download_size: 67435592965
  dataset_size: 68078300986
configs:
  - config_name: default
    data_files:
      - split: test
        path: data/test-*
      - split: train
        path: data/train-*

Dataset Card: Android Control Episodes (with Screenshots)

Dataset Summary

This dataset contains Android UI control episodes consisting of:

episode-level metadata (episode_id, goal)
step-by-step instructions (step_instructions)
action sequences (actions as a list of structs)
base64-encoded screenshots per step (screenshots_b64)

Each episode records a short interaction trajectory on an Android device, including what the agent/user attempted to do and how (tap, swipe, text input, etc.).

Supported Tasks and Benchmarks

UI task planning and control
Multimodal grounding (text instructions + UI visual context)
Imitation learning / behavior cloning for mobile agents
Action prediction and trajectory modeling

Languages

Prompts and instructions: English

Dataset Structure

Data Fields

episode_id (int64): Unique identifier of the episode.
goal (string): Natural language description of the objective for the episode.
screenshots_b64 (list[string]): Base64-encoded screenshots captured along the trajectory. Large; dominates file sizes.
actions (list[struct]): Sequence of actions taken. Each element has:
- action_type (string): e.g., "open_app", "click", "swipe", "type".
- app_name (string or null): App associated with the action, if any.
- direction (string or null): For gestures like swipe (e.g., "up", "down").
- text (string or null): Text content for typing actions, if applicable.
- x (int64 or null): X coordinate for tap/click.
- y (int64 or null): Y coordinate for tap/click.
step_instructions (list[string]): Short imperative instructions per step.

Example Instance (images excluded for brevity)

{
  "episode_id": 13,
  "goal": "On cruisedeals, I would like to view the cruise schedules for a four-night trip from New York to Canada.",
  "actions": [
    {"action_type": "open_app", "app_name": "CruiseDeals", "direction": null, "text": null, "x": null, "y": null},
    {"action_type": "click", "app_name": null, "direction": null, "text": null, "x": 313, "y": 742},
    {"action_type": "swipe", "app_name": null, "direction": "up", "text": null, "x": null, "y": null}
  ],
  "step_instructions": [
    "Open the cruisedeals app",
    "Click on the suggested searched result",
    "Swipe up to view schedules"
  ],
  "screenshots_b64": ["<base64>", "<base64>", "<base64>"]
}

Data Splits

train: 12,232 episodes across 275 Parquet shards (1 row group per file)
test: 3,051 episodes across 67 Parquet shards (1 row group per file)

Total compressed size on the Hub is approximately 67.4 GB (train ≈ 54.3 GB, test ≈ 13.1 GB). The screenshots_b64 column contributes the majority of the size.

Typical per-shard stats (example shard):

~45 episodes per shard
~6–7 screenshots per episode on average
~5–6 actions per episode on average
~5–6 step instructions per episode on average

Usage

Load with Datasets (streaming to avoid full download)

from datasets import load_dataset

ds = load_dataset(
    "parquet",
    data_files="hf://datasets/<owner>/<repo>@~parquet/default/train/*.parquet",
    streaming=True,
)["train"]

for i, ex in enumerate(ds):
    ex.pop("screenshots_b64", None)  # skip large images for lightweight inspection
    print(ex["episode_id"], ex["goal"])
    if i >= 4:
        break

Materialize a small slice without streaming

from datasets import load_dataset

small = load_dataset(
    "parquet",
    data_files="hf://datasets/<owner>/<repo>@~parquet/default/train/*.parquet",
    split="train[:1%]",
)
print(len(small))

DuckDB: schema preview and lightweight sampling

import duckdb

# Peek schema of one shard
duckdb.sql("""
DESCRIBE SELECT * FROM
'hf://datasets/<owner>/<repo>@~parquet/default/train/0000.parquet'
""").show()

# Count rows via metadata only (no full scan)
duckdb.sql("""
SELECT SUM(row_group_num_rows) AS total_rows
FROM parquet_metadata('hf://datasets/<owner>/<repo>@~parquet/default/train/*.parquet')
""").show()

# Sample a few rows excluding heavy images
duckdb.sql("""
SELECT episode_id, goal,
       list_length(actions) AS num_actions,
       list_length(step_instructions) AS num_steps
FROM 'hf://datasets/<owner>/<repo>@~parquet/default/train/*.parquet'
LIMIT 10
""").show()

PyArrow: footer-only metadata or row-group reads

from huggingface_hub import HfFileSystem
import pyarrow.parquet as pq

fs = HfFileSystem()
path = "hf://datasets/<owner>/<repo>@~parquet/default/train/0000.parquet"

# Metadata-only: schema & row groups
with fs.open(path, "rb") as f:
    pf = pq.ParquetFile(f)
    print(pf.schema_arrow)
    print(pf.metadata.num_rows, pf.num_row_groups)

# Read a single row group without images
with fs.open(path, "rb") as f:
    pf = pq.ParquetFile(f)
    cols = [c for c in pf.schema_arrow.names if c != "screenshots_b64"]
    tbl = pf.read_row_group(0, columns=cols)
    print(tbl.slice(0, 3).to_pydict())

Dask: predicate/projection pushdown

import dask.dataframe as dd

ddf = dd.read_parquet(
    "hf://datasets/<owner>/<repo>@~parquet/default/train/*.parquet",
    columns=["episode_id", "goal", "actions", "step_instructions"],
)
print(ddf.head())

Efficiency Tips

Prefer streaming or column selection to avoid downloading screenshots_b64 unless needed.
Use DuckDB parquet_metadata(...) or PyArrow ParquetFile(...).metadata to inspect sizes/counts without reading data pages.
Each file has one row group; shard-level parallelism is straightforward.

Licensing

[More Information Needed]

Citation

If you use this dataset in your work, please cite the source dataset/creators as appropriate and this repository. Example placeholder:

@misc{android_control_episodes,
  title  = {Android Control Episodes Dataset},
  year   = {2025},
  url    = {https://huggingface.co/datasets/smolagents/android-control}
}

Limitations and Risks

Screenshots are stored as base64 strings and can be large; consider storage and memory implications.
Some action fields (e.g., app_name, direction, text) may be null for many steps.
Visual UI elements may vary across Android versions/devices.

Maintainers

[more information needed]