Datasets:

amazon
/

armbench-object-identification

---
license: cc-by-4.0
language:
- en
pretty_name: ARMBench Object Identification
tags:
- armbench
- amazon-robotics
- robotic-manipulation
- object-identification
- open-set-recognition
- image-retrieval
- warehouse-automation
task_categories:
- image-classification
- zero-shot-image-classification
- image-feature-extraction
size_categories:
- 100K<n<1M
annotations_creators:
- expert-generated
source_datasets:
- original
---
# ARMBench - Object Identification

This repository is the official Amazon redistribution, on the Hugging Face Hub, of the **object
identification** subset of ARMBench. The payload under `archive/` is Amazon's original release archive,
byte-for-byte; nothing in it has been repacked, resharded or re-encoded.

Project home: <http://armbench.com> &nbsp;|&nbsp; Paper: [arXiv:2303.16382](https://arxiv.org/abs/2303.16382)
&nbsp;|&nbsp; Contact: armbench-support@amazon.com

> **Note on the project website.** `http://armbench.com` is Amazon's canonical home for ARMBench and is
> the URL printed in the paper. At the time of writing the `https://www.armbench.com` certificate has
> expired, so some browsers will warn before showing the site. This has been reported to the ARMBench
> team. The arXiv link above is a non-expiring alternative reference.

**Provenance of the quotations in this card.** Every block quote below was read from the live ARMBench
site on 2026-10-28 and is reproduced verbatim. The quotes come from three different pages, each served
with HTTP 200, and are sourced as follows. The `Tasks > Sparrow > Identification` task page
(`identification.html`) is the source of the task description, the download list and the per-pick
layout. The home page (`index.html`) is the source of the "What is ARMBench?" paragraph, the Sparrow
program description, this subset's home-page card, the release history and the Credits licence
sentence. The contact page (`contactus.html`) is the source of the contact line. One block quote is not
from the website at all: the paper abstract, which is quoted from arXiv:2303.16382 and labelled as such
where it appears. Where this card states a number that is *not* Amazon's, it is labelled "measured" and
the measurement is described. Nothing is paraphrased and attributed to Amazon.

## Dataset Description

The following description is quoted verbatim from Amazon's ARMBench website.

> **What is ARMBench?**
>
> ARMBench is a large-scale benchmark dataset for perception and manipulation challenges across Amazon
> Robotics systems. The datasets are collected in Amazon warehouses and capture a wide variety of objects
> and configurations. They comprise images, videos, and tabular data for different stages of robotic
> manipulation with high-quality annotations.

ARMBench currently includes datasets from two Amazon Robotics programs. This subset belongs to the
**Sparrow Tasks** group, described on the site as:

> Sparrow - Amazon's intelligent robotic system that streamlines the fulfillment process by moving
> individual products before they get packaged. Sparrow is a robotic system in Amazon warehouses that can
> detect, select, and handle individual products in inventory using computer vision and artificial
> intelligence. It focuses on object segmentation, identification, and defect detection, enabling more
> efficient and safer operations while allowing employees to focus on higher-value tasks.

