| """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_)} |
|
|
