File size: 3,783 Bytes
578663d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 | """Grader for the nut_thread scene: every nut seated on a bolt.
Rubric stages (weights and modes live in RUBRIC), each a fraction over that env's nuts:
lifted nuts ever raised to the bolt-top rest height — origin at/above `bolt_height`
in the nearest bolt's frame, the height the scene quotes for a nut resting on
the bolt top and so the height a nut has to clear before it can be set on the
bolt — or already aligned on a bolt (a nut on the bolt was necessarily lifted
there); a milestone, latched per nut
aligned nuts aligned on a bolt — within `align_xy` of the bolt axis and tilted at most
`align_axis_deg` off it, the scene's own two non-depth seat gates
threaded mean thread depth from the bolt-top rest height (`bolt_height`) down to the
seat (`seat_z`), counted only while aligned — so a nut's value is 1.0 iff the
scene calls it seated
The rungs nest (seated => aligned => lifted), so progress reaches 1.0 exactly when every
nut of the env is seated, and for a grader built after the pick as well as one that watched
it. Success is the scene's `seated()` per env, read when the delivery finishes.
"""
from __future__ import annotations
import math
from robobench.core import BaseGrader
from robobench.suites.assembly.scenes.nut_thread_assembly import NutThreadAssemblyScene
class NutThreadAssemblyGrader(BaseGrader):
"""Every nut seated — threaded down to seat depth, on the bolt axis, upright.
Ladder: lifted 0.33 · aligned 0.67 · threaded 1.00 — three equal rungs for the three
steps of the task (pick the nut up, set it on the bolt, screw it down); the last rung
is a linear ramp of the nut's height from the bolt-top rest height (`bolt_height`) to
the seat (`seat_z`). With N nuts every stage is the fraction of nuts.
"""
SCENE = NutThreadAssemblyScene
RUBRIC = (("lifted", 1, "once"), ("aligned", 1), ("threaded", 1))
scene: NutThreadAssemblyScene
def setup(self) -> None:
import torch
z, _, _ = self._on_bolt()
self._lifted = torch.zeros_like(z, dtype=torch.bool) # per-nut latch: ever lifted
def check_success(self):
return self.scene.seated().all(dim=1) # (num_envs,) — every nut of that env
def _on_bolt(self):
"""(height, aligned, thread), each (num_envs, num_nuts): the nut origin's height
above its nearest bolt's origin, whether it passes the scene's xy + tilt seat gates,
and its thread-depth fraction from the bolt-top rest height to the seat."""
import torch
c = self.scene.cfg
off = self.scene._nut_offsets_in_bolt() # (n, N_nut, B_bolt, 3) — privileged read
near_dist, near = off[..., :2].norm(dim=-1).min(dim=-1)
z = torch.gather(off[..., 2], 2, near.unsqueeze(-1)).squeeze(-1)
aligned = (near_dist <= c.align_xy) & (
self.scene._nut_axis_cos() >= math.cos(math.radians(c.align_axis_deg)))
thread = ((c.bolt_height - z) / (c.bolt_height - c.seat_z)).clamp(0.0, 1.0)
return z, aligned, thread
# ---- rubric stages — each returns a (num_envs,) fraction over that
# env's nuts -------------------------------------------------------------
def lifted(self):
z, aligned, _ = self._on_bolt()
self._lifted |= (z >= self.scene.cfg.bolt_height) | aligned
return self._lifted.float().mean(dim=1)
def aligned(self):
_, aligned, _ = self._on_bolt()
return aligned.float().mean(dim=1)
def threaded(self):
_, aligned, thread = self._on_bolt()
return (aligned * thread).mean(dim=1)
|