ARMBench documents **five benchmark tasks** and distributes them as **six downloads**: Defect Detection
ships as two separate downloads (images and videos), and the three Object Segmentation subsets ship
inside a single download. This repository is one of those six downloads; the others are published under
the same [`amazon`](https://huggingface.co/amazon) organization with the `armbench-` prefix.

### This subset on the ARMBench home page, verbatim

> **Object Identification:** Open-set object recognition challenge with 200,000+ unique objects.
> Benchmark will evaluate image retrieval and classification methods with uncertainty estimation.

### The object identification task, verbatim

> Object identification (ID) is the task of exactly identifying an image segment as one of the objects
> within a database. In the robotic manipulation context, this task is applicable both before and after
> picking the object. In the pre-pick stage, identifying an object segment within the tote allows
> accessing any stored models or attributes of the object from past experience which can be used for
> manipulation planning purposes. In the post-pick stage, ID has access to the segment of the object
> being manipulated both within the tote as well as when it is attached to the robotic arm.

### What the task page says you need, verbatim

> To evaluate this usecase, please download the following items:
>
> - **Picks:** 235,000 pick activities with images of the picked object in tote and in robotic arm.
> - **Reference-images:** Up to 6 images (1.jpg-6.jpg) corresponding to different product-ids.
> - **Train-Test-Split:** List of training and test cases.

All three of those items ship inside the single archive in this repository; there is no separate
download to assemble.

### The per-pick layout, verbatim

> Each pick activity in the pick directory contains the following:
>
> - Image of the object when it was in the container (PickRGB.jpg)
> - Images of the object after pick (ToteWallRGB.jpg, OnArmLowRGB.jpg, FarTrayRGB.jpg)
> - List of all products in the container before the picking starts. The file contains product-id, text
>   description, weight and dimensions for all the products (container.json)
> - Polygon segments for the object in above images, ground-truth product-id for the object
>   (annotation.json)

The only editorial changes in the four quotations above are of layout. The site renders the download
list and the per-pick layout as styled list items; they are rendered here as Markdown bullets with the
site's own leading labels bolded. The home-page card carries its title, "Object Identification", above
the quoted text; it is rendered here as a bolded lead-in label with a colon added. No word is added,
removed or reordered.

## Dataset Structure

### What this repository contains

| Path | Bytes | Description |
|---|---|---|
| `archive/armbench-object-id-0.1.tar.gz` | 109,039,658,872 | Amazon's original release archive, unmodified |

That is the payload: one archive plus this card. 109,039,658,872 bytes is **101.551 GiB** (109.04 GB),
and that is the exact length of Amazon's release object - the `stat` check further down reproduces it
from your own download.

> **Amazon's 3 MB sample, and why it is not in the table above.** The ARMBench release also contains an
> official sample, `armbench-object-id-tiny.tar.gz` (3,126,329 bytes), holding 5 complete pick
> directories. It is a *separate* object in Amazon's release, so
> it is present in this repository only if the **Files and versions** tab lists it. Check that tab
> before scripting against it; this card deliberately does not assert that it is here. Every structural
> claim in the sections below was measured from that sample, not from the 101.551 GiB archive.

### Why only the tarball, and no extracted file tree

Amazon's own figure is 235,000 pick activities, and each pick directory holds five files (`PickRGB.jpg`,
`ToteWallRGB.jpg`, `OnArmLowRGB.jpg`, `container.json`, `annotation.json`). That is on the order of
**1.2 million files for the picks alone**, before the reference images - up to six per product, over a
product catalogue the home page puts at 200,000+ unique objects.

Hugging Face's Hub limits apply per folder and per repository: a single folder is capped at **10,000
entries**, and the Hub's own guidance is to stay **under about 100,000 files per repository**. An
extracted `Picks/` directory would hold ~235,000 entries in one folder - roughly 23x the per-folder cap -
and the repository as a whole would be more than an order of magnitude past the recommended file count.
So this subset is published exactly as Amazon released it: one gzipped tar, plus the official small
sample. Extract locally and the per-pick tree is yours.

A practical consequence: **there is no dataset viewer on this repository, and that is deliberate.** The
viewer needs a Parquet or CSV table, and this subset ships no tabular file. A `configs:` block pointing
at a path that does not exist would break the viewer rather than populate it, so this card does not
declare one. To inspect the format, extract the archive - or Amazon's 3 MB sample, if the **Files and
versions** tab lists it.

### Archive contents

Measured by listing the official sample archive, `armbench-object-id-tiny.tar.gz` (83 members including
directory entries, 5 picks, listed with `tar -tzvf`). The sample's root directory is
`armbench-object-id-tiny/`; the layout under it is:

- `Picks/<pick_id>/` - one directory per pick activity. `<pick_id>` is a 21-digit numeric string, e.g.
  `004017001665774539482`.
- `Reference_Images/<product_id>/{1.jpg..6.jpg}` - the reference gallery, one directory per product id.
  Product ids are Amazon-style alphanumeric codes, e.g. `B0853996GF`, `X002PQZ5UX`. The count of images
  per product varies and is not always 6, consistent with the site's "up to 6 images".
- `train-test-split.pickle` - the official split, as a **Python pickle** (see the warning below).

This card describes the *sample's* structure because confirming the full archive's member list requires a
single sequential pass over a 101.551 GiB non-seekable gzip stream. That pass was not run here, so no
claim is made about the full archive's exact member count, and none is implied.

### `annotation.json` schema, measured from the sample

A JSON object. Keys are image filenames plus one label key:

