jaybhagiya/FAST-assembly-labels

FAST Assembly Feasibility Labels

Physics-simulation labels for disassembly actions on 2,131 assemblies from the Fusion 360 Gallery assembly dataset, in the processed form distributed with ASAP. Each action removes one part along one of six directions. Each action has a removability label R and a joint feasibility label Y. Each removed part has a post-removal stability label T. The labels were used to train and evaluate FAST, a Graph Transformer that ranks actions for physically feasible assembly sequence planning.

This dataset is a modified portion of the Fusion 360 Gallery Dataset. It contains labels, states, stable poses, and splits only. It contains no meshes, no CAD geometry, no features, and no planner results. Use is restricted to non-commercial research; see LICENSE.md.

• Code: https://github.com/ZeMA-gGmbH/FAST (release v2.0.0)
• Geometry: the ASAP assembly dataset, https://github.com/yunshengtian/ASAP ("Assembly dataset")
• Meshes and contact graphs of exactly these assemblies: jaybhagiya/FAST-assembly-meshes

Contents

Table	Rows	One row per
assemblies	2,132 (2,131 included, 1 excluded)	assembly
candidates	126,123	part removal attempt: state, stable pose, removed part
actions	756,738	action: candidate and one of six directions

Split	Assemblies	Small	Medium	Large	Candidates	Actions
train	1,703	1,036	576	91	98,969	593,814
validation	191	115	65	11	9,610	57,660
test	237	20	128	89	17,544	105,264
excluded	1	0	1	0	0	0

Each table has one configuration. Its Hugging Face splits are the dataset splits; the column dataset_split repeats the split.

from datasets import load_dataset

actions = load_dataset("jaybhagiya/FAST-assembly-labels", "actions", split="train")
candidates = load_dataset("jaybhagiya/FAST-assembly-labels", "candidates", split="train")

Files:

• data/<table>/<split>.parquet: the tables (zstd-compressed Parquet).
• manifest.json, profile.json: the manifest and the label statistics of the JSON Lines index, release fast-labels-v1.
• convert_index.py: converts between Parquet and the JSON Lines index used by the code (needs pyarrow).
• SHA256SUMS: SHA-256 of every file.

The FAST code reads the JSON Lines index. To rebuild it byte for byte:

python convert_index.py restore --dataset-dir . --index-dir datasets/fast-labels-v1

The command checks the row counts and the SHA-256 of each rebuilt file against manifest.json. The column index_row keeps the original line order.

Problem setting

A state is the set of parts that are still assembled, in their assembled positions. The remaining parts rest on a horizontal support plane in one of at most three stable poses of their combined geometry. A candidate is a state, a pose, and one part to be removed. An action removes that part in a straight line along one of six world-frame directions +X, -X, +Y, -Y, +Z, -Z, after the pose is applied; +Z points away from the plane. A complete disassembly removes one part per step until one part is left; reversed, it is an assembly sequence.

Label semantics

Every label is true, false, or null. null (⊥) means unresolved: the check reached its wall-clock limit or was not run. Unresolved labels are kept. The *_valid columns mark resolved labels; the *_status and *_reason columns say why a label is what it is.

R, directional removability (per action). All other remaining parts are held fixed. Gravity and friction are off. The part receives a constant, mass-independent acceleration of 100 cm/s² along the direction, in time steps of 1 ms. Every 100 steps its velocity is reset to zero.

R	R_status	R_reason	Meaning
true	success	disassembled	the part separated: at least 0.5 cm from every other part
false	blocked	stalled	contacts stopped it: mean acceleration over 100 steps below 1 cm/s²
null	timeout	timeout	no decision within 60 s wall clock

T, post-removal stability (per candidate, the same for all six directions). The part is removed, and the remaining parts are placed in the pose on the support plane under gravity (0, 0, −9.8) cm/s², about 1% of Earth gravity, for 1,000 steps of 1 ms. A part fails if it moves more than 0.2 cm or moves 0.1 cm away from a part it touched at the start; a part without any initial contact fails at once. ASAP's greedy procedure then holds the heaviest failing part of each touching group and repeats. Stability may use at most one held part; with the gripper that removes the part, this is at most two grippers.

T	T_status	T_reason	T_queried	Meaning
true	success	stable	true	stable with at most one held part
false	unstable	max_fix_exceeded	true	would need more than one held part
null	timeout	stability_timeout	true	no decision within 900 s wall clock
null	not_evaluated	no_proven_removable_direction	false	not checked, because no direction had R = true

Y, joint feasibility (per action): the action is feasible if the part can be removed and the remainder is stable.

