Tinghong-Ye22's picture
Add files using upload-large-folder tool
211ae03 verified
Raw History Blame Contribute Delete
4.06 kB
from abc import ABC, abstractmethod
from typing import Any
class BasePolicy(ABC):
"""Abstract base class for robotic control policies.
This class defines the interface that all policies must implement, including
methods for action computation, input/output validation, and state management.
Subclasses must implement:
- check_observation(): Validate observation format
- check_action(): Validate action format
- _get_action(): Core action computation logic
- reset(): Reset policy to initial state
"""
def __init__(self, *, strict: bool = True):
self.strict = strict
@abstractmethod
def check_observation(self, observation: dict[str, Any]) -> None:
"""Check if the observation is valid.
Args:
observation: Dictionary containing the current state/observation of the environment
Raises:
AssertionError: If the observation is invalid.
"""
pass
@abstractmethod
def check_action(self, action: dict[str, Any]) -> None:
"""Check if the action is valid.
Args:
action: Dictionary containing the action to be executed
Raises:
AssertionError: If the action is invalid.
"""
pass
@abstractmethod
def _get_action(
self, observation: dict[str, Any], options: dict[str, Any] | None = None
) -> tuple[dict[str, Any], dict[str, Any]]:
"""Compute and return the next action based on current observation.
This method should be overridden by subclasses to implement policy-specific
action computation. Input validation is handled by the public get_action() method.
Args:
observation: Dictionary containing the current state/observation
options: Optional configuration dict for action computation
Returns:
Tuple of (action, info):
- action: Dictionary containing the action to be executed
- info: Dictionary containing additional metadata (e.g., confidence scores)
"""
pass
def get_action(
self, observation: dict[str, Any], options: dict[str, Any] | None = None
) -> tuple[dict[str, Any], dict[str, Any]]:
"""Compute and return the next action based on current observation with validation.
This is the main public interface. It validates the observation, calls
the internal _get_action(), and validates the resulting action.
Args:
observation: Dictionary containing the current state/observation
options: Optional configuration dict for action computation
Returns:
Tuple of (action, info):
- action: Dictionary containing the validated action
- info: Dictionary containing additional metadata
Raises:
AssertionError/ValueError: If observation or action validation fails
"""
if self.strict:
self.check_observation(observation)
action, info = self._get_action(observation, options)
if self.strict:
self.check_action(action)
return action, info
@abstractmethod
def reset(self, options: dict[str, Any] | None = None) -> dict[str, Any]:
"""Reset the policy to its initial state.
Args:
options: Dictionary containing the options for the reset
Returns:
Dictionary containing the info after resetting the policy
"""
pass
class PolicyWrapper(BasePolicy):
"""Base wrapper class for composing policy behaviors.
Note: This base implementation only forwards reset(). Subclasses should
implement validation logic and additional functionality as needed.
"""
def __init__(self, policy: BasePolicy, *, strict: bool = True):
super().__init__(strict=strict)
self.policy = policy
def reset(self, options: dict[str, Any] | None = None) -> dict[str, Any]:
return self.policy.reset(options)