| Key | Type | Description |
|---|---|---|
| `PickRGB.jpg` | list of `[x, y]` | Polygon vertices of the picked object's segment in the in-container image |
| `ToteWallRGB.jpg` | list of `[x, y]` | Polygon vertices of the same object in the tote-wall view |
| `OnArmLowRGB.jpg` | list of `[x, y]` | Polygon vertices of the same object in the on-arm view |
| `GT_ID` | string | The ground-truth product id, i.e. the identification target |

The polygons are dense: in the sample's five picks the `PickRGB.jpg` contour runs from 191 to 657
vertices, while the post-pick views are much coarser - 27 to 32 vertices. Expect the in-container segment
to be the detailed one.

### `container.json` schema, measured from the sample

A JSON object mapping **product id to product record** - the manifest of everything in the container
before the pick, which is what makes the pre-pick task a closed-set problem within a container and an
open-set problem across the dataset:

| Key | Type | Description |
|---|---|---|
| *(object key)* | string | Product id, e.g. `B008TYX146` |
| `name` | string | Text description of the product |
| `weight` | float | Product weight. Values in the sample are around 0.045-0.9, consistent with kilograms |
| `dimensions.lengthX` | float | Product extent, values around 0.1-0.4, consistent with metres |
| `dimensions.lengthY` | float | Product extent, same units |
| `dimensions.lengthZ` | float | Product extent, same units |

The site says `container.json` contains "product-id, text description, weight and dimensions"; it does
not state the units. The ranges above are measured from the sample and the unit reading is an inference,
labelled as such. Amazon's site does not publish a units statement for this file.

### The train/test split

The split is `train-test-split.pickle`, a Python pickle at the root of the archive. In the sample archive
it is 354 bytes, pickle protocol 4, and - inspected with `pickletools.dis`, which parses the opcode
stream without executing it - a dictionary with exactly two top-level keys:

| Key | Type | Sample content |
|---|---|---|
| `testset` | list of strings | The 5 pick ids in the sample |
| `testset-objects` | list of strings | 14 product ids |

> **Load this file with care.** Unpickling executes arbitrary code by design; `pickle.load` is not a
> safe reader for a file you downloaded. Inspect it first with `pickletools.dis`, or load it with a
> restricted `Unpickler` that only permits `dict`, `list` and `str`. This is a property of the format
> Amazon chose, not of this redistribution.

The full archive's split file was not opened here, so this card does not state what keys it carries or
how many picks are in each split. The sample contains only test-side keys; do not assume the full file
has the same two keys and nothing else.

### How the benchmark is framed

The task page calls this "exactly identifying an image segment as one of the objects within a database",
and the home page calls it an "open-set object recognition challenge ... with uncertainty estimation".
The pieces the archive gives you map onto that directly: the query is a polygon-cropped segment from
`PickRGB.jpg` (pre-pick) or from `ToteWallRGB.jpg` / `OnArmLowRGB.jpg` (post-pick); the gallery is
`Reference_Images/<product_id>/`; the target is `annotation.json`'s `GT_ID`. Amazon's site does not
publish a scoring script, a metric definition or a baseline checkpoint for this subset, and none is added
here.

## Published figures versus measured figures

Amazon's published figures are given first; figures measured from this exact release follow, labelled as
such. Both are reported rather than silently reconciled.

| Quantity | Amazon's published figure | Measured here |
|---|---|---|
| Pick activities | **235,000** (task page); "235K+ pick-and-place activities" (paper abstract) | Not counted. Counting requires a full sequential pass over the 101.551 GiB gzip stream, which was not run. |
| Unique objects | **200,000+** (home page); "190K+ unique objects" (paper abstract) | Not counted. The two published figures differ from each other; the home page figure is the newer of the two. |
| Download size | Not stated on the task page | **109,039,658,872 bytes** = 101.551 GiB = 109.04 GB, from the release object's exact byte length |
| Post-pick views per pick | `ToteWallRGB.jpg`, `OnArmLowRGB.jpg`, `FarTrayRGB.jpg` (task page) | In the sample archive, **`FarTrayRGB.jpg` is absent**: all 5 picks carry `ToteWallRGB.jpg` and `OnArmLowRGB.jpg` only. Whether the full archive includes the far-tray view was not verified. |
| Reference images per product | "Up to 6 images (1.jpg-6.jpg)" | Confirmed as a range, not a constant: in the sample some products have all six, others fewer. |

