| # Table of Contents | |
| * [mlagents\_envs.base\_env](#mlagents_envs.base_env) | |
| * [DecisionStep](#mlagents_envs.base_env.DecisionStep) | |
| * [DecisionSteps](#mlagents_envs.base_env.DecisionSteps) | |
| * [agent\_id\_to\_index](#mlagents_envs.base_env.DecisionSteps.agent_id_to_index) | |
| * [\_\_getitem\_\_](#mlagents_envs.base_env.DecisionSteps.__getitem__) | |
| * [empty](#mlagents_envs.base_env.DecisionSteps.empty) | |
| * [TerminalStep](#mlagents_envs.base_env.TerminalStep) | |
| * [TerminalSteps](#mlagents_envs.base_env.TerminalSteps) | |
| * [agent\_id\_to\_index](#mlagents_envs.base_env.TerminalSteps.agent_id_to_index) | |
| * [\_\_getitem\_\_](#mlagents_envs.base_env.TerminalSteps.__getitem__) | |
| * [empty](#mlagents_envs.base_env.TerminalSteps.empty) | |
| * [ActionTuple](#mlagents_envs.base_env.ActionTuple) | |
| * [discrete\_dtype](#mlagents_envs.base_env.ActionTuple.discrete_dtype) | |
| * [ActionSpec](#mlagents_envs.base_env.ActionSpec) | |
| * [is\_discrete](#mlagents_envs.base_env.ActionSpec.is_discrete) | |
| * [is\_continuous](#mlagents_envs.base_env.ActionSpec.is_continuous) | |
| * [discrete\_size](#mlagents_envs.base_env.ActionSpec.discrete_size) | |
| * [empty\_action](#mlagents_envs.base_env.ActionSpec.empty_action) | |
| * [random\_action](#mlagents_envs.base_env.ActionSpec.random_action) | |
| * [create\_continuous](#mlagents_envs.base_env.ActionSpec.create_continuous) | |
| * [create\_discrete](#mlagents_envs.base_env.ActionSpec.create_discrete) | |
| * [DimensionProperty](#mlagents_envs.base_env.DimensionProperty) | |
| * [UNSPECIFIED](#mlagents_envs.base_env.DimensionProperty.UNSPECIFIED) | |
| * [NONE](#mlagents_envs.base_env.DimensionProperty.NONE) | |
| * [TRANSLATIONAL\_EQUIVARIANCE](#mlagents_envs.base_env.DimensionProperty.TRANSLATIONAL_EQUIVARIANCE) | |
| * [VARIABLE\_SIZE](#mlagents_envs.base_env.DimensionProperty.VARIABLE_SIZE) | |
| * [ObservationType](#mlagents_envs.base_env.ObservationType) | |
| * [DEFAULT](#mlagents_envs.base_env.ObservationType.DEFAULT) | |
| * [GOAL\_SIGNAL](#mlagents_envs.base_env.ObservationType.GOAL_SIGNAL) | |
| * [ObservationSpec](#mlagents_envs.base_env.ObservationSpec) | |
| * [BehaviorSpec](#mlagents_envs.base_env.BehaviorSpec) | |
| * [BaseEnv](#mlagents_envs.base_env.BaseEnv) | |
| * [step](#mlagents_envs.base_env.BaseEnv.step) | |
| * [reset](#mlagents_envs.base_env.BaseEnv.reset) | |
| * [close](#mlagents_envs.base_env.BaseEnv.close) | |
| * [behavior\_specs](#mlagents_envs.base_env.BaseEnv.behavior_specs) | |
| * [set\_actions](#mlagents_envs.base_env.BaseEnv.set_actions) | |
| * [set\_action\_for\_agent](#mlagents_envs.base_env.BaseEnv.set_action_for_agent) | |
| * [get\_steps](#mlagents_envs.base_env.BaseEnv.get_steps) | |
| * [mlagents\_envs.environment](#mlagents_envs.environment) | |
| * [UnityEnvironment](#mlagents_envs.environment.UnityEnvironment) | |
| * [\_\_init\_\_](#mlagents_envs.environment.UnityEnvironment.__init__) | |
| * [close](#mlagents_envs.environment.UnityEnvironment.close) | |
| * [mlagents\_envs.registry](#mlagents_envs.registry) | |
| * [mlagents\_envs.registry.unity\_env\_registry](#mlagents_envs.registry.unity_env_registry) | |
| * [UnityEnvRegistry](#mlagents_envs.registry.unity_env_registry.UnityEnvRegistry) | |
| * [register](#mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.register) | |
| * [register\_from\_yaml](#mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.register_from_yaml) | |
| * [clear](#mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.clear) | |
| * [\_\_getitem\_\_](#mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.__getitem__) | |
| * [mlagents\_envs.side\_channel](#mlagents_envs.side_channel) | |
| * [mlagents\_envs.side\_channel.raw\_bytes\_channel](#mlagents_envs.side_channel.raw_bytes_channel) | |
| * [RawBytesChannel](#mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel) | |
| * [on\_message\_received](#mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.on_message_received) | |
| * [get\_and\_clear\_received\_messages](#mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.get_and_clear_received_messages) | |
| * [send\_raw\_data](#mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.send_raw_data) | |
| * [mlagents\_envs.side\_channel.outgoing\_message](#mlagents_envs.side_channel.outgoing_message) | |
| * [OutgoingMessage](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage) | |
| * [\_\_init\_\_](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.__init__) | |
| * [write\_bool](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_bool) | |
| * [write\_int32](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_int32) | |
| * [write\_float32](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_float32) | |
| * [write\_float32\_list](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_float32_list) | |
| * [write\_string](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_string) | |
| * [set\_raw\_bytes](#mlagents_envs.side_channel.outgoing_message.OutgoingMessage.set_raw_bytes) | |
| * [mlagents\_envs.side\_channel.engine\_configuration\_channel](#mlagents_envs.side_channel.engine_configuration_channel) | |
| * [EngineConfigurationChannel](#mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel) | |
| * [on\_message\_received](#mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.on_message_received) | |
| * [set\_configuration\_parameters](#mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.set_configuration_parameters) | |
| * [set\_configuration](#mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.set_configuration) | |
| * [mlagents\_envs.side\_channel.side\_channel\_manager](#mlagents_envs.side_channel.side_channel_manager) | |
| * [SideChannelManager](#mlagents_envs.side_channel.side_channel_manager.SideChannelManager) | |
| * [process\_side\_channel\_message](#mlagents_envs.side_channel.side_channel_manager.SideChannelManager.process_side_channel_message) | |
| * [generate\_side\_channel\_messages](#mlagents_envs.side_channel.side_channel_manager.SideChannelManager.generate_side_channel_messages) | |
| * [mlagents\_envs.side\_channel.stats\_side\_channel](#mlagents_envs.side_channel.stats_side_channel) | |
| * [StatsSideChannel](#mlagents_envs.side_channel.stats_side_channel.StatsSideChannel) | |
| * [on\_message\_received](#mlagents_envs.side_channel.stats_side_channel.StatsSideChannel.on_message_received) | |
| * [get\_and\_reset\_stats](#mlagents_envs.side_channel.stats_side_channel.StatsSideChannel.get_and_reset_stats) | |
| * [mlagents\_envs.side\_channel.incoming\_message](#mlagents_envs.side_channel.incoming_message) | |
| * [IncomingMessage](#mlagents_envs.side_channel.incoming_message.IncomingMessage) | |
| * [\_\_init\_\_](#mlagents_envs.side_channel.incoming_message.IncomingMessage.__init__) | |
| * [read\_bool](#mlagents_envs.side_channel.incoming_message.IncomingMessage.read_bool) | |
| * [read\_int32](#mlagents_envs.side_channel.incoming_message.IncomingMessage.read_int32) | |
| * [read\_float32](#mlagents_envs.side_channel.incoming_message.IncomingMessage.read_float32) | |
| * [read\_float32\_list](#mlagents_envs.side_channel.incoming_message.IncomingMessage.read_float32_list) | |
| * [read\_string](#mlagents_envs.side_channel.incoming_message.IncomingMessage.read_string) | |
| * [get\_raw\_bytes](#mlagents_envs.side_channel.incoming_message.IncomingMessage.get_raw_bytes) | |
| * [mlagents\_envs.side\_channel.float\_properties\_channel](#mlagents_envs.side_channel.float_properties_channel) | |
| * [FloatPropertiesChannel](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel) | |
| * [on\_message\_received](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.on_message_received) | |
| * [set\_property](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.set_property) | |
| * [get\_property](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.get_property) | |
| * [list\_properties](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.list_properties) | |
| * [get\_property\_dict\_copy](#mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.get_property_dict_copy) | |
| * [mlagents\_envs.side\_channel.environment\_parameters\_channel](#mlagents_envs.side_channel.environment_parameters_channel) | |
| * [EnvironmentParametersChannel](#mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel) | |
| * [set\_float\_parameter](#mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_float_parameter) | |
| * [set\_uniform\_sampler\_parameters](#mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_uniform_sampler_parameters) | |
| * [set\_gaussian\_sampler\_parameters](#mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_gaussian_sampler_parameters) | |
| * [set\_multirangeuniform\_sampler\_parameters](#mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_multirangeuniform_sampler_parameters) | |
| * [mlagents\_envs.side\_channel.side\_channel](#mlagents_envs.side_channel.side_channel) | |
| * [SideChannel](#mlagents_envs.side_channel.side_channel.SideChannel) | |
| * [queue\_message\_to\_send](#mlagents_envs.side_channel.side_channel.SideChannel.queue_message_to_send) | |
| * [on\_message\_received](#mlagents_envs.side_channel.side_channel.SideChannel.on_message_received) | |
| * [channel\_id](#mlagents_envs.side_channel.side_channel.SideChannel.channel_id) | |
| <a name="mlagents_envs.base_env"></a> | |
| # mlagents\_envs.base\_env | |
| Python Environment API for the ML-Agents Toolkit | |
| The aim of this API is to expose Agents evolving in a simulation | |
| to perform reinforcement learning on. | |
| This API supports multi-agent scenarios and groups similar Agents (same | |
| observations, actions spaces and behavior) together. These groups of Agents are | |
| identified by their BehaviorName. | |
| For performance reasons, the data of each group of agents is processed in a | |
| batched manner. Agents are identified by a unique AgentId identifier that | |
| allows tracking of Agents across simulation steps. Note that there is no | |
| guarantee that the number or order of the Agents in the state will be | |
| consistent across simulation steps. | |
| A simulation steps corresponds to moving the simulation forward until at least | |
| one agent in the simulation sends its observations to Python again. Since | |
| Agents can request decisions at different frequencies, a simulation step does | |
| not necessarily correspond to a fixed simulation time increment. | |
| <a name="mlagents_envs.base_env.DecisionStep"></a> | |
| ## DecisionStep Objects | |
| ```python | |
| class DecisionStep(NamedTuple) | |
| ``` | |
| Contains the data a single Agent collected since the last | |
| simulation step. | |
| - obs is a list of numpy arrays observations collected by the agent. | |
| - reward is a float. Corresponds to the rewards collected by the agent | |
| since the last simulation step. | |
| - agent_id is an int and an unique identifier for the corresponding Agent. | |
| - action_mask is an optional list of one dimensional array of booleans. | |
| Only available when using multi-discrete actions. | |
| Each array corresponds to an action branch. Each array contains a mask | |
| for each action of the branch. If true, the action is not available for | |
| the agent during this simulation step. | |
| <a name="mlagents_envs.base_env.DecisionSteps"></a> | |
| ## DecisionSteps Objects | |
| ```python | |
| class DecisionSteps(Mapping) | |
| ``` | |
| Contains the data a batch of similar Agents collected since the last | |
| simulation step. Note that all Agents do not necessarily have new | |
| information to send at each simulation step. Therefore, the ordering of | |
| agents and the batch size of the DecisionSteps are not fixed across | |
| simulation steps. | |
| - obs is a list of numpy arrays observations collected by the batch of | |
| agent. Each obs has one extra dimension compared to DecisionStep: the | |
| first dimension of the array corresponds to the batch size of the batch. | |
| - reward is a float vector of length batch size. Corresponds to the | |
| rewards collected by each agent since the last simulation step. | |
| - agent_id is an int vector of length batch size containing unique | |
| identifier for the corresponding Agent. This is used to track Agents | |
| across simulation steps. | |
| - action_mask is an optional list of two dimensional array of booleans. | |
| Only available when using multi-discrete actions. | |
| Each array corresponds to an action branch. The first dimension of each | |
| array is the batch size and the second contains a mask for each action of | |
| the branch. If true, the action is not available for the agent during | |
| this simulation step. | |
| <a name="mlagents_envs.base_env.DecisionSteps.agent_id_to_index"></a> | |
| #### agent\_id\_to\_index | |
| ```python | |
| | @property | |
| | agent_id_to_index() -> Dict[AgentId, int] | |
| ``` | |
| **Returns**: | |
| A Dict that maps agent_id to the index of those agents in | |
| this DecisionSteps. | |
| <a name="mlagents_envs.base_env.DecisionSteps.__getitem__"></a> | |
| #### \_\_getitem\_\_ | |
| ```python | |
| | __getitem__(agent_id: AgentId) -> DecisionStep | |
| ``` | |
| returns the DecisionStep for a specific agent. | |
| **Arguments**: | |
| - `agent_id`: The id of the agent | |
| **Returns**: | |
| The DecisionStep | |
| <a name="mlagents_envs.base_env.DecisionSteps.empty"></a> | |
| #### empty | |
| ```python | |
| | @staticmethod | |
| | empty(spec: "BehaviorSpec") -> "DecisionSteps" | |
| ``` | |
| Returns an empty DecisionSteps. | |
| **Arguments**: | |
| - `spec`: The BehaviorSpec for the DecisionSteps | |
| <a name="mlagents_envs.base_env.TerminalStep"></a> | |
| ## TerminalStep Objects | |
| ```python | |
| class TerminalStep(NamedTuple) | |
| ``` | |
| Contains the data a single Agent collected when its episode ended. | |
| - obs is a list of numpy arrays observations collected by the agent. | |
| - reward is a float. Corresponds to the rewards collected by the agent | |
| since the last simulation step. | |
| - interrupted is a bool. Is true if the Agent was interrupted since the last | |
| decision step. For example, if the Agent reached the maximum number of steps for | |
| the episode. | |
| - agent_id is an int and an unique identifier for the corresponding Agent. | |
| <a name="mlagents_envs.base_env.TerminalSteps"></a> | |
| ## TerminalSteps Objects | |
| ```python | |
| class TerminalSteps(Mapping) | |
| ``` | |
| Contains the data a batch of Agents collected when their episode | |
| terminated. All Agents present in the TerminalSteps have ended their | |
| episode. | |
| - obs is a list of numpy arrays observations collected by the batch of | |
| agent. Each obs has one extra dimension compared to DecisionStep: the | |
| first dimension of the array corresponds to the batch size of the batch. | |
| - reward is a float vector of length batch size. Corresponds to the | |
| rewards collected by each agent since the last simulation step. | |
| - interrupted is an array of booleans of length batch size. Is true if the | |
| associated Agent was interrupted since the last decision step. For example, if the | |
| Agent reached the maximum number of steps for the episode. | |
| - agent_id is an int vector of length batch size containing unique | |
| identifier for the corresponding Agent. This is used to track Agents | |
| across simulation steps. | |
| <a name="mlagents_envs.base_env.TerminalSteps.agent_id_to_index"></a> | |
| #### agent\_id\_to\_index | |
| ```python | |
| | @property | |
| | agent_id_to_index() -> Dict[AgentId, int] | |
| ``` | |
| **Returns**: | |
| A Dict that maps agent_id to the index of those agents in | |
| this TerminalSteps. | |
| <a name="mlagents_envs.base_env.TerminalSteps.__getitem__"></a> | |
| #### \_\_getitem\_\_ | |
| ```python | |
| | __getitem__(agent_id: AgentId) -> TerminalStep | |
| ``` | |
| returns the TerminalStep for a specific agent. | |
| **Arguments**: | |
| - `agent_id`: The id of the agent | |
| **Returns**: | |
| obs, reward, done, agent_id and optional action mask for a | |
| specific agent | |
| <a name="mlagents_envs.base_env.TerminalSteps.empty"></a> | |
| #### empty | |
| ```python | |
| | @staticmethod | |
| | empty(spec: "BehaviorSpec") -> "TerminalSteps" | |
| ``` | |
| Returns an empty TerminalSteps. | |
| **Arguments**: | |
| - `spec`: The BehaviorSpec for the TerminalSteps | |
| <a name="mlagents_envs.base_env.ActionTuple"></a> | |
| ## ActionTuple Objects | |
| ```python | |
| class ActionTuple(_ActionTupleBase) | |
| ``` | |
| An object whose fields correspond to actions of different types. | |
| Continuous and discrete actions are numpy arrays of type float32 and | |
| int32, respectively and are type checked on construction. | |
| Dimensions are of (n_agents, continuous_size) and (n_agents, discrete_size), | |
| respectively. Note, this also holds when continuous or discrete size is | |
| zero. | |
| <a name="mlagents_envs.base_env.ActionTuple.discrete_dtype"></a> | |
| #### discrete\_dtype | |
| ```python | |
| | @property | |
| | discrete_dtype() -> np.dtype | |
| ``` | |
| The dtype of a discrete action. | |
| <a name="mlagents_envs.base_env.ActionSpec"></a> | |
| ## ActionSpec Objects | |
| ```python | |
| class ActionSpec(NamedTuple) | |
| ``` | |
| A NamedTuple containing utility functions and information about the action spaces | |
| for a group of Agents under the same behavior. | |
| - num_continuous_actions is an int corresponding to the number of floats which | |
| constitute the action. | |
| - discrete_branch_sizes is a Tuple of int where each int corresponds to | |
| the number of discrete actions available to the agent on an independent action branch. | |
| <a name="mlagents_envs.base_env.ActionSpec.is_discrete"></a> | |
| #### is\_discrete | |
| ```python | |
| | is_discrete() -> bool | |
| ``` | |
| Returns true if this Behavior uses discrete actions | |
| <a name="mlagents_envs.base_env.ActionSpec.is_continuous"></a> | |
| #### is\_continuous | |
| ```python | |
| | is_continuous() -> bool | |
| ``` | |
| Returns true if this Behavior uses continuous actions | |
| <a name="mlagents_envs.base_env.ActionSpec.discrete_size"></a> | |
| #### discrete\_size | |
| ```python | |
| | @property | |
| | discrete_size() -> int | |
| ``` | |
| Returns a an int corresponding to the number of discrete branches. | |
| <a name="mlagents_envs.base_env.ActionSpec.empty_action"></a> | |
| #### empty\_action | |
| ```python | |
| | empty_action(n_agents: int) -> ActionTuple | |
| ``` | |
| Generates ActionTuple corresponding to an empty action (all zeros) | |
| for a number of agents. | |
| **Arguments**: | |
| - `n_agents`: The number of agents that will have actions generated | |
| <a name="mlagents_envs.base_env.ActionSpec.random_action"></a> | |
| #### random\_action | |
| ```python | |
| | random_action(n_agents: int) -> ActionTuple | |
| ``` | |
| Generates ActionTuple corresponding to a random action (either discrete | |
| or continuous) for a number of agents. | |
| **Arguments**: | |
| - `n_agents`: The number of agents that will have actions generated | |
| <a name="mlagents_envs.base_env.ActionSpec.create_continuous"></a> | |
| #### create\_continuous | |
| ```python | |
| | @staticmethod | |
| | create_continuous(continuous_size: int) -> "ActionSpec" | |
| ``` | |
| Creates an ActionSpec that is homogenously continuous | |
| <a name="mlagents_envs.base_env.ActionSpec.create_discrete"></a> | |
| #### create\_discrete | |
| ```python | |
| | @staticmethod | |
| | create_discrete(discrete_branches: Tuple[int]) -> "ActionSpec" | |
| ``` | |
| Creates an ActionSpec that is homogenously discrete | |
| <a name="mlagents_envs.base_env.DimensionProperty"></a> | |
| ## DimensionProperty Objects | |
| ```python | |
| class DimensionProperty(IntFlag) | |
| ``` | |
| The dimension property of a dimension of an observation. | |
| <a name="mlagents_envs.base_env.DimensionProperty.UNSPECIFIED"></a> | |
| #### UNSPECIFIED | |
| No properties specified. | |
| <a name="mlagents_envs.base_env.DimensionProperty.NONE"></a> | |
| #### NONE | |
| No Property of the observation in that dimension. Observation can be processed with | |
| Fully connected networks. | |
| <a name="mlagents_envs.base_env.DimensionProperty.TRANSLATIONAL_EQUIVARIANCE"></a> | |
| #### TRANSLATIONAL\_EQUIVARIANCE | |
| Means it is suitable to do a convolution in this dimension. | |
| <a name="mlagents_envs.base_env.DimensionProperty.VARIABLE_SIZE"></a> | |
| #### VARIABLE\_SIZE | |
| Means that there can be a variable number of observations in this dimension. | |
| The observations are unordered. | |
| <a name="mlagents_envs.base_env.ObservationType"></a> | |
| ## ObservationType Objects | |
| ```python | |
| class ObservationType(Enum) | |
| ``` | |
| An Enum which defines the type of information carried in the observation | |
| of the agent. | |
| <a name="mlagents_envs.base_env.ObservationType.DEFAULT"></a> | |
| #### DEFAULT | |
| Observation information is generic. | |
| <a name="mlagents_envs.base_env.ObservationType.GOAL_SIGNAL"></a> | |
| #### GOAL\_SIGNAL | |
| Observation contains goal information for current task. | |
| <a name="mlagents_envs.base_env.ObservationSpec"></a> | |
| ## ObservationSpec Objects | |
| ```python | |
| class ObservationSpec(NamedTuple) | |
| ``` | |
| A NamedTuple containing information about the observation of Agents. | |
| - shape is a Tuple of int : It corresponds to the shape of | |
| an observation's dimensions. | |
| - dimension_property is a Tuple of DimensionProperties flag, one flag for each | |
| dimension. | |
| - observation_type is an enum of ObservationType. | |
| <a name="mlagents_envs.base_env.BehaviorSpec"></a> | |
| ## BehaviorSpec Objects | |
| ```python | |
| class BehaviorSpec(NamedTuple) | |
| ``` | |
| A NamedTuple containing information about the observation and action | |
| spaces for a group of Agents under the same behavior. | |
| - observation_specs is a List of ObservationSpec NamedTuple containing | |
| information about the information of the Agent's observations such as their shapes. | |
| The order of the ObservationSpec is the same as the order of the observations of an | |
| agent. | |
| - action_spec is an ActionSpec NamedTuple. | |
| <a name="mlagents_envs.base_env.BaseEnv"></a> | |
| ## BaseEnv Objects | |
| ```python | |
| class BaseEnv(ABC) | |
| ``` | |
| <a name="mlagents_envs.base_env.BaseEnv.step"></a> | |
| #### step | |
| ```python | |
| | @abstractmethod | |
| | step() -> None | |
| ``` | |
| Signals the environment that it must move the simulation forward | |
| by one step. | |
| <a name="mlagents_envs.base_env.BaseEnv.reset"></a> | |
| #### reset | |
| ```python | |
| | @abstractmethod | |
| | reset() -> None | |
| ``` | |
| Signals the environment that it must reset the simulation. | |
| <a name="mlagents_envs.base_env.BaseEnv.close"></a> | |
| #### close | |
| ```python | |
| | @abstractmethod | |
| | close() -> None | |
| ``` | |
| Signals the environment that it must close. | |
| <a name="mlagents_envs.base_env.BaseEnv.behavior_specs"></a> | |
| #### behavior\_specs | |
| ```python | |
| | @property | |
| | @abstractmethod | |
| | behavior_specs() -> MappingType[str, BehaviorSpec] | |
| ``` | |
| Returns a Mapping from behavior names to behavior specs. | |
| Agents grouped under the same behavior name have the same action and | |
| observation specs, and are expected to behave similarly in the | |
| environment. | |
| Note that new keys can be added to this mapping as new policies are instantiated. | |
| <a name="mlagents_envs.base_env.BaseEnv.set_actions"></a> | |
| #### set\_actions | |
| ```python | |
| | @abstractmethod | |
| | set_actions(behavior_name: BehaviorName, action: ActionTuple) -> None | |
| ``` | |
| Sets the action for all of the agents in the simulation for the next | |
| step. The Actions must be in the same order as the order received in | |
| the DecisionSteps. | |
| **Arguments**: | |
| - `behavior_name`: The name of the behavior the agents are part of | |
| - `action`: ActionTuple tuple of continuous and/or discrete action. | |
| Actions are np.arrays with dimensions (n_agents, continuous_size) and | |
| (n_agents, discrete_size), respectively. | |
| <a name="mlagents_envs.base_env.BaseEnv.set_action_for_agent"></a> | |
| #### set\_action\_for\_agent | |
| ```python | |
| | @abstractmethod | |
| | set_action_for_agent(behavior_name: BehaviorName, agent_id: AgentId, action: ActionTuple) -> None | |
| ``` | |
| Sets the action for one of the agents in the simulation for the next | |
| step. | |
| **Arguments**: | |
| - `behavior_name`: The name of the behavior the agent is part of | |
| - `agent_id`: The id of the agent the action is set for | |
| - `action`: ActionTuple tuple of continuous and/or discrete action | |
| Actions are np.arrays with dimensions (1, continuous_size) and | |
| (1, discrete_size), respectively. Note, this initial dimensions of 1 is because | |
| this action is meant for a single agent. | |
| <a name="mlagents_envs.base_env.BaseEnv.get_steps"></a> | |
| #### get\_steps | |
| ```python | |
| | @abstractmethod | |
| | get_steps(behavior_name: BehaviorName) -> Tuple[DecisionSteps, TerminalSteps] | |
| ``` | |
| Retrieves the steps of the agents that requested a step in the | |
| simulation. | |
| **Arguments**: | |
| - `behavior_name`: The name of the behavior the agents are part of | |
| **Returns**: | |
| A tuple containing : | |
| - A DecisionSteps NamedTuple containing the observations, | |
| the rewards, the agent ids and the action masks for the Agents | |
| of the specified behavior. These Agents need an action this step. | |
| - A TerminalSteps NamedTuple containing the observations, | |
| rewards, agent ids and interrupted flags of the agents that had their | |
| episode terminated last step. | |
| <a name="mlagents_envs.environment"></a> | |
| # mlagents\_envs.environment | |
| <a name="mlagents_envs.environment.UnityEnvironment"></a> | |
| ## UnityEnvironment Objects | |
| ```python | |
| class UnityEnvironment(BaseEnv) | |
| ``` | |
| <a name="mlagents_envs.environment.UnityEnvironment.__init__"></a> | |
| #### \_\_init\_\_ | |
| ```python | |
| | __init__(file_name: Optional[str] = None, worker_id: int = 0, base_port: Optional[int] = None, seed: int = 0, no_graphics: bool = False, timeout_wait: int = 60, additional_args: Optional[List[str]] = None, side_channels: Optional[List[SideChannel]] = None, log_folder: Optional[str] = None, num_areas: int = 1) | |
| ``` | |
| Starts a new unity environment and establishes a connection with the environment. | |
| Notice: Currently communication between Unity and Python takes place over an open socket without authentication. | |
| Ensure that the network where training takes place is secure. | |
| :string file_name: Name of Unity environment binary. | |
| :int base_port: Baseline port number to connect to Unity environment over. worker_id increments over this. | |
| If no environment is specified (i.e. file_name is None), the DEFAULT_EDITOR_PORT will be used. | |
| :int worker_id: Offset from base_port. Used for training multiple environments simultaneously. | |
| :bool no_graphics: Whether to run the Unity simulator in no-graphics mode | |
| :int timeout_wait: Time (in seconds) to wait for connection from environment. | |
| :list args: Addition Unity command line arguments | |
| :list side_channels: Additional side channel for no-rl communication with Unity | |
| :str log_folder: Optional folder to write the Unity Player log file into. Requires absolute path. | |
| <a name="mlagents_envs.environment.UnityEnvironment.close"></a> | |
| #### close | |
| ```python | |
| | close() | |
| ``` | |
| Sends a shutdown signal to the unity environment, and closes the socket connection. | |
| <a name="mlagents_envs.registry"></a> | |
| # mlagents\_envs.registry | |
| <a name="mlagents_envs.registry.unity_env_registry"></a> | |
| # mlagents\_envs.registry.unity\_env\_registry | |
| <a name="mlagents_envs.registry.unity_env_registry.UnityEnvRegistry"></a> | |
| ## UnityEnvRegistry Objects | |
| ```python | |
| class UnityEnvRegistry(Mapping) | |
| ``` | |
| ### UnityEnvRegistry | |
| Provides a library of Unity environments that can be launched without the need | |
| of downloading the Unity Editor. | |
| The UnityEnvRegistry implements a Map, to access an entry of the Registry, use: | |
| ```python | |
| registry = UnityEnvRegistry() | |
| entry = registry[<environment_identifyier>] | |
| ``` | |
| An entry has the following properties : | |
| * `identifier` : Uniquely identifies this environment | |
| * `expected_reward` : Corresponds to the reward an agent must obtained for the task | |
| to be considered completed. | |
| * `description` : A human readable description of the environment. | |
| To launch a Unity environment from a registry entry, use the `make` method: | |
| ```python | |
| registry = UnityEnvRegistry() | |
| env = registry[<environment_identifyier>].make() | |
| ``` | |
| <a name="mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.register"></a> | |
| #### register | |
| ```python | |
| | register(new_entry: BaseRegistryEntry) -> None | |
| ``` | |
| Registers a new BaseRegistryEntry to the registry. The | |
| BaseRegistryEntry.identifier value will be used as indexing key. | |
| If two are more environments are registered under the same key, the most | |
| recentry added will replace the others. | |
| <a name="mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.register_from_yaml"></a> | |
| #### register\_from\_yaml | |
| ```python | |
| | register_from_yaml(path_to_yaml: str) -> None | |
| ``` | |
| Registers the environments listed in a yaml file (either local or remote). Note | |
| that the entries are registered lazily: the registration will only happen when | |
| an environment is accessed. | |
| The yaml file must have the following format : | |
| ```yaml | |
| environments: | |
| - <identifier of the first environment>: | |
| expected_reward: <expected reward of the environment> | |
| description: | <a multi line description of the environment> | |
| <continued multi line description> | |
| linux_url: <The url for the Linux executable zip file> | |
| darwin_url: <The url for the OSX executable zip file> | |
| win_url: <The url for the Windows executable zip file> | |
| - <identifier of the second environment>: | |
| expected_reward: <expected reward of the environment> | |
| description: | <a multi line description of the environment> | |
| <continued multi line description> | |
| linux_url: <The url for the Linux executable zip file> | |
| darwin_url: <The url for the OSX executable zip file> | |
| win_url: <The url for the Windows executable zip file> | |
| - ... | |
| ``` | |
| **Arguments**: | |
| - `path_to_yaml`: A local path or url to the yaml file | |
| <a name="mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.clear"></a> | |
| #### clear | |
| ```python | |
| | clear() -> None | |
| ``` | |
| Deletes all entries in the registry. | |
| <a name="mlagents_envs.registry.unity_env_registry.UnityEnvRegistry.__getitem__"></a> | |
| #### \_\_getitem\_\_ | |
| ```python | |
| | __getitem__(identifier: str) -> BaseRegistryEntry | |
| ``` | |
| Returns the BaseRegistryEntry with the provided identifier. BaseRegistryEntry | |
| can then be used to make a Unity Environment. | |
| **Arguments**: | |
| - `identifier`: The identifier of the BaseRegistryEntry | |
| **Returns**: | |
| The associated BaseRegistryEntry | |
| <a name="mlagents_envs.side_channel"></a> | |
| # mlagents\_envs.side\_channel | |
| <a name="mlagents_envs.side_channel.raw_bytes_channel"></a> | |
| # mlagents\_envs.side\_channel.raw\_bytes\_channel | |
| <a name="mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel"></a> | |
| ## RawBytesChannel Objects | |
| ```python | |
| class RawBytesChannel(SideChannel) | |
| ``` | |
| This is an example of what the SideChannel for raw bytes exchange would | |
| look like. Is meant to be used for general research purpose. | |
| <a name="mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.on_message_received"></a> | |
| #### on\_message\_received | |
| ```python | |
| | on_message_received(msg: IncomingMessage) -> None | |
| ``` | |
| Is called by the environment to the side channel. Can be called | |
| multiple times per step if multiple messages are meant for that | |
| SideChannel. | |
| <a name="mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.get_and_clear_received_messages"></a> | |
| #### get\_and\_clear\_received\_messages | |
| ```python | |
| | get_and_clear_received_messages() -> List[bytes] | |
| ``` | |
| returns a list of bytearray received from the environment. | |
| <a name="mlagents_envs.side_channel.raw_bytes_channel.RawBytesChannel.send_raw_data"></a> | |
| #### send\_raw\_data | |
| ```python | |
| | send_raw_data(data: bytearray) -> None | |
| ``` | |
| Queues a message to be sent by the environment at the next call to | |
| step. | |
| <a name="mlagents_envs.side_channel.outgoing_message"></a> | |
| # mlagents\_envs.side\_channel.outgoing\_message | |
| <a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage"></a> | |
| ## OutgoingMessage Objects | |
| ```python | |
| class OutgoingMessage() | |
| ``` | |
| Utility class for forming the message that is written to a SideChannel. | |
| All data is written in little-endian format using the struct module. | |
| <a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.__init__"></a> | |
| #### \_\_init\_\_ | |
| ```python | |
| | __init__() | |
| ``` | |
| Create an OutgoingMessage with an empty buffer. | |
| <a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_bool"></a> | |
| #### write\_bool | |
| ```python | |
| | write_bool(b: bool) -> None | |
| ``` | |
| Append a boolean value. | |
| <a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_int32"></a> | |
| #### write\_int32 | |
| ```python | |
| | write_int32(i: int) -> None | |
| ``` | |
| Append an integer value. | |
| <a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_float32"></a> | |
| #### write\_float32 | |
| ```python | |
| | write_float32(f: float) -> None | |
| ``` | |
| Append a float value. It will be truncated to 32-bit precision. | |
| <a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_float32_list"></a> | |
| #### write\_float32\_list | |
| ```python | |
| | write_float32_list(float_list: List[float]) -> None | |
| ``` | |
| Append a list of float values. They will be truncated to 32-bit precision. | |
| <a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.write_string"></a> | |
| #### write\_string | |
| ```python | |
| | write_string(s: str) -> None | |
| ``` | |
| Append a string value. Internally, it will be encoded to ascii, and the | |
| encoded length will also be written to the message. | |
| <a name="mlagents_envs.side_channel.outgoing_message.OutgoingMessage.set_raw_bytes"></a> | |
| #### set\_raw\_bytes | |
| ```python | |
| | set_raw_bytes(buffer: bytearray) -> None | |
| ``` | |
| Set the internal buffer to a new bytearray. This will overwrite any existing data. | |
| **Arguments**: | |
| - `buffer`: | |
| **Returns**: | |
| <a name="mlagents_envs.side_channel.engine_configuration_channel"></a> | |
| # mlagents\_envs.side\_channel.engine\_configuration\_channel | |
| <a name="mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel"></a> | |
| ## EngineConfigurationChannel Objects | |
| ```python | |
| class EngineConfigurationChannel(SideChannel) | |
| ``` | |
| This is the SideChannel for engine configuration exchange. The data in the | |
| engine configuration is as follows : | |
| - int width; | |
| - int height; | |
| - int qualityLevel; | |
| - float timeScale; | |
| - int targetFrameRate; | |
| - int captureFrameRate; | |
| <a name="mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.on_message_received"></a> | |
| #### on\_message\_received | |
| ```python | |
| | on_message_received(msg: IncomingMessage) -> None | |
| ``` | |
| Is called by the environment to the side channel. Can be called | |
| multiple times per step if multiple messages are meant for that | |
| SideChannel. | |
| Note that Python should never receive an engine configuration from | |
| Unity | |
| <a name="mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.set_configuration_parameters"></a> | |
| #### set\_configuration\_parameters | |
| ```python | |
| | set_configuration_parameters(width: Optional[int] = None, height: Optional[int] = None, quality_level: Optional[int] = None, time_scale: Optional[float] = None, target_frame_rate: Optional[int] = None, capture_frame_rate: Optional[int] = None) -> None | |
| ``` | |
| Sets the engine configuration. Takes as input the configurations of the | |
| engine. | |
| **Arguments**: | |
| - `width`: Defines the width of the display. (Must be set alongside height) | |
| - `height`: Defines the height of the display. (Must be set alongside width) | |
| - `quality_level`: Defines the quality level of the simulation. | |
| - `time_scale`: Defines the multiplier for the deltatime in the | |
| simulation. If set to a higher value, time will pass faster in the | |
| simulation but the physics might break. | |
| - `target_frame_rate`: Instructs simulation to try to render at a | |
| specified frame rate. | |
| - `capture_frame_rate`: Instructs the simulation to consider time between | |
| updates to always be constant, regardless of the actual frame rate. | |
| <a name="mlagents_envs.side_channel.engine_configuration_channel.EngineConfigurationChannel.set_configuration"></a> | |
| #### set\_configuration | |
| ```python | |
| | set_configuration(config: EngineConfig) -> None | |
| ``` | |
| Sets the engine configuration. Takes as input an EngineConfig. | |
| <a name="mlagents_envs.side_channel.side_channel_manager"></a> | |
| # mlagents\_envs.side\_channel.side\_channel\_manager | |
| <a name="mlagents_envs.side_channel.side_channel_manager.SideChannelManager"></a> | |
| ## SideChannelManager Objects | |
| ```python | |
| class SideChannelManager() | |
| ``` | |
| <a name="mlagents_envs.side_channel.side_channel_manager.SideChannelManager.process_side_channel_message"></a> | |
| #### process\_side\_channel\_message | |
| ```python | |
| | process_side_channel_message(data: bytes) -> None | |
| ``` | |
| Separates the data received from Python into individual messages for each | |
| registered side channel and calls on_message_received on them. | |
| **Arguments**: | |
| - `data`: The packed message sent by Unity | |
| <a name="mlagents_envs.side_channel.side_channel_manager.SideChannelManager.generate_side_channel_messages"></a> | |
| #### generate\_side\_channel\_messages | |
| ```python | |
| | generate_side_channel_messages() -> bytearray | |
| ``` | |
| Gathers the messages that the registered side channels will send to Unity | |
| and combines them into a single message ready to be sent. | |
| <a name="mlagents_envs.side_channel.stats_side_channel"></a> | |
| # mlagents\_envs.side\_channel.stats\_side\_channel | |
| <a name="mlagents_envs.side_channel.stats_side_channel.StatsSideChannel"></a> | |
| ## StatsSideChannel Objects | |
| ```python | |
| class StatsSideChannel(SideChannel) | |
| ``` | |
| Side channel that receives (string, float) pairs from the environment, so that they can eventually | |
| be passed to a StatsReporter. | |
| <a name="mlagents_envs.side_channel.stats_side_channel.StatsSideChannel.on_message_received"></a> | |
| #### on\_message\_received | |
| ```python | |
| | on_message_received(msg: IncomingMessage) -> None | |
| ``` | |
| Receive the message from the environment, and save it for later retrieval. | |
| **Arguments**: | |
| - `msg`: | |
| **Returns**: | |
| <a name="mlagents_envs.side_channel.stats_side_channel.StatsSideChannel.get_and_reset_stats"></a> | |
| #### get\_and\_reset\_stats | |
| ```python | |
| | get_and_reset_stats() -> EnvironmentStats | |
| ``` | |
| Returns the current stats, and resets the internal storage of the stats. | |
| **Returns**: | |
| <a name="mlagents_envs.side_channel.incoming_message"></a> | |
| # mlagents\_envs.side\_channel.incoming\_message | |
| <a name="mlagents_envs.side_channel.incoming_message.IncomingMessage"></a> | |
| ## IncomingMessage Objects | |
| ```python | |
| class IncomingMessage() | |
| ``` | |
| Utility class for reading the message written to a SideChannel. | |
| Values must be read in the order they were written. | |
| <a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.__init__"></a> | |
| #### \_\_init\_\_ | |
| ```python | |
| | __init__(buffer: bytes, offset: int = 0) | |
| ``` | |
| Create a new IncomingMessage from the bytes. | |
| <a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.read_bool"></a> | |
| #### read\_bool | |
| ```python | |
| | read_bool(default_value: bool = False) -> bool | |
| ``` | |
| Read a boolean value from the message buffer. | |
| **Arguments**: | |
| - `default_value`: Default value to use if the end of the message is reached. | |
| **Returns**: | |
| The value read from the message, or the default value if the end was reached. | |
| <a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.read_int32"></a> | |
| #### read\_int32 | |
| ```python | |
| | read_int32(default_value: int = 0) -> int | |
| ``` | |
| Read an integer value from the message buffer. | |
| **Arguments**: | |
| - `default_value`: Default value to use if the end of the message is reached. | |
| **Returns**: | |
| The value read from the message, or the default value if the end was reached. | |
| <a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.read_float32"></a> | |
| #### read\_float32 | |
| ```python | |
| | read_float32(default_value: float = 0.0) -> float | |
| ``` | |
| Read a float value from the message buffer. | |
| **Arguments**: | |
| - `default_value`: Default value to use if the end of the message is reached. | |
| **Returns**: | |
| The value read from the message, or the default value if the end was reached. | |
| <a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.read_float32_list"></a> | |
| #### read\_float32\_list | |
| ```python | |
| | read_float32_list(default_value: List[float] = None) -> List[float] | |
| ``` | |
| Read a list of float values from the message buffer. | |
| **Arguments**: | |
| - `default_value`: Default value to use if the end of the message is reached. | |
| **Returns**: | |
| The value read from the message, or the default value if the end was reached. | |
| <a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.read_string"></a> | |
| #### read\_string | |
| ```python | |
| | read_string(default_value: str = "") -> str | |
| ``` | |
| Read a string value from the message buffer. | |
| **Arguments**: | |
| - `default_value`: Default value to use if the end of the message is reached. | |
| **Returns**: | |
| The value read from the message, or the default value if the end was reached. | |
| <a name="mlagents_envs.side_channel.incoming_message.IncomingMessage.get_raw_bytes"></a> | |
| #### get\_raw\_bytes | |
| ```python | |
| | get_raw_bytes() -> bytes | |
| ``` | |
| Get a copy of the internal bytes used by the message. | |
| <a name="mlagents_envs.side_channel.float_properties_channel"></a> | |
| # mlagents\_envs.side\_channel.float\_properties\_channel | |
| <a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel"></a> | |
| ## FloatPropertiesChannel Objects | |
| ```python | |
| class FloatPropertiesChannel(SideChannel) | |
| ``` | |
| This is the SideChannel for float properties shared with Unity. | |
| You can modify the float properties of an environment with the commands | |
| set_property, get_property and list_properties. | |
| <a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.on_message_received"></a> | |
| #### on\_message\_received | |
| ```python | |
| | on_message_received(msg: IncomingMessage) -> None | |
| ``` | |
| Is called by the environment to the side channel. Can be called | |
| multiple times per step if multiple messages are meant for that | |
| SideChannel. | |
| <a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.set_property"></a> | |
| #### set\_property | |
| ```python | |
| | set_property(key: str, value: float) -> None | |
| ``` | |
| Sets a property in the Unity Environment. | |
| **Arguments**: | |
| - `key`: The string identifier of the property. | |
| - `value`: The float value of the property. | |
| <a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.get_property"></a> | |
| #### get\_property | |
| ```python | |
| | get_property(key: str) -> Optional[float] | |
| ``` | |
| Gets a property in the Unity Environment. If the property was not | |
| found, will return None. | |
| **Arguments**: | |
| - `key`: The string identifier of the property. | |
| **Returns**: | |
| The float value of the property or None. | |
| <a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.list_properties"></a> | |
| #### list\_properties | |
| ```python | |
| | list_properties() -> List[str] | |
| ``` | |
| Returns a list of all the string identifiers of the properties | |
| currently present in the Unity Environment. | |
| <a name="mlagents_envs.side_channel.float_properties_channel.FloatPropertiesChannel.get_property_dict_copy"></a> | |
| #### get\_property\_dict\_copy | |
| ```python | |
| | get_property_dict_copy() -> Dict[str, float] | |
| ``` | |
| Returns a copy of the float properties. | |
| **Returns**: | |
| <a name="mlagents_envs.side_channel.environment_parameters_channel"></a> | |
| # mlagents\_envs.side\_channel.environment\_parameters\_channel | |
| <a name="mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel"></a> | |
| ## EnvironmentParametersChannel Objects | |
| ```python | |
| class EnvironmentParametersChannel(SideChannel) | |
| ``` | |
| This is the SideChannel for sending environment parameters to Unity. | |
| You can send parameters to an environment with the command | |
| set_float_parameter. | |
| <a name="mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_float_parameter"></a> | |
| #### set\_float\_parameter | |
| ```python | |
| | set_float_parameter(key: str, value: float) -> None | |
| ``` | |
| Sets a float environment parameter in the Unity Environment. | |
| **Arguments**: | |
| - `key`: The string identifier of the parameter. | |
| - `value`: The float value of the parameter. | |
| <a name="mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_uniform_sampler_parameters"></a> | |
| #### set\_uniform\_sampler\_parameters | |
| ```python | |
| | set_uniform_sampler_parameters(key: str, min_value: float, max_value: float, seed: int) -> None | |
| ``` | |
| Sets a uniform environment parameter sampler. | |
| **Arguments**: | |
| - `key`: The string identifier of the parameter. | |
| - `min_value`: The minimum of the sampling distribution. | |
| - `max_value`: The maximum of the sampling distribution. | |
| - `seed`: The random seed to initialize the sampler. | |
| <a name="mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_gaussian_sampler_parameters"></a> | |
| #### set\_gaussian\_sampler\_parameters | |
| ```python | |
| | set_gaussian_sampler_parameters(key: str, mean: float, st_dev: float, seed: int) -> None | |
| ``` | |
| Sets a gaussian environment parameter sampler. | |
| **Arguments**: | |
| - `key`: The string identifier of the parameter. | |
| - `mean`: The mean of the sampling distribution. | |
| - `st_dev`: The standard deviation of the sampling distribution. | |
| - `seed`: The random seed to initialize the sampler. | |
| <a name="mlagents_envs.side_channel.environment_parameters_channel.EnvironmentParametersChannel.set_multirangeuniform_sampler_parameters"></a> | |
| #### set\_multirangeuniform\_sampler\_parameters | |
| ```python | |
| | set_multirangeuniform_sampler_parameters(key: str, intervals: List[Tuple[float, float]], seed: int) -> None | |
| ``` | |
| Sets a multirangeuniform environment parameter sampler. | |
| **Arguments**: | |
| - `key`: The string identifier of the parameter. | |
| - `intervals`: The lists of min and max that define each uniform distribution. | |
| - `seed`: The random seed to initialize the sampler. | |
| <a name="mlagents_envs.side_channel.side_channel"></a> | |
| # mlagents\_envs.side\_channel.side\_channel | |
| <a name="mlagents_envs.side_channel.side_channel.SideChannel"></a> | |
| ## SideChannel Objects | |
| ```python | |
| class SideChannel(ABC) | |
| ``` | |
| The side channel just get access to a bytes buffer that will be shared | |
| between C# and Python. For example, We will create a specific side channel | |
| for properties that will be a list of string (fixed size) to float number, | |
| that can be modified by both C# and Python. All side channels are passed | |
| to the Env object at construction. | |
| <a name="mlagents_envs.side_channel.side_channel.SideChannel.queue_message_to_send"></a> | |
| #### queue\_message\_to\_send | |
| ```python | |
| | queue_message_to_send(msg: OutgoingMessage) -> None | |
| ``` | |
| Queues a message to be sent by the environment at the next call to | |
| step. | |
| <a name="mlagents_envs.side_channel.side_channel.SideChannel.on_message_received"></a> | |
| #### on\_message\_received | |
| ```python | |
| | @abstractmethod | |
| | on_message_received(msg: IncomingMessage) -> None | |
| ``` | |
| Is called by the environment to the side channel. Can be called | |
| multiple times per step if multiple messages are meant for that | |
| SideChannel. | |
| <a name="mlagents_envs.side_channel.side_channel.SideChannel.channel_id"></a> | |
| #### channel\_id | |
| ```python | |
| | @property | |
| | channel_id() -> uuid.UUID | |
| ``` | |
| **Returns**: | |
| The type of side channel used. Will influence how the data is | |
| processed in the environment. | |