File size: 6,644 Bytes
3e7c150
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
"""Checkpoints and inference of the baselines.

A checkpoint is a directory written by train.py (`<run>/checkpoints/step-NNNNNN/`, `final` links the last one):

- `model.pt`: torch.save of {format, config (the config.json text), state_dict}: the EMA weights (or the raw ones when
  EMA is off) with the policy's state and action normalizers, loaded strictly with `weights_only=True`;
- `config.json`: the policy configuration, the contract (robot, cameras, state and action columns), the image size,
  the training task text, dataset, episodes, recipe and statistics;
- `protocol.json`: model.pt's size and SHA-256.

`BaselinePolicy.predict` takes the live frames of the checkpoint's cameras (any size; resized with data.resize_frame,
as the training cache), the physical state of the contract and a seed, and returns the physical (horizon,
action_dim) chunk with its normalized form; row 0 is the action of the observation's frame.
"""
from __future__ import annotations

import hashlib
import json
from pathlib import Path

import numpy as np

FORMAT = 'hb_baselines/1'


def sha256(path) -> str:
    digest = hashlib.sha256()
    with Path(path).open('rb') as stream:
        for block in iter(lambda: stream.read(16 << 20), b''):
            digest.update(block)
    return digest.hexdigest()


def save_checkpoint(folder, policy, config: dict):
    """Write model.pt, config.json and protocol.json of `policy` (an nn.Module) into `folder`."""
    import torch
    folder = Path(folder)
    folder.mkdir(parents=True, exist_ok=True)
    text = json.dumps(dict(config, format=FORMAT), indent=1)
    state = {k: v.detach().cpu().contiguous() for k, v in policy.state_dict().items()}
    torch.save(dict(format=FORMAT, config=text, state_dict=state), folder / 'model.pt.tmp')
    (folder / 'model.pt.tmp').replace(folder / 'model.pt')
    (folder / 'config.json').write_text(text)
    (folder / 'protocol.json').write_text(json.dumps(dict(
        format=FORMAT, step=config.get('step'), policy=config['policy']['policy'],
        files={'model.pt': dict(bytes=(folder / 'model.pt').stat().st_size, sha256=sha256(folder / 'model.pt'))}),
        indent=1))


def load_checkpoint(folder, device='cpu', verify=True):
    """(policy in eval mode on `device`, config dict) of a checkpoint directory."""
    import torch
    from .policies import build_policy
    folder = Path(folder)
    if verify:
        protocol = json.loads((folder / 'protocol.json').read_text())
        entry = protocol['files']['model.pt']
        if (folder / 'model.pt').stat().st_size != entry['bytes']:
            raise ValueError(f'{folder}/model.pt differs from protocol.json')
    payload = torch.load(folder / 'model.pt', map_location='cpu', weights_only=True)
    if payload.get('format') != FORMAT:
        raise ValueError(f"{folder}: format {payload.get('format')!r}, expected {FORMAT}")
    config = json.loads(payload['config'])
    if json.loads((folder / 'config.json').read_text()) != config:
        raise ValueError(f'{folder}: config.json differs from the one inside model.pt')
    policy = build_policy(config['policy'], pretrained=False)  # every weight comes from model.pt
    policy.load_state_dict(payload['state_dict'], strict=True)
    return policy.to(device).eval(), config


class BaselinePolicy:
    """A loaded checkpoint for closed-loop inference (one request at a time)."""

    def __init__(self, checkpoint, device='cuda:0', policy: str | None = None, robot: str | None = None):
        import torch
        self.torch = torch
        self.device = torch.device(device)
        self.model, self.config = load_checkpoint(checkpoint, device=self.device)
        self.checkpoint = str(Path(checkpoint).resolve())
        name, contract = self.config['policy']['policy'], self.config['contract']
        if policy is not None and name != policy:
            raise ValueError(f'{checkpoint} is a {name!r} checkpoint, not {policy!r}')
        if robot is not None and contract['robot'] != robot:
            raise ValueError(f"{checkpoint} was trained for {contract['robot']!r} ({contract['name']}), not {robot!r}")
        self.name, self.contract = name, contract
        self.cameras = tuple(contract['cameras'])
        self.image_hw = tuple(self.config['image_hw'])
        self.horizon = int(self.config['policy']['horizon'])
        self.state_dim, self.action_dim = int(contract['state_dim']), int(contract['action_dim'])
        self.sampling_steps = int(self.model.sampling_steps)
        self.task_text = self.config.get('task_text')

    def info(self) -> dict:
        return dict(model=self.name, checkpoint=self.checkpoint, step=self.config.get('step'),
                    contract=self.contract['name'], views=list(self.cameras), image_hw=list(self.image_hw),
                    action_chunk=self.horizon, action_dim=self.action_dim, state_dim=self.state_dim,
                    sampling_steps=self.sampling_steps, task_text=self.task_text,
                    training_data=self.config.get('dataset', {}).get('name'))

    def images_tensor(self, images: dict):
        from .data import resize_frame
        missing = [c for c in self.cameras if c not in images]
        if missing:
            raise KeyError(f'missing cameras {missing}; the checkpoint reads {list(self.cameras)}')
        frames = np.stack([resize_frame(np.asarray(images[c]), self.image_hw) for c in self.cameras])
        x = self.torch.from_numpy(frames).to(self.device).permute(0, 3, 1, 2).float().div_(255.)
        return x.unsqueeze(0)  # (1, n_cameras, 3, h, w)

    def predict(self, images: dict, state, seed: int = 0):
        """(action (horizon, action_dim) float32 physical, normalized (horizon, action_dim) float32)."""
        torch = self.torch
        state = np.asarray(state, np.float32).reshape(-1)
        if state.shape != (self.state_dim,) or not np.isfinite(state).all():
            raise ValueError(f'expected a finite state of {self.state_dim} values, got {state.shape}')
        generator = torch.Generator(device=self.device)
        generator.manual_seed(int(seed) % (2 ** 63 - 1))
        with torch.inference_mode():
            action, raw = self.model.predict(self.images_tensor(images),
                                             torch.from_numpy(state)[None].to(self.device), generator=generator)
        action = action[0].float().cpu().numpy()
        if action.shape != (self.horizon, self.action_dim) or not np.isfinite(action).all():
            raise ValueError(f'invalid prediction {action.shape}')
        return np.ascontiguousarray(action, np.float32), raw[0].float().cpu().numpy().astype(np.float32)