lerobot/scripts/server/policy_server.py

# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
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  # nosec
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,  # type: ignore
    services_pb2_grpc,  # type: ignore
)
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()

        # FPS measurement
        #追踪和计算FPS，帮助测量观测数据从客户端流入服务器的速度
        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

        # Attributes will be set by SendPolicyInstructions
        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."""
        # only running inference on the latest observation received by the server
        self.shutdown_event.set()
        self.observation_queue = Queue(maxsize=1)

        with self._predicted_timesteps_lock:
            self._predicted_timesteps = set()

    def Ready(self, request, context):  # noqa: N802
        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):  # noqa: N802
        """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() #获取客户端ID

        policy_specs = pickle.loads(request.data)  # nosec #数据反序列化

        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  # act, pi0, etc.
        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))

        #加载策略类 — RM65 local ckpts need sanitize + normalizer stats
        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):  # noqa: N802
        """Receive observations from the robot client"""
        #接收观测数据并对观测数据进行判断
        client_id = context.peer()
        # self.logger.info(f"Receiving observations from {client_id}")

        receive_time = time.time()  # comparing timestamps so need time.time()
        start_deserialize = time.perf_counter()
        #阻塞地接收数据，直到request_iterator迭代完毕
        received_bytes = receive_bytes_in_chunks(
            request_iterator, None, self.shutdown_event, self.logger
        )  # blocking call while looping over request_iterator
        #反序列化接收到的字节流
        timed_observation = pickle.loads(received_bytes)  # nosec
        #这里需要检查反序列化接收到的观测是否正确

        deserialize_time = time.perf_counter() - start_deserialize

        #debug: 接收到观测结果
        # self.logger.debug(f"Received observation #{timed_observation.get_timestep()}")

        obs_timestep = timed_observation.get_timestep()
        obs_timestamp = timed_observation.get_timestamp()

        # Calculate FPS metrics
        fps_metrics = self.fps_tracker.calculate_fps_metrics(obs_timestamp)

        #debug-> Received observation #0 | Avg FPS: 0.00 | Target: 30.00 | One-way latency: 1.97ms
                #Received observation #0 | Avg FPS: 30.56 | Target: 30.00 | One-way latency: 4.60ms
                #Received observation #0 | Avg FPS: 30.19 | Target: 30.00 | One-way latency: 4.42ms
                #Received observation #0 | Avg FPS: 30.06 | Target: 30.00 | One-way latency: 2.79ms
        self.logger.info(
            f"Received observation #{obs_timestep} | "
            f"Avg FPS: {fps_metrics['avg_fps']:.2f} | "  # fps at which observations are received from client
            f"Target: {fps_metrics['target_fps']:.2f} | "
            f"One-way latency: {(receive_time - obs_timestamp) * 1000:.2f}ms"
        )

        # self.logger.debug(
        #     f"Server timestamp: {receive_time:.6f} | "
        #     f"Client timestamp: {obs_timestamp:.6f} | "
        #     f"Deserialization time: {deserialize_time:.6f}s"
        # )

        if not self._enqueue_observation(
            timed_observation  # wrapping a RawObservation
        ):
            #观测结果被过滤掉了
            self.logger.info(f"Observation #{obs_timestep} has been filtered out")

        return services_pb2.Empty()

    def GetActions(self, request, context):  # noqa: N802
        """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")

        # Generate action based on the most recent observation and its timestep
        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()
            #debug: 打印当前正在进行的动作预测
            # self.logger.info("Starting action chunk prediction")
            action_chunk = self._predict_action_chunk(obs)
            # self.logger.info("Action chunk prediction completed")
            inference_time = time.perf_counter() - start_time

            #序列化动作数据
            start_time = time.perf_counter()
            actions_bytes = pickle.dumps(action_chunk)  # nosec
            serialize_time = time.perf_counter() - start_time

            # Create and return the action chunk
            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))
            )  # sleep controls inference latency

            return actions

        except Empty:  # no observation added to queue in obs_queue_timeout
            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
        # 关节变化很小时也继续推理。RM65_SKIP_SIMILAR_OBS=1 时不因 L2<1° 丢帧。
        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"""

        # # debug: must_go:false
        # self.logger.info(f"must_go: {obs.must_go}")
        # # debug: last_processed_obs: None
        # if self.last_processed_obs is None:
        #     self.logger.info("Last processed observation is None")
        # # self.logger.info(f"sanity_checks: {self._obs_sanity_checks(obs, self.last_processed_obs)}")   
        # debug:
        # 第一帧：
        # INFO 2025-07-30 11:15:49 y_server.py:303 must_go: True
        # INFO 2025-07-30 11:15:49 y_server.py:306 Last processed observation is None
        # INFO 2025-07-30 11:15:49 y_server.py:328 successfully enqueued observation
        # INFO 2025-07-30 11:15:49 y_server.py:230 Running inference for observation #0 (must_go: True)
        # INFO 2025-07-30 11:15:49 y_server.py:240 Starting action chunk prediction
        # ERROR 2025-07-30 11:15:49 y_server.py:274 Error in StreamActions: 'SmolVLAPolicy' object has no attribute 'predict_action_chunk'

        #如果观测数据必须被处理，或者这是第一个观测数据，或者当前观测数据与上一个观测数据不相似，则将其放入队列
        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 queue is full, get the old observation to make room
            if self.observation_queue.full():
                # pops from queue
                _ = self.observation_queue.get_nowait()
                self.logger.debug("Observation queue was full, removed oldest observation")

            # Now put the new observation (never blocks as queue is non-full here)
            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.
        """
        # RawObservation from robot.get_observation() - wrong keys, wrong dtype, wrong image shape
        observation: Observation = raw_observation_to_observation(
            observation_t.get_observation(),
            self.lerobot_features,
            self.policy_image_features,
            self.device,
        )
        # RM65: robot may send 7-D (joints+gripper) while astra/usb ckpts expect 6-D joint state
        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:  # noqa: BLE001
                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"""
        # self.logger.info(observation)
        chunk = self.policy.predict_action_chunk(observation, **(rtc_kwargs or {}))
        if chunk.ndim != 3:
            chunk = chunk.unsqueeze(0)  # adding batch dimension, now shape is (B, chunk_size, action_dim)

        return chunk[:, : self.actions_per_chunk, :]

    def _predict_action_chunk(self, observation_t: TimedObservation) -> list[TimedAction]:
        """Predict an action chunk based on an observation"""
        # self.logger.info("Predicting action chunk")
        inference_starts = time.perf_counter()

        """1. Prepare observation"""
        start_time = time.perf_counter()
        observation = self._prepare_observation(observation_t)
        # self.logger.info("Observation prepared")
        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()
        # Move to CPU before serializing
        action_tensor = action_tensor.cpu().squeeze(0)

        # Gripper diagnostics (chunk-level): compare vs teleop demos with few open/close edges
        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:  # noqa: BLE001
                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"
        )

        # full-process latency breakdown for debugging purposes
        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)))

    # Create the server instance first
    policy_server = PolicyServer(cfg)

    # Setup and start gRPC server
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=4))
    # Register the PolicyServer servicer
    services_pb2_grpc.add_AsyncInferenceServicer_to_server(policy_server, server)
    # Add insecure port for the server to listen on
    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()