| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| """ |
| Example: |
| ```shell |
| python src/lerobot/scripts/server/policy_server.py \ |
| --host=127.0.0.1 \ |
| --port=8080 \ |
| --fps=30 \ |
| --inference_latency=0.033 \ |
| --obs_queue_timeout=1 |
| ``` |
| """ |
|
|
| import logging |
| import os |
| import pickle |
| import threading |
| import time |
| from concurrent import futures |
| from dataclasses import asdict |
| from pathlib import Path |
| from pprint import pformat |
| from queue import Empty, Queue |
|
|
| import draccus |
| import grpc |
| import torch |
|
|
| from lerobot.common.policies.factory import get_policy_class |
| from lerobot.scripts.server.configs import PolicyServerConfig |
| from lerobot.scripts.server.constants import SUPPORTED_POLICIES |
| from lerobot.scripts.server.helpers import ( |
| FPSTracker, |
| Observation, |
| RemotePolicyConfig, |
| TimedAction, |
| TimedObservation, |
| get_logger, |
| observations_similar, |
| raw_observation_to_observation, |
| ) |
| from lerobot.common.transport import ( |
| services_pb2, |
| services_pb2_grpc, |
| ) |
| from lerobot.common.transport.utils import receive_bytes_in_chunks |
|
|
|
|
| class PolicyServer(services_pb2_grpc.AsyncInferenceServicer): |
| prefix = "policy_server" |
| logger = get_logger(prefix) |
|
|
| def __init__(self, config: PolicyServerConfig): |
| self.config = config |
| self.shutdown_event = threading.Event() |
|
|
| |
| |
| self.fps_tracker = FPSTracker(target_fps=config.fps) |
| |
| |
| self.observation_queue = Queue(maxsize=1) |
|
|
| self._predicted_timesteps_lock = threading.Lock() |
| self._predicted_timesteps = set() |
|
|
| self.last_processed_obs = None |
|
|
| |
| self.device = None |
| self.policy_type = None |
| self.lerobot_features = None |
| self.actions_per_chunk = None |
| self.policy = None |
|
|
| @property |
| def running(self): |
| |
| return not self.shutdown_event.is_set() |
|
|
| @property |
| def policy_image_features(self): |
| |
| return self.policy.config.image_features |
|
|
| def _reset_server(self) -> None: |
| """Flushes server state when new client connects.""" |
| |
| self.shutdown_event.set() |
| self.observation_queue = Queue(maxsize=1) |
|
|
| with self._predicted_timesteps_lock: |
| self._predicted_timesteps = set() |
|
|
| def Ready(self, request, context): |
| client_id = context.peer() |
| self.logger.info(f"Client {client_id} connected and ready") |
| self._reset_server() |
| self.shutdown_event.clear() |
|
|
| return services_pb2.Empty() |
|
|
| def SendPolicyInstructions(self, request, context): |
| """Receive policy instructions from the robot client""" |
|
|
| if not self.running: |
| |
| self.logger.warning("Server is not running. Ignoring policy instructions.") |
| return services_pb2.Empty() |
|
|
| client_id = context.peer() |
|
|
| policy_specs = pickle.loads(request.data) |
|
|
| if not isinstance(policy_specs, RemotePolicyConfig): |
| |
| raise TypeError(f"Policy specs must be a RemotePolicyConfig. Got {type(policy_specs)}") |
|
|
| if policy_specs.policy_type not in SUPPORTED_POLICIES: |
| raise ValueError( |
| f"Policy type {policy_specs.policy_type} not supported. " |
| f"Supported policies: {SUPPORTED_POLICIES}" |
| ) |
|
|
| self.logger.info( |
| f"Receiving policy instructions from {client_id} | " |
| f"Policy type: {policy_specs.policy_type} | " |
| f"Pretrained name or path: {policy_specs.pretrained_name_or_path} | " |
| f"Actions per chunk: {policy_specs.actions_per_chunk} | " |
| f"Device: {policy_specs.device}" |
| ) |
|
|
| self.device = policy_specs.device |
| self.policy_type = policy_specs.policy_type |
| self.lerobot_features = policy_specs.lerobot_features |
| self.actions_per_chunk = policy_specs.actions_per_chunk |
| self.rtc_enabled = bool(getattr(policy_specs, "rtc_enabled", False)) |
|
|
| |
| start = time.perf_counter() |
| if self.policy_type == "smolvla" and Path(policy_specs.pretrained_name_or_path).is_dir(): |
| from lerobot.scripts.server.rm65_ckpt import load_smolvla_for_server |
|
|
| self.policy = load_smolvla_for_server( |
| policy_specs.pretrained_name_or_path, self.device |
| ) |
| else: |
| policy_class = get_policy_class(self.policy_type) |
| self.policy = policy_class.from_pretrained(policy_specs.pretrained_name_or_path) |
| self.policy.to(self.device) |
| if self.rtc_enabled: |
| if self.policy_type != "smolvla": |
| raise ValueError(f"RTC is wired for smolvla, got {self.policy_type}") |
| from lerobot.scripts.server.rm65_rtc import enable_smolvla_rtc |
|
|
| enable_smolvla_rtc( |
| self.policy, |
| num_steps=int(getattr(policy_specs, "rtc_num_steps", 4)), |
| execution_horizon=int(getattr(policy_specs, "rtc_execution_horizon", 13)), |
| max_guidance_weight=float(getattr(policy_specs, "rtc_max_guidance_weight", 10.0)), |
| ckpt_dir=policy_specs.pretrained_name_or_path, |
| ) |
| chunk = int(self.policy.config.chunk_size) |
| if self.actions_per_chunk < chunk: |
| self.logger.info( |
| "RTC returns the full chunk (%s); client asked for %s", |
| chunk, |
| self.actions_per_chunk, |
| ) |
| self.actions_per_chunk = chunk |
| end = time.perf_counter() |
| self.logger.info("policy loaded and put on device (%.2fs)", end - start) |
|
|
| return services_pb2.Empty() |
|
|
| def SendObservations(self, request_iterator, context): |
| """Receive observations from the robot client""" |
| |
| client_id = context.peer() |
| |
|
|
| receive_time = time.time() |
| start_deserialize = time.perf_counter() |
| |
| received_bytes = receive_bytes_in_chunks( |
| request_iterator, None, self.shutdown_event, self.logger |
| ) |
| |
| timed_observation = pickle.loads(received_bytes) |
| |
|
|
| deserialize_time = time.perf_counter() - start_deserialize |
|
|
| |
| |
|
|
| obs_timestep = timed_observation.get_timestep() |
| obs_timestamp = timed_observation.get_timestamp() |
|
|
| |
| fps_metrics = self.fps_tracker.calculate_fps_metrics(obs_timestamp) |
|
|
| |
| |
| |
| |
| self.logger.info( |
| f"Received observation #{obs_timestep} | " |
| f"Avg FPS: {fps_metrics['avg_fps']:.2f} | " |
| f"Target: {fps_metrics['target_fps']:.2f} | " |
| f"One-way latency: {(receive_time - obs_timestamp) * 1000:.2f}ms" |
| ) |
|
|
| |
| |
| |
| |
| |
|
|
| if not self._enqueue_observation( |
| timed_observation |
| ): |
| |
| self.logger.info(f"Observation #{obs_timestep} has been filtered out") |
|
|
| return services_pb2.Empty() |
|
|
| def GetActions(self, request, context): |
| """Returns actions to the robot client. Actions are sent as a single |
| chunk, containing multiple actions.""" |
| |
| client_id = context.peer() |
| self.logger.debug(f"Client {client_id} connected for action streaming") |
|
|
| |
| try: |
| getactions_starts = time.perf_counter() |
| |
| obs = self.observation_queue.get(timeout=self.config.obs_queue_timeout) |
| self.logger.info( |
| f"Running inference for observation #{obs.get_timestep()} (must_go: {obs.must_go})" |
| ) |
|
|
| with self._predicted_timesteps_lock: |
| self._predicted_timesteps.add(obs.get_timestep()) |
|
|
| |
| start_time = time.perf_counter() |
| |
| |
| action_chunk = self._predict_action_chunk(obs) |
| |
| inference_time = time.perf_counter() - start_time |
|
|
| |
| start_time = time.perf_counter() |
| actions_bytes = pickle.dumps(action_chunk) |
| serialize_time = time.perf_counter() - start_time |
|
|
| |
| actions = services_pb2.Actions(data=actions_bytes) |
|
|
| self.logger.info( |
| f"Action chunk #{obs.get_timestep()} generated | " |
| f"Total time: {(inference_time + serialize_time) * 1000:.2f}ms" |
| ) |
|
|
| self.logger.debug( |
| f"Action chunk #{obs.get_timestep()} generated | " |
| f"Inference time: {inference_time:.2f}s |" |
| f"Serialize time: {serialize_time:.2f}s |" |
| f"Total time: {inference_time + serialize_time:.2f}s" |
| ) |
|
|
| time.sleep( |
| max(0, self.config.inference_latency - max(0, time.perf_counter() - getactions_starts)) |
| ) |
|
|
| return actions |
|
|
| except Empty: |
| return services_pb2.Empty() |
|
|
| except Exception as e: |
| self.logger.error(f"Error in StreamActions: {e}") |
|
|
| return services_pb2.Empty() |
|
|
| def _obs_sanity_checks(self, obs: TimedObservation, previous_obs: TimedObservation) -> bool: |
| """Check if the observation is valid to be processed by the policy""" |
| with self._predicted_timesteps_lock: |
| predicted_timesteps = self._predicted_timesteps |
|
|
| |
| if obs.get_timestep() in predicted_timesteps: |
| self.logger.debug(f"Skipping observation #{obs.get_timestep()} - Timestep predicted already!") |
| return False |
| |
| elif os.environ.get("RM65_SKIP_SIMILAR_OBS", "0").lower() not in ( |
| "1", |
| "true", |
| "yes", |
| ) and observations_similar(obs, previous_obs, lerobot_features=self.lerobot_features): |
| self.logger.info("Similar observation detected, skipping processing.") |
| self.logger.debug( |
| f"Skipping observation #{obs.get_timestep()} - Observation too similar to last obs predicted!" |
| ) |
| return False |
|
|
| else: |
| return True |
|
|
| def _enqueue_observation(self, obs: TimedObservation) -> bool: |
| """Enqueue an observation if it must go through processing, otherwise skip it. |
| Observations not in queue are never run through the policy network""" |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| |
| if ( |
| obs.must_go |
| or self.last_processed_obs is None |
| or self._obs_sanity_checks(obs, self.last_processed_obs) |
| ): |
| last_obs = self.last_processed_obs.get_timestep() if self.last_processed_obs else "None" |
| self.logger.debug( |
| f"Enqueuing observation. Must go: {obs.must_go} | Last processed obs: {last_obs}" |
| ) |
|
|
| |
| if self.observation_queue.full(): |
| |
| _ = self.observation_queue.get_nowait() |
| self.logger.debug("Observation queue was full, removed oldest observation") |
|
|
| |
| self.observation_queue.put(obs) |
| self.logger.info("successfully enqueued observation") |
| return True |
|
|
| return False |
|
|
| def _time_action_chunk(self, t_0: float, action_chunk: list[torch.Tensor], i_0: int) -> list[TimedAction]: |
| """Turn a chunk of actions into a list of TimedAction instances, |
| with the first action corresponding to t_0 and the rest corresponding to |
| t_0 + i*environment_dt for i in range(len(action_chunk)) |
| """ |
| return [ |
| TimedAction(timestamp=t_0 + i * self.config.environment_dt, timestep=i_0 + i, action=action) |
| for i, action in enumerate(action_chunk) |
| ] |
|
|
| def _prepare_observation(self, observation_t: TimedObservation) -> Observation: |
| """ |
| Prepare observation, ready for policy inference. |
| E.g.: To keep observation sampling rate high (and network packet tiny) we send int8 [0,255] images from the |
| client and then convert them to float32 [0,1] images here, before running inference. |
| """ |
| |
| observation: Observation = raw_observation_to_observation( |
| observation_t.get_observation(), |
| self.lerobot_features, |
| self.policy_image_features, |
| self.device, |
| ) |
| |
| from lerobot.common.constants import OBS_STATE |
|
|
| if OBS_STATE in observation and self.policy is not None: |
| want = None |
| try: |
| want = int(self.policy.config.robot_state_feature.shape[0]) |
| except Exception: |
| want = None |
| state = observation[OBS_STATE] |
| if want is not None and state.shape[-1] > want: |
| observation[OBS_STATE] = state[..., :want] |
|
|
| return observation |
|
|
| def _rtc_call_kwargs(self, observation_t: TimedObservation) -> dict: |
| """Leftover prefix for guided RTC. Empty when this is the first chunk.""" |
| if not getattr(self, "rtc_enabled", False): |
| return {} |
| leftover = observation_t.rtc_prev_chunk_left_over |
| delay = int(observation_t.rtc_inference_delay or 0) |
| if leftover is None or delay <= 0 or leftover.numel() == 0: |
| return {} |
| chunk = int(self.policy.config.chunk_size) |
| if leftover.ndim == 3: |
| leftover = leftover[0] |
| if delay >= chunk - 1 or leftover.shape[0] < 2: |
| self.logger.warning( |
| "RTC skip guidance delay=%s leftover=%s chunk=%s", |
| delay, |
| tuple(leftover.shape), |
| chunk, |
| ) |
| return {} |
| delay = min(delay, int(leftover.shape[0])) |
| horizon = int(self.policy.config.rtc_config.execution_horizon) |
| horizon = min(chunk - 1, max(horizon, delay + 2)) |
| self.logger.info( |
| "RTC guide delay=%s horizon=%s leftover=%s", |
| delay, |
| horizon, |
| tuple(leftover.shape), |
| ) |
| return { |
| "prev_chunk_left_over": leftover, |
| "inference_delay": delay, |
| "execution_horizon": horizon, |
| } |
|
|
| def _get_action_chunk(self, observation: dict[str, torch.Tensor], rtc_kwargs: dict | None = None) -> torch.Tensor: |
| """Get an action chunk from the policy. The chunk contains only""" |
| |
| chunk = self.policy.predict_action_chunk(observation, **(rtc_kwargs or {})) |
| if chunk.ndim != 3: |
| chunk = chunk.unsqueeze(0) |
|
|
| return chunk[:, : self.actions_per_chunk, :] |
|
|
| def _predict_action_chunk(self, observation_t: TimedObservation) -> list[TimedAction]: |
| """Predict an action chunk based on an observation""" |
| |
| inference_starts = time.perf_counter() |
|
|
| """1. Prepare observation""" |
| start_time = time.perf_counter() |
| observation = self._prepare_observation(observation_t) |
| |
| preprocessing_time = time.perf_counter() - start_time |
|
|
| self.last_processed_obs: TimedObservation = observation_t |
|
|
| """2. Get action chunk""" |
| start_time = time.perf_counter() |
| action_tensor = self._get_action_chunk(observation, self._rtc_call_kwargs(observation_t)) |
| inference_time = time.perf_counter() - start_time |
|
|
| """3. Post-inference processing""" |
| start_time = time.perf_counter() |
| |
| action_tensor = action_tensor.cpu().squeeze(0) |
|
|
| |
| if os.environ.get("RM65_LOG_GRIPPER", "1").lower() not in ("0", "false", "no"): |
| try: |
| import numpy as np |
|
|
| grip = action_tensor[:, -1].numpy() if action_tensor.ndim == 2 else action_tensor.numpy()[-1:] |
| edges = int(np.sum(np.abs(np.diff((grip > 0.5).astype(np.int8))))) |
| self.logger.info( |
| f"grip_chunk t={observation_t.get_timestep()} n={int(grip.shape[0])} " |
| f"first={float(grip[0]):.3f} last={float(grip[-1]):.3f} mean={float(grip.mean()):.3f} " |
| f"min={float(grip.min()):.3f} max={float(grip.max()):.3f} edges(>0.5)={edges} " |
| f"head={np.array2string(grip[:12], precision=2, separator=',')}" |
| ) |
| log_path = os.environ.get( |
| "RM65_GRIPPER_LOG", |
| "/home/sdznkj/zkx_ws/sendlerobot/logs/gripper_chunk.log", |
| ) |
| with open(log_path, "a", encoding="utf-8") as f: |
| f.write( |
| f"chunk\tt={observation_t.get_timestep()}\tn={grip.shape[0]}\t" |
| f"first={grip[0]:.4f}\tlast={grip[-1]:.4f}\tmean={grip.mean():.4f}\t" |
| f"min={grip.min():.4f}\tmax={grip.max():.4f}\tedges={edges}\n" |
| ) |
| except Exception as exc: |
| self.logger.debug("grip_chunk log failed: %s", exc) |
|
|
| action_chunk = self._time_action_chunk( |
| observation_t.get_timestamp(), list(action_tensor), observation_t.get_timestep() |
| ) |
| postprocessing_time = time.perf_counter() - start_time |
| inference_stops = time.perf_counter() |
|
|
| self.logger.info( |
| f"Observation {observation_t.get_timestep()} |" |
| f"Inference time: {1000 * (inference_stops - inference_starts):.2f}ms" |
| ) |
|
|
| |
| self.logger.debug( |
| f"Observation {observation_t.get_timestep()} | " |
| f"Preprocessing time: {1000 * (preprocessing_time - inference_starts):.2f}ms | " |
| f"Inference time: {1000 * (inference_time - preprocessing_time):.2f}ms | " |
| f"Postprocessing time: {1000 * (postprocessing_time - inference_time):.2f}ms | " |
| f"Total time: {1000 * (postprocessing_time - inference_starts):.2f}ms" |
| ) |
|
|
| return action_chunk |
|
|
| def stop(self): |
| """Stop the server""" |
| self._reset_server() |
| self.logger.info("Server stopping...") |
|
|
|
|
| @draccus.wrap() |
| def serve(cfg: PolicyServerConfig): |
| """Start the PolicyServer with the given configuration. |
| |
| Args: |
| config: PolicyServerConfig instance. If None, uses default configuration. |
| """ |
| logging.info(pformat(asdict(cfg))) |
|
|
| |
| policy_server = PolicyServer(cfg) |
|
|
| |
| server = grpc.server(futures.ThreadPoolExecutor(max_workers=4)) |
| |
| services_pb2_grpc.add_AsyncInferenceServicer_to_server(policy_server, server) |
| |
| server.add_insecure_port(f"{cfg.host}:{cfg.port}") |
|
|
| policy_server.logger.info(f"PolicyServer started on {cfg.host}:{cfg.port}") |
| server.start() |
|
|
| server.wait_for_termination() |
|
|
| policy_server.logger.info("Server terminated") |
|
|
|
|
| if __name__ == "__main__": |
| serve() |
|
|