Y	Y_status	Rule
false	blocked	R = false
false	unstable	R = true and T = false
true	success	R = true and T = true
null	timeout	R or T unresolved, and neither is false

Label counts over all splits (positive share among resolved labels):

Label	true	false	null	positive share
R (per action)	394,756	357,839	4,143	52.5%
T (per candidate)	57,093	50,878	18,152	52.9%
Y (per action)	210,451	537,955	8,332	28.1%

profile.json gives the counts per split and per split and size tier.

Simulator and units

The labels come from the RedMax-based simulator of ASAP, unchanged. RedMax has no built-in units. The ASAP assets use centimetres, with each assembly scaled so that its largest dimension is at most 10 cm, and time is in seconds. Every part has density 1. The stability gravity, 9.8 cm/s², is ASAP's default and about 1% of Earth gravity. The stability label is therefore a simulator criterion, not a physical stability guarantee: within the 1 s check, slow tipping or sliding can pass as stable. Stable poses come from trimesh stable-pose estimation: the most probable poses, at most three, until their cumulative probability exceeds 0.9. If no pose is found, the assembled orientation is used, and pose and pose_probability are null (138 candidates).

Label search per size tier

The labels come from a search over the states of each assembly, starting from the finished product. A removal attempt checks one part of one state in each of its poses. The next state is added only after a feasible removal (Y = true in some direction and pose). The search depends on the size tier:

• Small (3–6 parts): every reachable state is visited in breadth-first order, and every part of every state is attempted. The labels cover the complete disassembly tree.
• Medium (7–20 parts): one path first follows ASAP's outside-in part order down from the finished product. The remaining attempts alternate between a random untried part in the shallowest open state and the next outside-in part in the deepest open state. The search stops after 2(N−1) attempts for N parts or after one hour of simulation.
• Large (21–70 parts): ASAP's depth-first search with the outside-in order. It follows the first feasible removal and backtracks when a state has no removable part. It stops when one part is left or after 400 attempts.

complete_sequence_found says whether the search reached a complete disassembly (1,370 of 2,131 assemblies, 64.3%). It describes how far the search reached, not whether an assembly can be solved.

Columns

assemblies

Column	Type	Description
assembly_id	string	ASAP assembly folder name, e.g. 00014
source_split	string	ASAP folder: training_assembly or test_assembly
dataset_split	string	train, validation, test, or excluded
included	bool	false only for the excluded assembly
exclusion_reason	string	why an assembly is excluded, else null
tier	string	small, medium, or large
part_count	int64	number of parts N
input_sha256	string	hash of the ASAP input files (see below)
candidate_count	int64	candidates of this assembly
complete_sequence_found	bool	the label search reached a single part
audit_status	string	passed, or review_required when the search did not meet every coverage target of its tier (for example, no complete sequence in a large assembly, unresolved labels, or the orphan states below). All rows passed the integrity checks.
orphan_state_checkpoints	list	state IDs with an interrupted, unused search checkpoint; their labels are not in the index
schema_version	string	row schema
index_row	int64	line number in the JSON Lines file

candidates

Column	Type	Description
candidate_id	string	<source_split>:<assembly_id>:<state_id>:<pose_id>:<part_move>
assembly_id, source_split, input_sha256, tier, dataset_split		as in assemblies
assembly_part_count	int64	N
state_id	string	hash-based ID of the set of remaining parts
parts	list	remaining parts before the removal (OBJ file stems)
parts_after	list	remaining parts after the removal
state_part_count	int64	number of parts in parts
depth	int64	parts already removed: N − state_part_count
part_move	string	the part to be removed
pose_id, pose_index	string, int64	stable pose of the state (pose-000 … pose-002)
pose	list<list>	4×4 homogeneous transform applied to the assembled parts, or null
pose_probability	double	stable-pose probability from trimesh, or null
T, T_status, T_reason, T_queried, T_valid		stability label (see above); T_valid = queried and resolved
schema_version, index_row		as above

actions

Column	Type	Description
action_id	string	<candidate_id>:<direction_id>
candidate_id	string	joins to candidates
dataset_split	string	as above
direction_id	string	+X, -X, +Y, -Y, +Z, or -Z
direction	list	unit vector in the world frame
R, R_status, R_reason, R_valid		removability label (see above)
Y, Y_status, Y_valid		joint feasibility label (see above)
schema_version, index_row		as above

Geometry

