Another line break removal

Author: maryamziaa

com.unity.ml-agents/Documentation~/Background-Machine-Learning.md

@@ -38,17 +38,14 @@ Similar to both unsupervised and supervised learning, reinforcement learning als
 
 One common aspect of all three branches of machine learning is that they all involve a **training phase** and an **inference phase**. While the details of the training and inference phases are different for each of the three, at a high-level, the training phase involves building a model using the provided data, while the inference phase involves applying this model to new, previously unseen, data. More specifically:
 
-- For our unsupervised learning example, the training phase learns the optimal
-two clusters based on the data describing existing players, while the inference phase assigns a new player to one of these two clusters.
-- For our supervised learning example, the training phase learns the mapping
-from player attributes to player label (whether they churned or not), and the inference phase predicts whether a new player will churn or not based on that learned mapping.
-- For our reinforcement learning example, the training phase learns the optimal
-policy through guided trials, and in the inference phase, the agent observes and takes actions in the wild using its learned policy.
+- For our unsupervised learning example, the training phase learns the optimal two clusters based on the data describing existing players, while the inference phase assigns a new player to one of these two clusters.
+- For our supervised learning example, the training phase learns the mapping from player attributes to player label (whether they churned or not), and the inference phase predicts whether a new player will churn or not based on that learned mapping.
+- For our reinforcement learning example, the training phase learns the optimal policy through guided trials, and in the inference phase, the agent observes and takes actions in the wild using its learned policy.
 
 To briefly summarize: all three classes of algorithms involve training and inference phases in addition to attribute and model selections. What ultimately separates them is the type of data available to learn from. In unsupervised learning our data set was a collection of attributes, in supervised learning our data set was a collection of attribute-label pairs, and, lastly, in reinforcement learning our data set was a collection of observation-action-reward tuples.
 
 ## Deep Learning
 
 [Deep learning](https://en.wikipedia.org/wiki/Deep_learning) is a family of algorithms that can be used to address any of the problems introduced above. More specifically, they can be used to solve both attribute and model selection tasks. Deep learning has gained popularity in recent years due to its outstanding performance on several challenging machine learning tasks. One example is [AlphaGo](https://en.wikipedia.org/wiki/AlphaGo), a [computer Go](https://en.wikipedia.org/wiki/Computer_Go) program, that leverages deep learning, that was able to beat Lee Sedol (a Go world champion).
 
-A key characteristic of deep learning algorithms is their ability to learn very complex functions from large amounts of training data. This makes them a natural choice for reinforcement learning tasks when a large amount of data can be generated, say through the use of a simulator or engine such as Unity. By generating hundreds of thousands of simulations of the environment within Unity, we can learn policies for very complex environments (a complex environment is one where the number of observations an agent perceives and the number of actions they can take are large). Many of the algorithms we provide in ML-Agents use some form of deep learning, built on top of the open-source library, [PyTorch](Background-PyTorch.md).
+A key characteristic of deep learning algorithms is their ability to learn very complex functions from large amounts of training data. This makes them a natural choice for reinforcement learning tasks when a large amount of data can be generated, say through the use of a simulator or engine such as Unity. By generating hundreds of thousands of simulations of the environment within Unity, we can learn policies for very complex environments (a complex environment is one where the number of observations an agent perceives and the number of actions they can take are large). Many of the algorithms we provide in ML-Agents use some form of deep learning, built on top of the open-source library, [PyTorch](Background-PyTorch.md).

com.unity.ml-agents/Documentation~/Custom-SideChannels.md

@@ -1,8 +1,6 @@
 # Custom Side Channels
 
-You can create your own side channel in C# and Python and use it to communicate custom data structures between the two. This can be useful for situations in which the data to be sent is too complex or structured for the built-in
-`EnvironmentParameters`, or is not related to any specific agent, and therefore
-inappropriate as an agent observation.
+You can create your own side channel in C# and Python and use it to communicate custom data structures between the two. This can be useful for situations in which the data to be sent is too complex or structured for the built-in `EnvironmentParameters`, or is not related to any specific agent, and therefore inappropriate as an agent observation.
 
 ## Overview
 
@@ -12,24 +10,19 @@ In order to use a side channel, it must be implemented as both Unity and Python
 
 The side channel will have to implement the `SideChannel` abstract class and the following method.
 
-- `OnMessageReceived(IncomingMessage msg)` : You must implement this method and
-read the data from IncomingMessage. The data must be read in the order that it was written.
+- `OnMessageReceived(IncomingMessage msg)` : You must implement this method and read the data from IncomingMessage. The data must be read in the order that it was written.
 
-The side channel must also assign a `ChannelId` property in the constructor. The
-`ChannelId` is a Guid (or UUID in Python) used to uniquely identify a side
-channel. This Guid must be the same on C# and Python. There can only be one side channel of a certain id during communication.
+The side channel must also assign a `ChannelId` property in the constructor. The `ChannelId` is a Guid (or UUID in Python) used to uniquely identify a side channel. This Guid must be the same on C# and Python. There can only be one side channel of a certain id during communication.
 
 To send data from C# to Python, create an `OutgoingMessage` instance, add data to it, call the `base.QueueMessageToSend(msg)` method inside the side channel, and call the `OutgoingMessage.Dispose()` method.
 
-To register a side channel on the Unity side, call
-`SideChannelManager.RegisterSideChannel` with the side channel as only argument.
+To register a side channel on the Unity side, call `SideChannelManager.RegisterSideChannel` with the side channel as only argument.
 
 ### Python side
 
 The side channel will have to implement the `SideChannel` abstract class. You must implement :
 
-- `on_message_received(self, msg: "IncomingMessage") -> None` : You must
-implement this method and read the data from IncomingMessage. The data must be read in the order that it was written.
+- `on_message_received(self, msg: "IncomingMessage") -> None` : You must implement this method and read the data from IncomingMessage. The data must be read in the order that it was written.
 
 The side channel must also assign a `channel_id` property in the constructor. The `channel_id` is a UUID (referred in C# as Guid) used to uniquely identify a side channel. This number must be the same on C# and Python. There can only be one side channel of a certain id during communication.
 
@@ -191,4 +184,4 @@ for i in range(1000):
 env.close()
 ```
 
-Now, if you run this script and press `Play` the Unity Editor when prompted, the console in the Unity Editor will display a message at every Python step. Additionally, if you press the Space Bar in the Unity Engine, a message will appear in the terminal.
+Now, if you run this script and press `Play` the Unity Editor when prompted, the console in the Unity Editor will display a message at every Python step. Additionally, if you press the Space Bar in the Unity Engine, a message will appear in the terminal.

com.unity.ml-agents/Documentation~/FAQ.md

@@ -31,22 +31,14 @@ UnityAgentsException: The Communicator was unable to connect. Please make sure t
 There may be a number of possible causes:
 
 - _Cause_: There may be no agent in the scene
-- _Cause_: On OSX, the firewall may be preventing communication with the
-environment. _Solution_: Add the built environment binary to the list of exceptions on the firewall by following [instructions](https://support.apple.com/en-us/HT201642).
-- _Cause_: An error happened in the Unity Environment preventing communication.
-_Solution_: Look into the [log files](https://docs.unity3d.com/Manual/LogFiles.html) generated by the Unity Environment to figure what error happened.
-- _Cause_: You have assigned `HTTP_PROXY` and `HTTPS_PROXY` values in your
-environment variables. _Solution_: Remove these values and try again.
-- _Cause_: You are running in a headless environment (e.g. remotely connected
-to a server). _Solution_: Pass `--no-graphics` to `mlagents-learn`, or
-  `no_graphics=True` to `RemoteRegistryEntry.make()` or the `UnityEnvironment`
-initializer. If you need graphics for visual observations, you will need to set up `xvfb` (or equivalent).
+- _Cause_: On OSX, the firewall may be preventing communication with the environment. _Solution_: Add the built environment binary to the list of exceptions on the firewall by following [instructions](https://support.apple.com/en-us/HT201642).
+- _Cause_: An error happened in the Unity Environment preventing communication. _Solution_: Look into the [log files](https://docs.unity3d.com/Manual/LogFiles.html) generated by the Unity Environment to figure what error happened.
+- _Cause_: You have assigned `HTTP_PROXY` and `HTTPS_PROXY` values in your environment variables. _Solution_: Remove these values and try again.
+- _Cause_: You are running in a headless environment (e.g. remotely connected to a server). _Solution_: Pass `--no-graphics` to `mlagents-learn`, or `no_graphics=True` to `RemoteRegistryEntry.make()` or the `UnityEnvironment` initializer. If you need graphics for visual observations, you will need to set up `xvfb` (or equivalent).
 
 ## Communication port {} still in use
 
-If you receive an exception
-`"Couldn't launch new environment because communication port {} is still in use. "`,
-you can change the worker number in the Python script when calling
+If you receive an exception `"Couldn't launch new environment because communication port {} is still in use. "`, you can change the worker number in the Python script when calling
 
 ```python
 UnityEnvironment(file_name=filename, worker_id=X)
@@ -58,4 +50,4 @@ If you receive a message `Mean reward : nan` when attempting to train a model us
 
 ## "File name" cannot be opened because the developer cannot be verified.
 
-If you have downloaded the repository using the github website on macOS 10.15 (Catalina) or later, you may see this error when attempting to play scenes in the Unity project. Workarounds include installing the package using the Unity Package Manager (this is the officially supported approach - see [here](Installation.md)), or following the instructions [here](https://support.apple.com/en-us/HT202491) to verify the relevant files on your machine on a file-by-file basis.
+If you have downloaded the repository using the github website on macOS 10.15 (Catalina) or later, you may see this error when attempting to play scenes in the Unity project. Workarounds include installing the package using the Unity Package Manager (this is the officially supported approach - see [here](Installation.md)), or following the instructions [here](https://support.apple.com/en-us/HT202491) to verify the relevant files on your machine on a file-by-file basis.

com.unity.ml-agents/Documentation~/Get-Started.md

@@ -1,15 +1,11 @@
 # Get started
 The ML-Agents Toolkit contains several main components:
 
-- Unity package `com.unity.ml-agents` contains the
-Unity C# SDK that will be integrated into your Unity project.
+- Unity package `com.unity.ml-agents` contains the Unity C# SDK that will be integrated into your Unity project.
 - Two Python packages:
-  - `mlagents` contains the machine learning algorithms that
-enables you to train behaviors in your Unity scene. Most users of ML-Agents will only need to directly install `mlagents`.
-  - `mlagents_envs` contains a set of Python APIs to interact with
-a Unity scene. It is a foundational layer that facilitates data messaging between Unity scene and the Python machine learning algorithms. Consequently, `mlagents` depends on `mlagents_envs`.
-- Unity [Project](https://github.com/Unity-Technologies/ml-agents/tree/main/Project/Assets/ML-Agents/Examples) that contains several
-[example environments](Learning-Environment-Examples.md) that highlight the various features of the toolkit to help you get started.
+  - `mlagents` contains the machine learning algorithms that enables you to train behaviors in your Unity scene. Most users of ML-Agents will only need to directly install `mlagents`.
+  - `mlagents_envs` contains a set of Python APIs to interact with a Unity scene. It is a foundational layer that facilitates data messaging between Unity scene and the Python machine learning algorithms. Consequently, `mlagents` depends on `mlagents_envs`.
+- Unity [Project](https://github.com/Unity-Technologies/ml-agents/tree/main/Project/Assets/ML-Agents/Examples) that contains several [example environments](Learning-Environment-Examples.md) that highlight the various features of the toolkit to help you get started.
 
 Use the following topics to get started with ML-Agents.
 

com.unity.ml-agents/Documentation~/Inference-Engine.md

@@ -6,19 +6,15 @@ The ML-Agents Toolkit allows you to use pre-trained neural network models inside
 
 Inference Engine supports [all Unity runtime platforms](https://docs.unity3d.com/Manual/PlatformSpecific.html).
 
-Scripting Backends : Inference Engine is generally faster with
-**IL2CPP** than with **Mono** for Standalone builds. In the Editor, It is not
-possible to use Inference Engine with GPU device selected when Editor Graphics Emulation is set to **OpenGL(ES) 3.0 or 2.0 emulation**. Also there might be non-fatal build time errors when target platform includes Graphics API that does not support **Unity Compute Shaders**.
+Scripting Backends : Inference Engine is generally faster with **IL2CPP** than with **Mono** for Standalone builds. In the Editor, It is not possible to use Inference Engine with GPU device selected when Editor Graphics Emulation is set to **OpenGL(ES) 3.0 or 2.0 emulation**. Also there might be non-fatal build time errors when target platform includes Graphics API that does not support **Unity Compute Shaders**.
 
 In cases when it is not possible to use compute shaders on the target platform, inference can be performed using **CPU** or **GPUPixel** Inference Engine backends.
 
 ## Using Inference Engine
 
-When using a model, drag the model file into the **Model** field in the Inspector of the Agent. Select the **Inference Device**: **Compute Shader**, **Burst** or
-**Pixel Shader** you want to use for inference.
+When using a model, drag the model file into the **Model** field in the Inspector of the Agent. Select the **Inference Device**: **Compute Shader**, **Burst** or **Pixel Shader** you want to use for inference.
 
-**Note:** For most of the models generated with the ML-Agents Toolkit, CPU inference (**Burst**) will
-be faster than GPU inference (**Compute Shader** or **Pixel Shader**). You should use GPU inference only if you use the ResNet visual encoder or have a large number of agents with visual observations.
+**Note:** For most of the models generated with the ML-Agents Toolkit, CPU inference (**Burst**) will be faster than GPU inference (**Compute Shader** or **Pixel Shader**). You should use GPU inference only if you use the ResNet visual encoder or have a large number of agents with visual observations.
 
 # Unsupported use cases
 ## Externally trained models
@@ -27,4 +23,4 @@ The ML-Agents Toolkit only supports the models created with our trainers. Model
 If you wish to run inference on an externally trained model, you should use Inference Engine directly, instead of trying to run it through ML-Agents.
 
 ## Model inference outside of Unity
-We do not provide support for inference anywhere outside of Unity. The `.onnx` files produced by training use the open format ONNX; if you wish to convert a `.onnx` file to another format or run inference with them, refer to their documentation.
+We do not provide support for inference anywhere outside of Unity. The `.onnx` files produced by training use the open format ONNX; if you wish to convert a `.onnx` file to another format or run inference with them, refer to their documentation.

com.unity.ml-agents/Documentation~/InputSystem-Integration.md

@@ -7,9 +7,9 @@ Take a look at how we have implemented the C# code in the example Input Integrat
 ## Getting Started with Input System Integration
 1. Add the `com.unity.inputsystem` version 1.1.0-preview.3 or later to your project via the Package Manager window.
 2. If you have already setup an InputActionAsset skip to Step 3, otherwise follow these sub steps:
-1. Create an InputActionAsset to allow your Agent to be controlled by the Input System.
-2. Handle the events from the Input System where you normally would (i.e. a script external to your Agent class).
-3. Add the InputSystemActuatorComponent to the GameObject that has the `PlayerInput` and `Agent` components attached.
+3. Create an InputActionAsset to allow your Agent to be controlled by the Input System.
+4. Handle the events from the Input System where you normally would (i.e. a script external to your Agent class).
+5. Add the InputSystemActuatorComponent to the GameObject that has the `PlayerInput` and `Agent` components attached.
 
 Additionally, see below for additional technical specifications on the C# code for the InputActuatorComponent.
 ## Technical Specifications
@@ -22,8 +22,7 @@ that if multiple `Components` on your `GameObject` need to access an `InputActio
 
 ### `InputActuatorComponent` Class
 The `InputActuatorComponent` is the bridge between ML-Agents and the Input System. It allows ML-Agents to:
-* create an `ActionSpec` for your Agent based on an `InputActionAsset` that comes from an
-  `IInputActionAssetProvider`.
+* create an `ActionSpec` for your Agent based on an `InputActionAsset` that comes from an `IInputActionAssetProvider`.
 * send simulated input from a training process or a neural network
 * let developers keep their input handling code in one place