The `FarTrayRGB.jpg` gap matters if you plan to train on three post-pick views. Check for the file before
you depend on it, and treat the per-pick view set as variable.

## Verifying what you downloaded

The archive here is byte-identical to Amazon's release object, so the exact byte length is a usable
integrity check:

```bash
hf download amazon/armbench-object-identification \
  archive/armbench-object-id-0.1.tar.gz \
  --repo-type dataset --local-dir ./armbench-object-identification
stat -c %s ./armbench-object-identification/archive/armbench-object-id-0.1.tar.gz
# expected: 109039658872
```

**No SHA-256 is quoted in this card, deliberately.** Amazon published a checksum sidecar alongside some
ARMBench release objects but not, as far as could be verified at the time of writing, alongside this one:
no `.sha256` file accompanies this subset's release object, and a `HeadObject` on the candidate sidecar
key `identification/armbench-object-id-0.1.tar.gz.sha256` in Amazon's release bucket returned HTTP 404 on
2026-10-28. Rather than print a hash this redistribution computed itself and imply Amazon
published it, this card gives the byte length. If you need a strong hash, compute one and compare it with
another downloader.

Format check, 3 MB instead of 101.551 GiB - **only if the Files and versions tab lists the sample**
(it is a separate object in Amazon's release and is not guaranteed to be mirrored here):

```bash
hf download amazon/armbench-object-identification \
  archive/armbench-object-id-tiny.tar.gz \
  --repo-type dataset --local-dir ./armbench-object-identification
mkdir -p ./oid-sample && tar -xzf \
  ./armbench-object-identification/archive/armbench-object-id-tiny.tar.gz -C ./oid-sample
```

## Dataset Creation

The data was collected in Amazon warehouses from a robotic manipulator performing object singulation from
containers with heterogeneous contents, as described in the ARMBench paper:

> This paper introduces Amazon Robotic Manipulation Benchmark (ARMBench), a large-scale, object-centric
> benchmark dataset for robotic manipulation in the context of a warehouse. [...] We present a
> large-scale dataset collected in an Amazon warehouse using a robotic manipulator performing object
> singulation from containers with heterogeneous contents. ARMBench contains images, videos, and metadata
> that corresponds to 235K+ pick-and-place activities on 190K+ unique objects. The data is captured at
> different stages of manipulation, i.e., pre-pick, during transfer, and after placement. Benchmark tasks
> are proposed by virtue of high-quality annotations and baseline performance evaluation are presented on
> three visual perception challenges, namely 1) object segmentation in clutter, 2) object identification,
> and 3) defect detection. ARMBench can be accessed at http://armbench.com

The polygon segments and ground-truth product ids were produced by human annotators. Amazon's website
does not publish the annotation protocol, the annotator population, or inter-annotator agreement, and
this redistribution does not add them.

### Release history, verbatim from the ARMBench website

> **June, 2026:** New benchmark dataset released for Blade Insertion Affordance Prediction, with ~29,000
> cycles of RGBD images and 3D motion trajectories.
>
> **August, 2025:** New benchmark dataset released for Stow Success Prediction, adding a fourth key
> challenge to ARMBench.
>
> **March, 2023:** Benchmark datasets publicly released for 3 key perception challenges in robotic
> manipulation: (a) Object segmentation, (b) Object identification, and (c) Defect detection.
>
> **January, 2023:** The ARMBench research paper has been accepted for presentation at ICRA, 2023.

## Considerations for Using the Data

**Intended use.** Research and benchmarking of open-set object identification - image retrieval,
classification and uncertainty estimation - for robotic manipulation.

**Open set, not closed set.** The point of this subset is that the object catalogue is large and
incomplete. A model that assumes every query maps to a known gallery entry is solving a different
problem. The home page explicitly asks for "uncertainty estimation"; report a reject/abstain behaviour,
not only top-1 accuracy.

**Scope limits.** The images come from one class of Amazon Robotics workcell in Amazon fulfillment
centres, under that facility's lighting, camera placement and object mix. Product ids are Amazon
catalogue identifiers and the catalogue drifts over time. Models trained here should not be assumed to
transfer to other workcells, camera geometries or inventory distributions without re-evaluation.

**Segment quality differs by view.** As measured above, the in-container polygon is dense and the
post-pick polygons are coarse. A model fed raw polygon crops will see systematically different mask
fidelity pre-pick and post-pick.