Download the ASAP training and test sets from the ASAP repository. An assembly's parts are <source_split>/<assembly_id>/<part>.obj, and its contacts are in contact_graph.json. input_sha256 identifies the exact input: for each *.obj, contact_graph.json, and config.json present in the folder, sorted by name, it hashes name, a zero byte, the file's SHA-256 in hex, and a newline. The function _hash_assembly in the FAST code computes it. Use the original meshes, not the subdivided ones.

Splits

• test: the ASAP test set.
• validation: a random tenth of the ASAP training set (seed 0), stratified by part-count bins.
• train: the rest of the ASAP training set.
• Assemblies with identical input files (input_sha256) are kept in the same split. The one test assembly that duplicated a training assembly (test_assembly/07386 = training_assembly/07385) is kept here with dataset_split = excluded, and it has no candidates or actions.
• Fourteen ASAP assemblies are absent (twelve training, two test), because the simulator crashed on them on every attempt.

ASAP provides 1,906 training and 240 test assemblies. Without the 14 crashing assemblies and the duplicate, 2,131 remain.

Intended use

Training and evaluating models that predict removability, stability, or feasibility of disassembly actions, or that rank actions for assembly sequence planning, for non-commercial research. In the FAST thesis, training data fit the model and the feature normalisation, validation data select models, and the test labels served only an offline check of prediction quality; planning was evaluated in simulation.

Limitations

• Coverage. Small assemblies have complete trees. Medium and large assemblies have labels only for the states that the outside-in searches reached. A context therefore often holds only a few attempted parts, and a ranking across parts can be assessed mainly on small assemblies.
• Unresolved labels. About 0.5% of R, 14.4% of T, and 1.1% of Y labels are null. Most null T labels (16,049 of 18,152) belong to parts without a removable direction. Treat null as censored, not as false.
• Simulator criterion. The labels follow ASAP's simulator and settings: straight-line motions along six axes, at most one held part, reduced gravity, and wall-clock limits. They are not physical guarantees.
• Single CAD source. All assemblies come from the Fusion 360 Gallery and are normalised to 10 cm. The test split has mostly medium and large assemblies, unlike the training split.
• Imbalance. Feasible actions are a minority (28.1%) and become rare in large assemblies.

Citation

If you use this dataset, please cite the thesis and the source datasets:

@mastersthesis{bhagiya2026fast,
  author = {Bhagiya, Jaykumar},
  title  = {Feasibility Aware Assembly Sequence Planning using Graph Transformer},
  school = {Saarland University},
  year   = {2026}
}

@inproceedings{tian2024asap,
  author    = {Tian, Yunsheng and Willis, Karl D. D. and Al Omari, Bassel and Luo, Jieliang and Ma, Pingchuan and Li, Yichen and Javid, Farhad and Gu, Edward and Jacob, Joshua and Sueda, Shinjiro and Li, Hui and Chitta, Sachin and Matusik, Wojciech},
  title     = {{ASAP}: Automated Sequence Planning for Complex Robotic Assembly with Physical Feasibility},
  booktitle = {2024 IEEE International Conference on Robotics and Automation (ICRA)},
  pages     = {4380--4386},
  year      = {2024},
  doi       = {10.1109/ICRA57147.2024.10611595}
}

@inproceedings{willis2022joinable,
  author    = {Willis, Karl D. D. and Jayaraman, Pradeep Kumar and Chu, Hang and Tian, Yunsheng and Li, Yifei and Grandi, Daniele and Sanghi, Aditya and Tran, Linh and Lambourne, Joseph G. and Solar-Lezama, Armando and Matusik, Wojciech},
  title     = {{JoinABLe}: Learning Bottom-up Assembly of Parametric {CAD} Joints},
  booktitle = {2022 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
  pages     = {15828--15839},
  year      = {2022},
  doi       = {10.1109/CVPR52688.2022.01539}
}

The FAST method was published in:

@article{xu2026cats,
  author  = {Xu, Xiaomei and Bhagigya, Jaykumar and Schneider, Marco and M{\"u}ller, Rainer},
  title   = {A Physical Feasibility-Aware Sequence Planner for Robotic Assembly-Picking Systems},
  journal = {Procedia CIRP},
  volume  = {147},
  pages   = {266--271},
  year    = {2026},
  doi     = {10.1016/j.procir.2026.02.149}
}

@inproceedings{xu2026iros,
  author    = {Xu, Xiaomei and Bhagiya, Jaykumar and Schneider, Marco and M{\"u}ller, Rainer},
  title     = {{FAST}: Action-Aware Feasibility in Assembly Sequence Planning using {Graph Transformer}},
  booktitle = {2026 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)},
  year      = {2026},
  note      = {Accepted, to appear}
}