amesa-train-dev 0.20.5.dev13__tar.gz

amesa_train_dev-0.20.5.dev13/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: amesa-train-dev
+Version: 0.20.5.dev13
+Summary: a distributed trainer to be able to train agents across a cluster of machines
+Author-email: Hunter Park <hunter@amesa.com>
+Requires-Python: >=3.10, <3.13
+Description-Content-Type: text/markdown
+Requires-Dist: amesa-api-dev>=0.20.5.dev13
+Requires-Dist: amesa-core-dev>=0.20.5.dev13
+Requires-Dist: networkx==3.1
+Requires-Dist: docker==6.1.3
+Requires-Dist: kubernetes==27.2.0
+Requires-Dist: pytest-asyncio
+Requires-Dist: redis
+Requires-Dist: ray[rllib]==2.12.0
+Requires-Dist: urllib3==1.26.12
+Requires-Dist: torch==2.5.1
+Requires-Dist: ruff
+Requires-Dist: opencv-python-headless
+Requires-Dist: imageio
+Requires-Dist: onnx
+Requires-Dist: onnxruntime
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-python
+
+# Amesa
+
+Amesa helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.
+
+## Licenses / Seats
+
+Amesa is an enterprise platform and requires an API key to use.
+
+We offer 3 types of licenses:
+
+- **Enterprise:** for enterprise projects and agent creations
+- **Personal:** for personal usage and testing (typically offered to System Integrators)
+- **Trial:** validate the Amesa platform (requires sales contact person)
+
+One key is needed per user (seat-based licensing)
+
+You can request an API Key through the following methods:
+
+- [Discord](https://discord.gg/EQ3BgJt9NC)
+- [Mail](mailto:sales@amesa.com?subject=REQUEST%20API%20KEY%20-%20COMPANY_NAME%20-%20NAME&body=Hi%2C%0D%0A%0D%0AI%20would%20like%20to%20request%20an%20API%20key%20for%20my%20company%20to%20get%20started%20with%20Amesa.%0D%0A%0D%0A*%20Company%20Name%3A%20COMPANY_NAME%0D%0A*%20Seats%3A%20NO_OF_SEATS%0D%0A*%20License%20Type%3A%20Enterprise%20%7C%20Personal%20%7C%20Trial%20%28keep%20what%20is%20required%29%0D%0A%0D%0AKind%20Regards%2C%0D%0ANAME%0D%0AFUNCTION)
+
+## Getting Started
+
+1. Download the Amesa SDK: `pip install amesa`
+2. Request an API Key
+3. Get a simulator or use one of the [prebuilt ones](https://hub.docker.com/u/composabl)
+4. Create an Agent or see our [examples](https://github.com/Amesa/examples.amesa.com)

amesa_train_dev-0.20.5.dev13/README.md

@@ -0,0 +1,27 @@
+# Amesa
+
+Amesa helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.
+
+## Licenses / Seats
+
+Amesa is an enterprise platform and requires an API key to use.
+
+We offer 3 types of licenses:
+
+- **Enterprise:** for enterprise projects and agent creations
+- **Personal:** for personal usage and testing (typically offered to System Integrators)
+- **Trial:** validate the Amesa platform (requires sales contact person)
+
+One key is needed per user (seat-based licensing)
+
+You can request an API Key through the following methods:
+
+- [Discord](https://discord.gg/EQ3BgJt9NC)
+- [Mail](mailto:sales@amesa.com?subject=REQUEST%20API%20KEY%20-%20COMPANY_NAME%20-%20NAME&body=Hi%2C%0D%0A%0D%0AI%20would%20like%20to%20request%20an%20API%20key%20for%20my%20company%20to%20get%20started%20with%20Amesa.%0D%0A%0D%0A*%20Company%20Name%3A%20COMPANY_NAME%0D%0A*%20Seats%3A%20NO_OF_SEATS%0D%0A*%20License%20Type%3A%20Enterprise%20%7C%20Personal%20%7C%20Trial%20%28keep%20what%20is%20required%29%0D%0A%0D%0AKind%20Regards%2C%0D%0ANAME%0D%0AFUNCTION)
+
+## Getting Started
+
+1. Download the Amesa SDK: `pip install amesa`
+2. Request an API Key
+3. Get a simulator or use one of the [prebuilt ones](https://hub.docker.com/u/composabl)
+4. Create an Agent or see our [examples](https://github.com/Amesa/examples.amesa.com)

amesa_train_dev-0.20.5.dev13/amesa_train/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (C) Amesa, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from amesa_core.utils.space_utils import action_fits_mask
+
+from .trainer.trainer import Trainer

amesa_train_dev-0.20.5.dev13/amesa_train/actor/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (C) Amesa, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from .actor import Actor

amesa_train_dev-0.20.5.dev13/amesa_train/actor/actor.py

@@ -0,0 +1,164 @@
+# Copyright (C) Amesa, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from typing import Type, TypeVar, Union
+
+from pydantic import BaseModel
+import ray
+
+import amesa_core.utils.logger as logger_util
+
+T = TypeVar("T")
+
+logger = logger_util.get_logger(__name__)
+
+
+class ActorOptions(BaseModel):
+    name: str
+
+    # Do we detach the actor, maintaining it after references are removed
+    # https://docs.ray.io/en/latest/ray-core/actors/named-actors.html#actor-lifetimes
+    is_detached: bool = False
+
+
+class Actor:
+    """
+    Define an Actor class that acts as a Proxy for Ray Actors
+
+    We use this to wrap the Ray Actor and provide a more intuitive API as well as resolve cython compatibility issues
+    more specifically it provides:
+    1. Not having to use `.remote`
+    2. Not having to use `ray.get` to get the result
+    3. Supporting async methods natively, which are converted to sync methods always.
+        This mainly resolves nested serialization issues causing pickle issues (ref. cannot pickle `_cython_3_2_2.coroutine`)
+    """
+
+    def __init__(
+        self,
+        cls: Type[T],
+        name_or_options: Union[str, ActorOptions],
+        *actor_args,
+        **actor_kwargs
+    ):
+        self._cls = cls
+        self._actor_args = actor_args
+        self._actor_kwargs = actor_kwargs
+        self._options = (
+            name_or_options
+            if isinstance(name_or_options, ActorOptions)
+            else ActorOptions(name=name_or_options)
+        )
+
+        self._handle = (
+            ray.remote(cls)
+            .options(
+                name=self._options.name,
+                lifetime="detached" if self._options.is_detached else None,
+                # By default, we create only if it doesn't exist
+                get_if_exists=True,
+            )
+            .remote(*actor_args, **actor_kwargs)
+        )
+
+        # # Catch all exceptions
+        # sys.excepthook = self._handle_excepthook
+
+    def __getattr__(self, attr_name) -> T:
+        """
+        Execute this method on the Ray Actor Instance
+
+        Note: we make an exception for the reserved attributes _cls, _name and _handle
+        """
+        if attr_name in ["_cls", "_name", "_handle"]:
+            return getattr(self, attr_name)
+
+        method = getattr(self._handle, attr_name)
+        return self._make_sync_proxy(method)
+
+    def _make_sync_proxy(self, method):
+        def proxy(*args, **kwargs):
+            result_id = method.remote(*args, **kwargs)
+
+            try:
+                # Check if we need to use ray.get
+                if isinstance(result_id, ray.ObjectRef):
+                    return ray.get(result_id)
+                else:
+                    return result_id
+            except Exception as e:
+                logger.error(e)
+                # traceback.print_stack()
+                # Handle the exception here, e.g., by re-raising it or returning an error value
+                raise e
+
+        return proxy
+
+    def terminate(self):
+        """
+        Terminate the actor
+
+        This uses a undocumented featured named `__ray_terminate__`
+        https://github.com/ray-project/ray/blob/0e77916b0415ce95550610f8b61764eeadf7aa6c/python/ray/actor.py#L1340
+        """
+        self._handle.__ray_terminate__.remote()
+        ray.kill(self._handle)
+
+    def get_id(self):
+        """
+        Get the Ray Actor ID
+        https://github.com/ray-project/ray/blob/master/python/ray/actor.py#L1038
+        """
+        return self._handle._ray_actor_id
+
+    def get_language(self):
+        """
+        Get the Ray Actor Language
+        https://github.com/ray-project/ray/blob/master/python/ray/actor.py#L1037C9-L1037C28
+        """
+        return self._handle._ray_actor_language
+
+    def __getstate__(self):
+        state = {
+            "_cls": self._cls,
+            "_options": self._options,
+            "actor_args": self._actor_args,
+            "actor_kwargs": self._actor_kwargs,
+        }
+
+        # not every cls will have a __getstate__ method implemented
+        try:
+            additional_state = self._handle.__getstate__()
+            state["additional_state"] = additional_state
+        except:
+            pass
+
+        return state
+
+    def __setstate__(self, state):
+        self._cls = state["_cls"]
+        self._options = state["_options"]
+        self._actor_args = state["actor_args"]
+        self._actor_kwargs = state["actor_kwargs"]
+
+        # Set the handle through Named Actors
+        # https://docs.ray.io/en/latest/ray-core/actors/named-actors.html#named-actors
+
+        try:
+            self._handle = ray.get_actor(self._options.name)
+        except:
+            # if we can't find the ray actor by name,
+            # then this is a new ray instance, and we must create it
+            self._handle = (
+                ray.remote(self._cls)
+                .options(
+                    name=self._options.name,
+                    lifetime="detached" if self._options.is_detached else None,
+                    # By default, we create only if it doesn't exist
+                    get_if_exists=True,
+                )
+                .remote(*self._actor_args, **self._actor_kwargs)
+            )
+
+        if "additional_state" in state:
+            self._handle.__setstate__(state["additional_state"])

amesa_train_dev-0.20.5.dev13/amesa_train/actor/metrics_actor.py

@@ -0,0 +1,137 @@
+# Copyright (C) Amesa, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+import time
+from typing import Dict, Optional, Union
+
+import amesa_core.utils.logger as logger_util
+import ray
+from amesa_core.metrics.metrics import Metrics
+from amesa_core.metrics.metrics_config import MetricsConfig
+
+import amesa_core.utils.logger as logger_util
+logger = logger_util.get_logger(__name__)
+
+IDX_ALL = -1
+
+
+class MetricsActor:
+    def __init__(self, config: Union[Dict, MetricsConfig, None] = None):
+        self.logger = logger_util.get_logger(__name__)
+        self.config = MetricsConfig.create(config)
+        self.metrics = Metrics(config)
+        self.log_previous_steps = 0
+
+    @staticmethod
+    def get_or_create(
+        config: Optional[MetricsConfig] = None,
+    ) -> "ray.ObjectRef[MetricsActor]":
+        """
+        Get the named actor or create it if it doesn't exist
+
+        Returns:
+            The actor
+        """
+        if config is None:
+            config = MetricsConfig()
+
+        actor_name = "MetricsActor"
+
+        return (
+            ray.remote(MetricsActor)
+            .options(
+                name=actor_name,
+                # namespace="management",
+                # lifetime="detached",
+                get_if_exists=True,
+            )
+            .remote(config)
+        )
+
+    def divide_log_frequency(self, value: int) -> int:
+        """
+        Divide the log frequency by the value
+
+        Args:
+            value: The value
+
+        Returns:
+            The divided value
+        """
+        self.config.log_every_x_steps = int(self.config.log_every_x_steps / value)
+
+    def add_steps_collected(self, value: Union[float, int]):
+        """
+        Set the samples collected
+
+        Args:
+            value: The value
+
+        Returns:
+            None
+        """
+        steps_collected = int(self.metrics.add_value("steps_collected", int(value)))
+        steps_to_collect = int(self.metrics.get_metric("steps_to_collect", 0))
+
+        # Reset when done
+        if steps_to_collect > 0 and steps_collected >= steps_to_collect:
+            self.metrics.set_value("steps_collected", 0)
+            self.log_previous_steps = 0
+
+        # Calculate the Δt and Σt for the timestamp
+        ts = time.time()
+        t_delta = round(self.metrics.diff_value("steps_collected_t", ts, 0), 3)
+        self.metrics.set_value("steps_collected_Δt", t_delta)
+        t_sigma = round(self.metrics.add_value("steps_collected_Σt", t_delta), 3)
+
+        # Print
+        if steps_collected - self.log_previous_steps >= self.config.log_every_x_steps:
+            self.print(steps_to_collect, steps_collected, t_delta, t_sigma)
+            self.log_previous_steps = steps_collected
+
+    def print(
+        self,
+        steps_to_collect: int,
+        steps_collected: int,
+        t_delta: float,
+        t_sigma: float,
+    ):
+        """
+        Print the metrics
+        """
+        length_of_steps_to_collect = len(str(steps_to_collect))
+        steps_collected_str = str(steps_collected).rjust(length_of_steps_to_collect)
+        t_delta_str = (str(t_delta) + "s").rjust(8)
+        t_sigma_str = (str(t_sigma) + "s").rjust(8)
+        steps_per_second = round(
+            steps_collected / t_sigma if t_sigma > 0 else 0.0001, 3
+        )
+        steps_per_second_str = str(steps_per_second).rjust(8)
+        res = f"Gathering Experience: {steps_collected_str} / {steps_to_collect} | Δt: {t_delta_str} | Σt: {t_sigma_str} | steps/s: {steps_per_second_str}"
+        self.logger.info(res)
+
+    def set_steps_to_collect(self, value: int):
+        """
+        Set the samples to collect
+
+        Args:
+            value: The value
+
+        Returns:
+            None
+        """
+        self.metrics.set_value("steps_to_collect", value)
+
+    def reset(self, metric: Optional[str] = None):
+        """
+        Reset the metric given or everything if nothing
+        """
+        self.log_previous_steps = 0
+        self.metrics.reset(metric)
+
+        # Also reset the other values that belong with the steps collected
+        if metric == "steps_collected":
+            self.metrics.set_value("steps_collected_t", time.time())
+            self.metrics.set_value("steps_collected_Δt", 0)
+            self.metrics.set_value("steps_collected_Σt", 0)

amesa_train_dev-0.20.5.dev13/amesa_train/actor/sim_mgr_actor.py

@@ -0,0 +1,42 @@
+# Copyright (C) Amesa, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+import ray
+
+from amesa_core.config.trainer_config import TrainerConfig
+from amesa_core.networking.network_mgr import NetworkMgr
+import amesa_core.utils.logger as logger_util
+
+logger = logger_util.get_logger(__name__)
+
+
+class NetworkMgrActor(NetworkMgr):
+    """
+    Note: we do not use the `@ray.remote` decorator here because
+    ray does not support the decorator with Cython
+    see: https://github.com/ray-project/ray/issues/39736
+    """
+
+    def __init__(self, config: TrainerConfig):
+        super().__init__(config)
+
+    @staticmethod
+    def create_actor(config: TrainerConfig) -> "ray.ObjectRef[NetworkMgrActor]":
+        """
+        Create an actor
+        Note: we do not check if the actor exists already as we want the error. Causing the actor
+        to exist already causes unwanted behavior in tests
+        """
+        actor_name = "NetworkMgrActor"
+        cls = ray.remote(NetworkMgrActor)
+        return cls.options(name=actor_name).remote(config)
+
+    def terminate(self):
+        """
+        Terminate the actor
+        """
+        logger.debug("Terminating sim watchdog on actor")
+        self.stop_watchdogs()
+
+        logger.debug("Terminating actor")
+        ray.actor.exit_actor()

amesa_train_dev-0.20.5.dev13/amesa_train/config/__init__.py

@@ -0,0 +1,12 @@
+# Copyright (C) Amesa, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from .env_config import EnvConfig
+from .step_info import TeacherStepData, CoordinatedTeacherStepData
+
+__all__ = [
+    "EnvConfig",
+    "TeacherStepData",
+    "CoordinatedTeacherStepData",
+]

amesa_train_dev-0.20.5.dev13/amesa_train/config/env_config.py

@@ -0,0 +1,23 @@
+# Copyright (C) Amesa, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from amesa_core.networking.sim.client_config import ClientConfig
+
+
+# Create a BaseModel implemention that is a Union of an any dict with ClientConfigBase
+class EnvConfigBase(BaseModel):
+    amesa: ClientConfig = None
+    render: Optional[str] = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class EnvConfig(EnvConfigBase):
+    def __init__(self, config={}):
+        super().__init__(**config)

amesa_train_dev-0.20.5.dev13/amesa_train/config/step_info.py

@@ -0,0 +1,52 @@
+# Copyright (C) Amesa, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+from typing import Dict, List, Optional, Union
+from typing_extensions import Annotated
+
+from pydantic import BaseModel, BeforeValidator, PlainSerializer
+import numpy as np
+
+
+def nd_array_custom_before_validator(x):
+    # custome before validation logic
+    return x
+
+
+def nd_array_custom_serializer(x):
+    # custome serialization logic
+    return str(x)
+
+
+NdArray = Annotated[
+    np.ndarray,
+    BeforeValidator(nd_array_custom_before_validator),
+    PlainSerializer(nd_array_custom_serializer, return_type=str),
+]
+
+
+# Create a BaseModel implemention that is a Union of an any dict with ClientConfigBase
+class TeacherStepData(BaseModel):
+    state: Dict[str, Union[float, dict, tuple, str]] = None
+    action: Union[NdArray, int, float, dict, tuple] = None
+    top_selector_action: Optional[Union[NdArray, int, float, dict, tuple]] = None
+    teacher_reward: float = None
+    coordinated_reward: Optional[Dict[str, float]] = None
+    teacher_success: bool = None
+    teacher_terminal: bool = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class CoordinatedTeacherStepData(BaseModel):
+    state: Dict[str, Dict[str, Union[float, str]]] = None
+    action: Dict[str, Union[NdArray, int, float, dict, tuple]] = None
+    teacher_reward: Dict[str, float] = None
+    teacher_success: Dict[str, bool] = None
+    teacher_terminal: Dict[str, bool] = None
+    coordinated_reward: Optional[Dict[str, Dict[str, float]]] = None
+    coordinated_reward: Optional[List[float]] = None
+
+    class Config:
+        arbitrary_types_allowed = True

amesa_train_dev-0.20.5.dev13/amesa_train/env/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (C) Amesa, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from .env import AmesaEnv
+from .env_multi_agent import AmesaEnvMultiAgent
+from .env_mgr import EnvMgr