File size: 7,226 Bytes
36b714d | 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 125 126 127 128 129 130 131 132 133 134 135 | """E5 dual causal buffers: confirmed command prefix and prior public decisions.
The caller invokes record_completed only after take_action returns and the public
command counter advances. The cache never infers physical state from commands.
Observe is called at the original 50-command decision boundaries. A reconnect
invalidates both buffers until an explicit episode/session reset.
"""
from collections import deque
import hashlib
import json
from pathlib import Path
import numpy as np
class RolloutCombinedHistory:
def __init__(self, episode_id, output=None, stride=50, session_id=None):
if stride != 50:
raise ValueError('E5 retains the 50-command execution protocol')
self.stride = stride
self.output = Path(output) if output else None
if self.output:
self.output.mkdir(parents=True, exist_ok=True)
self.reset(episode_id, session_id)
def reset(self, episode_id, session_id=None):
if episode_id is None:
raise ValueError('Explicit episode identity required')
self.episode_id = str(episode_id)
self.session_id = None if session_id is None else str(session_id)
self.commands = deque(maxlen=8)
self.completed_commands = 0
self.decisions = []
self.last_fields = None
self.invalidated = False
self.episode_output = None
if self.output:
identity = json.dumps([self.session_id, self.episode_id])
self.episode_output = self.output / hashlib.sha256(identity.encode()).hexdigest()
self.episode_output.mkdir(exist_ok=False)
def invalidate_on_reconnect(self):
self.commands.clear()
self.decisions.clear()
self.last_fields = None
self.invalidated = True
def _check_session(self, session_id):
if self.invalidated:
raise ValueError('Explicit episode reset required after reconnect')
session_id = None if session_id is None else str(session_id)
if session_id != self.session_id:
self.invalidate_on_reconnect()
raise ValueError('Session changed without explicit episode reset')
@staticmethod
def _counter(value):
if isinstance(value, (bool, np.bool_)) or not isinstance(value, (int, np.integer)) or value < 0:
raise ValueError('Expected nonnegative executed command counter')
return int(value)
def record_completed(self, commands, *, before_counter, after_counter, episode_id, session_id=None):
"""Append only commands confirmed by the returned execution interval."""
self._check_session(session_id)
if str(episode_id) != self.episode_id:
raise ValueError('Episode changed without explicit reset')
before, after = self._counter(before_counter), self._counter(after_counter)
values = np.asarray(commands, dtype=np.float32)
if values.ndim != 2 or values.shape[1] != 14 or len(values) == 0 or not np.isfinite(values).all():
raise ValueError('Expected a nonempty finite executed command prefix of shape [N,14]')
if before != self.completed_commands or after-before != len(values):
raise ValueError('Execution confirmation must be contiguous and match the executed prefix')
if not self.decisions or after > self.decisions[-1][0]+self.stride:
raise ValueError('No current decision or command prefix exceeds frozen execution length')
for value in values:
self.commands.append(value.copy())
self.completed_commands = after
def _attach(self, observation):
actions, action_mask, states, state_mask = self.last_fields
return {**observation, 'action_history_raw': {'action': actions.copy()},
'action_history_mask': action_mask.copy(),
'state_history_raw': {'observation.state': states.copy()},
'state_history_mask': state_mask.copy()}
def observe(self, observation, action_counter, call=None, session_id=None):
self._check_session(session_id)
counter = self._counter(action_counter)
state = np.asarray(observation['observation.state'], dtype=np.float32).copy()
if state.shape != (14,) or not np.isfinite(state).all():
raise ValueError('Expected finite 14-dimensional public state; no command proxy substitution')
if counter != self.completed_commands:
raise ValueError('Observation counter differs from confirmed executed prefix')
if self.decisions and counter == self.decisions[-1][0]:
if not np.array_equal(state, self.decisions[-1][1]):
raise ValueError('Public state changed without executed command advance')
return self._attach(observation)
expected = self.decisions[-1][0]+self.stride if self.decisions else 0
if counter != expected:
raise ValueError('Decision interval/reset differs from frozen E5 protocol')
actions = np.zeros((8,14), dtype=np.float32)
action_mask = np.zeros(8, dtype=np.bool_)
if self.commands:
actions[-len(self.commands):] = np.stack(self.commands)
action_mask[-len(self.commands):] = True
states = np.zeros((2,14), dtype=np.float32)
state_mask = np.zeros(2, dtype=np.bool_)
recent = self.decisions[-2:]
for slot, (_, old_state) in enumerate(recent, start=2-len(recent)):
states[slot] = old_state
state_mask[slot] = True
self.last_fields = (actions.copy(), action_mask.copy(), states.copy(), state_mask.copy())
if self.output:
artifact = self.episode_output/('combined_history_%05d.npz' % counter)
np.savez_compressed(artifact, action_history_raw=actions, action_history_mask=action_mask,
state_history_raw=states, state_history_mask=state_mask, current_public_state=state)
with (self.episode_output/'combined_history_audit.jsonl').open('a') as handle:
handle.write(json.dumps(dict(episode_id=self.episode_id, session_id=self.session_id, call=call,
completed_commands=counter, past_decision_counters=[x[0] for x in recent],
valid_action_rows=int(action_mask.sum()), valid_state_rows=int(state_mask.sum()),
action_history_sha256=hashlib.sha256(actions.tobytes()).hexdigest(),
state_history_sha256=hashlib.sha256(states.tobytes()).hexdigest(),
action_source='confirmed executed command prefix; action offset0 normalization',
state_source='prior public observation.state; state normalization; not measured qpos',
history_masks_independent=True))+'\n')
self.decisions.append((counter,state))
self.decisions = self.decisions[-2:]
return self._attach(observation)
def empty_history():
return {'action_history_raw': {'action': np.zeros((8,14),dtype=np.float32)},
'action_history_mask': np.zeros(8,dtype=np.bool_),
'state_history_raw': {'observation.state': np.zeros((2,14),dtype=np.float32)},
'state_history_mask': np.zeros(2,dtype=np.bool_)}
|