**Personal and sensitive information.** The images show products being handled inside the robotic
workcell. Amazon's website does not publish a de-identification statement for this subset, and this
redistribution does not add one. If you find content that should not be public, please contact
armbench-support@amazon.com.

## Files in this repository (generated from the uploaded tree)

| Path | Bytes |
|---|---|
| `License-CC-BY.txt` | 18,657 |
| `archive/armbench-object-id-tiny.tar.gz` | 3,126,329 |

The large release archive is listed in the sections above; the files here are the small
companion objects (Amazon's published checksum sidecars, the tiny sample archives, the
official split lists and the released baseline checkpoints), all unmodified.

## Licence and attribution

Quoted verbatim from the ARMBench website's Credits section:

> These datasets are licensed under the Creative Commons Attribution 4.0 International (CC BY 4.0). Use
> the following citations if you use these datasets for publication.

| | |
|---|---|
| Licence | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) (`cc-by-4.0`) |
| Original data credit | Amazon.com, Inc. - ARMBench, <http://armbench.com> |
| Modifications to the media | **None.** `archive/armbench-object-id-0.1.tar.gz` is byte-for-byte identical to Amazon's release object, at 109,039,658,872 bytes. Any sample archive mirrored alongside it is likewise unmodified. |
| Additions | None. This repository adds no derived tables, no Parquet and no baseline checkpoint; it is Amazon's release archive and this card. |
| Further restrictions | None are applied. This redistribution adds no terms beyond CC BY 4.0. |

Attribution is a binding condition of CC BY 4.0. If you use this data, cite the paper below.

## The ARMBench suite on the Hub

ARMBench is distributed as six downloads, each published as its own dataset under the
[`amazon`](https://huggingface.co/amazon) organization so that you can take only the subset you need.
Every one carries the `armbench` tag, so [`datasets?other=armbench`](https://huggingface.co/datasets?other=armbench)
lists the whole family, and they are grouped in the **ARMBench** collection on the organization page.

| Dataset | Program | Task | Download size |
|---|---|---|---|
| [`amazon/armbench-segmentation`](https://huggingface.co/datasets/amazon/armbench-segmentation) | Sparrow | Object segmentation in clutter | 18.5 GiB |
| [`amazon/armbench-object-identification`](https://huggingface.co/datasets/amazon/armbench-object-identification) **(this dataset)** | Sparrow | Open-set object identification | 101.6 GiB |
| [`amazon/armbench-defect-image`](https://huggingface.co/datasets/amazon/armbench-defect-image) | Sparrow | Defect detection, images | 65.7 GiB |
| [`amazon/armbench-defect-video`](https://huggingface.co/datasets/amazon/armbench-defect-video) | Sparrow | Defect detection, videos | 254.0 GiB |
| [`amazon/armbench-stow-success-prediction`](https://huggingface.co/datasets/amazon/armbench-stow-success-prediction) | Vulcan Stow | Stow success prediction | 37.4 GiB |
| [`amazon/armbench-blade-insertion-affordance`](https://huggingface.co/datasets/amazon/armbench-blade-insertion-affordance) | Vulcan Stow | Blade insertion affordance | 555.7 GiB |

The Sparrow subsets are cited with `mitash2023armbench` (below); the two Vulcan Stow subsets are cited
with `hudson2025stow` - see each dataset's own card for its correct citation.

## Citation

```bibtex
@article{mitash2023armbench,
  title     = {ARMBench: An object-centric benchmark dataset for robotic manipulation},
  author    = {Mitash, Chaitanya and Wang, Fan and Lu, Shiyang and Terhuja, Vikedo
               and Garaas, Tyler and Polido, Felipe and Nambi, Manikantan},
  journal   = {arXiv preprint arXiv:2303.16382},
  year      = {2023}
}
```

This is Amazon's published BibTeX entry with one character removed: the version on armbench.com has a
stray comma after `Vikedo`, which makes BibTeX parse the name under its three-part `last, jr, first`
rule and drop Vikedo Terhuja's given name from the rendered reference. The seven authors and their order
are unchanged and match the arXiv metadata for 2303.16382. No `@inproceedings` ICRA entry is given
because arXiv carries no journal reference for this paper and the proceedings citation could not be
verified.

## Contact

Quoted verbatim from the ARMBench website:

> For questions or to provide feedback, please reach out to us at armbench-support@amazon.com

(c) Amazon.com