Merge pull request #1083 from Unity-Technologies/develop-flat-code-restructure

ML-Agents Code Restructure

.gitignore

-/unity-environment/[Ll]ibrary/
-/unity-environment/[Tt]emp/
-/unity-environment/[Oo]bj/
-/unity-environment/[Bb]uild/
-/unity-environment/[Bb]uilds/
-/unity-environment/[Pp]ackages/
-/unity-environment/[Uu]nity[Pp]ackage[Mm]anager/
-/unity-environment/Assets/AssetStoreTools*
-/unity-environment/Assets/Plugins*
-/unity-environment/Assets/Gizmos*
+/MLAgentsSDK/[Ll]ibrary/
+/MLAgentsSDK/[Tt]emp/
+/MLAgentsSDK/[Oo]bj/
+/MLAgentsSDK/[Bb]uild/
+/MLAgentsSDK/[Bb]uilds/
+/MLAgentsSDK/[Pp]ackages/
+/MLAgentsSDK/[Uu]nity[Pp]ackage[Mm]anager/
+/MLAgentsSDK/Assets/AssetStoreTools*
+/MLAgentsSDK/Assets/Plugins*
+/MLAgentsSDK/Assets/Gizmos*
-python/models
-python/summaries
-*unity-environment.log
+*MLAgentsSDK.log
-/unity-environment/.vs/
+/MLAgentsSDK/.vs/
-/unity-environmentExportedObj/
-/unity-environment.consulo/
+/MLAgentsSDKExportedObj/
+/MLAgentsSDK.consulo/
 *.csproj
 *.unityproj
 *.sln
 *.pidb.meta
 
 # Unity3D Generated File On Crash Reports
-/unity-environment/sysinfo.txt
+/MLAgentsSDK/sysinfo.txt
 
 # Builds
 *.apk
 *.x86
 
 # Tensorflow Sharp Files
-/unity-environment/Assets/ML-Agents/Plugins/Android*
-/unity-environment/Assets/ML-Agents/Plugins/iOS*
-/unity-environment/Assets/ML-Agents/Plugins/Computer*
-/unity-environment/Assets/ML-Agents/Plugins/System*
+/MLAgentsSDK/Assets/ML-Agents/Plugins/Android*
+/MLAgentsSDK/Assets/ML-Agents/Plugins/iOS*
+/MLAgentsSDK/Assets/ML-Agents/Plugins/Computer*
+/MLAgentsSDK/Assets/ML-Agents/Plugins/System*
 
 # Generated doc folders
 /docs/html
 
 # pytest cache 
 *.pytest_cache/
+
+# Ignore compiled protobuf files.
+ml-agents-protobuf/cs
+ml-agents-protobuf/python
+ml-agents-protobuf/Grpc*
+
+# Ignore PyPi build files.
+dist/
+build/

Dockerfile

 RUN apt-get install -y xvfb
 
 
-ADD python/requirements.txt .
+COPY ml-agents/requirements.txt .
-WORKDIR /execute
-COPY python /execute/python
+COPY README.md .
+COPY ml-agents /ml-agents
+WORKDIR /ml-agents
+RUN pip install .
-ENTRYPOINT ["python", "python/learn.py"]
+ENTRYPOINT ["python", "mlagents/learn.py"]

docs/API-Reference.md

 # API Reference
 
-Our developer-facing C# classes (Academy, Agent, Decision and 
-Monitor) have been documented to be compatabile with 
-[Doxygen](http://www.stack.nl/~dimitri/doxygen/) for auto-generating HTML 
+Our developer-facing C# classes (Academy, Agent, Decision and Monitor) have been
+documented to be compatabile with
+[Doxygen](http://www.stack.nl/~dimitri/doxygen/) for auto-generating HTML
-To generate the API reference, 
-[download Doxygen](http://www.stack.nl/~dimitri/doxygen/download.html) and run
-the following command within the `docs/` directory:
+To generate the API reference, [download
+Doxygen](http://www.stack.nl/~dimitri/doxygen/download.html) and run the
+following command within the `docs/` directory:
-that includes the classes that have been properly formatted. 
-The generated HTML files will be placed
-in the `html/` subdirectory. Open `index.html` within that subdirectory to 
-navigate to the API reference home. Note that `html/` is already included in 
-the repository's `.gitignore` file.
+that includes the classes that have been properly formatted. The generated HTML
+files will be placed in the `html/` subdirectory. Open `index.html` within that
+subdirectory to navigate to the API reference home. Note that `html/` is already
+included in the repository's `.gitignore` file.
-In the near future, we aim to expand our documentation
-to include all the Unity C# classes and Python API.
+In the near future, we aim to expand our documentation to include all the Unity
+C# classes and Python API.

docs/Background-Jupyter.md

 # Background: Jupyter
 
-[Jupyter](https://jupyter.org) is a fantastic tool for writing code with 
-embedded visualizations. We provide one such notebook, `python/notebooks/getting-started.ipynb`, 
-for testing the Python control interface to a Unity build. This notebook is 
-introduced in the 
-[Getting Started with the 3D Balance Ball Environment](Getting-Started-with-Balance-Ball.md)
+[Jupyter](https://jupyter.org) is a fantastic tool for writing code with
+embedded visualizations. We provide one such notebook,
+`notebooks/getting-started.ipynb`, for testing the Python control
+interface to a Unity build. This notebook is introduced in the [Getting Started
+with the 3D Balance Ball Environment](Getting-Started-with-Balance-Ball.md)
-in the _Jupyter/IPython Quick Start Guide_. To launch Jupyter, run in the command line:
+in the _Jupyter/IPython Quick Start Guide_. To launch Jupyter, run in the
+command line:
-`jupyter notebook`
+    jupyter notebook
 
 Then navigate to `localhost:8888` to access your notebooks.

docs/Basic-Guide.md

 # Basic Guide
 
-This guide will show you how to use a pretrained model in an example Unity environment, and show you how to train the model yourself.
+This guide will show you how to use a pretrained model in an example Unity
+environment, and show you how to train the model yourself.
-If you are not familiar with the [Unity Engine](https://unity3d.com/unity),
-we highly recommend the [Roll-a-ball tutorial](https://unity3d.com/learn/tutorials/s/roll-ball-tutorial) to learn all the basic concepts of Unity. 
+If you are not familiar with the [Unity Engine](https://unity3d.com/unity), we
+highly recommend the [Roll-a-ball
+tutorial](https://unity3d.com/learn/tutorials/s/roll-ball-tutorial) to learn all
+the basic concepts of Unity.
-In order to use the ML-Agents toolkit within Unity, you need to change some Unity settings first. Also [TensorFlowSharp plugin](https://s3.amazonaws.com/unity-ml-agents/0.4/TFSharpPlugin.unitypackage) is needed for you to use pretrained model within Unity, which is based on the [TensorFlowSharp repo](https://github.com/migueldeicaza/TensorFlowSharp). 
+In order to use the ML-Agents toolkit within Unity, you need to change some
+Unity settings first. Also [TensorFlowSharp
+plugin](https://s3.amazonaws.com/unity-ml-agents/0.4/TFSharpPlugin.unitypackage)
+is needed for you to use pretrained model within Unity, which is based on the
+[TensorFlowSharp repo](https://github.com/migueldeicaza/TensorFlowSharp).
-3. Using the file dialog that opens, locate the `unity-environment` folder within the the ML-Agents toolkit project and click **Open**.
+3. Using the file dialog that opens, locate the `MLAgentsSDK` folder
+   within the the ML-Agents toolkit project and click **Open**.
-5. For **each** of the platforms you target 
-(**PC, Mac and Linux Standalone**, **iOS** or **Android**):
+5. For **each** of the platforms you target (**PC, Mac and Linux Standalone**,
+   **iOS** or **Android**):
-    2. Select **Scripting Runtime Version** to 
-    **Experimental (.NET 4.6 Equivalent or .NET 4.x Equivalent)**
-    3. In **Scripting Defined Symbols**, add the flag `ENABLE_TENSORFLOW`. 
-    After typing in the flag name, press Enter.
+    2. Select **Scripting Runtime Version** to **Experimental (.NET 4.6
+       Equivalent or .NET 4.x Equivalent)**
+    3. In **Scripting Defined Symbols**, add the flag `ENABLE_TENSORFLOW`. After
+       typing in the flag name, press Enter.
-[Download](https://s3.amazonaws.com/unity-ml-agents/0.4/TFSharpPlugin.unitypackage) the TensorFlowSharp plugin. Then import it into Unity by double clicking the downloaded file.  You can check if it was successfully imported by checking the TensorFlow files in the Project window under **Assets** > **ML-Agents** > **Plugins** > **Computer**. 
+[Download](https://s3.amazonaws.com/unity-ml-agents/0.4/TFSharpPlugin.unitypackage)
+the TensorFlowSharp plugin. Then import it into Unity by double clicking the
+downloaded file.  You can check if it was successfully imported by checking the
+TensorFlow files in the Project window under **Assets** > **ML-Agents** >
+**Plugins** > **Computer**.
-**Note**: If you don't see anything under **Assets**, drag the `ml-agents/unity-environment/Assets/ML-Agents` folder under **Assets** within Project window.
+**Note**: If you don't see anything under **Assets**, drag the
+`MLAgentsSDK/Assets/ML-Agents` folder under **Assets** within
+Project window.
-1. In the **Project** window, go to `Assets/ML-Agents/Examples/3DBall` folder and open the `3DBall` scene file. 
-2. In the **Hierarchy** window, select the **Ball3DBrain** child under the **Ball3DAcademy** GameObject to view its properties in the Inspector window.
-3. On the **Ball3DBrain** object's **Brain** component, change the **Brain Type** to **Internal**.
-4. In the **Project** window, locate the `Assets/ML-Agents/Examples/3DBall/TFModels` folder.
-5. Drag the `3DBall` model file from the `TFModels` folder to the **Graph Model** field of the **Ball3DBrain** object's **Brain** component.
-5. Click the **Play** button and you will see the platforms balance the balls using the pretrained model.
+1. In the **Project** window, go to `Assets/ML-Agents/Examples/3DBall` folder
+   and open the `3DBall` scene file.
+2. In the **Hierarchy** window, select the **Ball3DBrain** child under the
+   **Ball3DAcademy** GameObject to view its properties in the Inspector window.
+3. On the **Ball3DBrain** object's **Brain** component, change the **Brain
+   Type** to **Internal**.
+4. In the **Project** window, locate the
+   `Assets/ML-Agents/Examples/3DBall/TFModels` folder.
+5. Drag the `3DBall` model file from the `TFModels` folder to the **Graph
+   Model** field of the **Ball3DBrain** object's **Brain** component.
+6. Click the **Play** button and you will see the platforms balance the balls
+   using the pretrained model.
-The `python/Basics` [Jupyter notebook](Background-Jupyter.md) contains a 
-simple walkthrough of the functionality of the Python 
-API. It can also serve as a simple test that your environment is configured
-correctly. Within `Basics`, be sure to set `env_name` to the name of the 
-Unity executable if you want to [use an executable](Learning-Environment-Executable.md) or to `None` if you want to interact with the current scene in the Unity Editor.
+The `notebooks/getting-started.ipynb` [Jupyter notebook](Background-Jupyter.md)
+contains a simple walkthrough of the functionality of the Python API. It can
+also serve as a simple test that your environment is configured correctly.
+Within `Basics`, be sure to set `env_name` to the name of the Unity executable
+if you want to [use an executable](Learning-Environment-Executable.md) or to
+`None` if you want to interact with the current scene in the Unity Editor.
+
-Since we are going to build this environment to conduct training, we need to 
-set the brain used by the agents to **External**. This allows the agents to 
+
+Since we are going to build this environment to conduct training, we need to set
+the brain used by the agents to **External**. This allows the agents to
-1. In the **Scene** window, click the triangle icon next to the Ball3DAcademy 
-object.
+1. In the **Scene** window, click the triangle icon next to the Ball3DAcademy
+   object.
 2. Select its child object **Ball3DBrain**.
 3. In the Inspector window, set **Brain Type** to **External**.
 
-1. Open a command or terminal window. 
-2. Nagivate to the folder where you installed the ML-Agents toolkit. 
-3. Change to the `python` directory. 
-4. Run `python3 learn.py --run-id=<run-identifier> --train`
-Where:
-- `<run-identifier>` is a string used to separate the results of different training runs
-- And the `--train` tells learn.py to run a training session (rather than inference)
-5. When the message _"Start training by pressing the Play button in the Unity Editor"_ is displayed on the screen, you can press the :arrow_forward: button in Unity to start training in the Editor.
+
+1. Open a command or terminal window.
+2. Nagivate to the folder where you installed the ML-Agents toolkit.
+3. Run `mlagents-learn <trainer-config-path> --run-id=<run-identifier> --train`
+   Where:
+    - `<trainer-config-path>` is the relative or absolute filepath of the
+      trainer configuration. The defaults used by environments in the ML-Agents
+      SDK can be found in `config/trainer_config.yaml`.
+    - `<run-identifier>` is a string used to separate the results of different
+      training runs
+    - And the `--train` tells `mlagents-learn` to run a training session (rather
+      than inference)
+5. When the message _"Start training by pressing the Play button in the Unity
+   Editor"_ is displayed on the screen, you can press the :arrow_forward: button
+   in Unity to start training in the Editor.
-**Note**: Alternatively, you can use an executable rather than the Editor to perform training. Please refer to [this page](Learning-Environment-Executable.md) for instructions on how to build and use an executable.
+**Note**: Alternatively, you can use an executable rather than the Editor to
+perform training. Please refer to [this
+page](Learning-Environment-Executable.md) for instructions on how to build and
+use an executable.
-**Note**: If you're using Anaconda, don't forget to activate the ml-agents environment first.
+**Note**: If you're using Anaconda, don't forget to activate the ml-agents
+environment first.
-If the learn.py runs correctly and starts training, you should see something like this:
+If `mlagents-learn` runs correctly and starts training, you should see something
+like this:
-You can press Ctrl+C to stop the training, and your trained model will be at `ml-agents/python/models/<run-identifier>/editor_<academy_name>_<run-identifier>.bytes` where `<academy_name>` is the name of the Academy GameObject in the current scene. This file corresponds to your model's latest checkpoint. You can now embed this trained model into your internal brain by following the steps below, which is similar to the steps described [above](#play-an-example-environment-using-pretrained-model).  
-1. Move your model file into 
-`unity-environment/Assets/ML-Agents/Examples/3DBall/TFModels/`.
+You can press Ctrl+C to stop the training, and your trained model will be at
+`models/<run-identifier>/editor_<academy_name>_<run-identifier>.bytes` where
+`<academy_name>` is the name of the Academy GameObject in the current scene.
+This file corresponds to your model's latest checkpoint. You can now embed this
+trained model into your internal brain by following the steps below, which is
+similar to the steps described
+[above](#play-an-example-environment-using-pretrained-model).
+
+1. Move your model file into
+   `MLAgentsSDK/Assets/ML-Agents/Examples/3DBall/TFModels/`.
-5. Drag the `<env_name>_<run-identifier>.bytes` file from the Project window of the Editor
-to the **Graph Model** placeholder in the **Ball3DBrain** inspector window.
+5. Drag the `<env_name>_<run-identifier>.bytes` file from the Project window of
+   the Editor to the **Graph Model** placeholder in the **Ball3DBrain**
+   inspector window.
-* For more information on the ML-Agents toolkit, in addition to helpful background, check out the [ML-Agents Toolkit Overview](ML-Agents-Overview.md) page.
-* For a more detailed walk-through of our 3D Balance Ball environment, check out the [Getting Started](Getting-Started-with-Balance-Ball.md) page.
-* For a "Hello World" introduction to creating your own learning environment, check out the [Making a New Learning Environment](Learning-Environment-Create-New.md) page.
-* For a series of Youtube video tutorials, checkout the [Machine Learning Agents PlayList](https://www.youtube.com/playlist?list=PLX2vGYjWbI0R08eWQkO7nQkGiicHAX7IX) page. 
+- For more information on the ML-Agents toolkit, in addition to helpful
+  background, check out the [ML-Agents Toolkit Overview](ML-Agents-Overview.md)
+  page.
+- For a more detailed walk-through of our 3D Balance Ball environment, check out
+  the [Getting Started](Getting-Started-with-Balance-Ball.md) page.
+- For a "Hello World" introduction to creating your own learning environment,
+  check out the [Making a New Learning
+  Environment](Learning-Environment-Create-New.md) page.
+- For a series of Youtube video tutorials, checkout the [Machine Learning Agents
+  PlayList](https://www.youtube.com/playlist?list=PLX2vGYjWbI0R08eWQkO7nQkGiicHAX7IX)
+  page.

docs/FAQ.md

 # Frequently Asked Questions
 
-
-### Scripting Runtime Environment not setup correctly
+## Scripting Runtime Environment not setup correctly
-If you haven't switched your scripting runtime version from .NET 3.5 to .NET 4.6 or .NET 4.x, you will see such error message:
+If you haven't switched your scripting runtime version from .NET 3.5 to .NET 4.6
+or .NET 4.x, you will see such error message:
-This is because .NET 3.5 doesn't support method Clear() for StringBuilder, refer to [Setting Up The ML-Agents Toolkit Within Unity](Installation.md#setting-up-ml-agent-within-unity) for solution. 
+This is because .NET 3.5 doesn't support method Clear() for StringBuilder, refer
+to [Setting Up The ML-Agents Toolkit Within
+Unity](Installation.md#setting-up-ml-agent-within-unity) for solution.
-### TensorFlowSharp flag not turned on. 
+## TensorFlowSharp flag not turned on
-If you have already imported the TensorFlowSharp plugin, but havn't set ENABLE_TENSORFLOW flag for your scripting define symbols, you will see the following error message:
+If you have already imported the TensorFlowSharp plugin, but havn't set
+ENABLE_TENSORFLOW flag for your scripting define symbols, you will see the
+following error message:
-You need to install and enable the TensorFlowSharp plugin in order to use the internal brain. 
+You need to install and enable the TensorFlowSharp plugin in order to use the internal brain.
-This error message occurs because the TensorFlowSharp plugin won't be usage without the ENABLE_TENSORFLOW flag, refer to [Setting Up The ML-Agents Toolkit Within Unity](Installation.md#setting-up-ml-agent-within-unity) for solution. 
+This error message occurs because the TensorFlowSharp plugin won't be usage
+without the ENABLE_TENSORFLOW flag, refer to [Setting Up The ML-Agents Toolkit
+Within Unity](Installation.md#setting-up-ml-agent-within-unity) for solution.
-### Tensorflow epsilon placeholder error
+## Tensorflow epsilon placeholder error
-If you have a graph placeholder set in the internal Brain inspector that is not present in the TensorFlow graph, you will see some error like this:
+If you have a graph placeholder set in the internal Brain inspector that is not
+present in the TensorFlow graph, you will see some error like this:
-UnityAgentsException: One of the Tensorflow placeholder could not be found. In brain <some_brain_name>, there are no FloatingPoint placeholder named <some_placeholder_name>. 
+UnityAgentsException: One of the Tensorflow placeholder could not be found. In brain <some_brain_name>, there are no FloatingPoint placeholder named <some_placeholder_name>.
-Solution: Go to all of your Brain object, find `Graph placeholders` and change its `size` to 0 to remove the `epsilon` placeholder. 
+Solution: Go to all of your Brain object, find `Graph placeholders` and change
+its `size` to 0 to remove the `epsilon` placeholder.
-Similarly, if you have a graph scope set in the internal Brain inspector that is not correctly set, you will see some error like this:
+Similarly, if you have a graph scope set in the internal Brain inspector that is
+not correctly set, you will see some error like this:
-Solution: Make sure your Graph Scope field matches the corresponding brain object name in your Hierachy Inspector when there is multiple brain. 
+Solution: Make sure your Graph Scope field matches the corresponding brain
+object name in your Hierachy Inspector when there is multiple brain.
-### Environment Permission Error
+## Environment Permission Error
-If you directly import your Unity environment without building it in the 
-editor, you might need to give it additional permissions to execute it. 
+If you directly import your Unity environment without building it in the
+editor, you might need to give it additional permissions to execute it.
-`chmod -R 755 *.app` 
+```shell
+chmod -R 755 *.app
+```
-`chmod -R 755 *.x86_64` 
+```shell
+chmod -R 755 *.x86_64
+```
-On Windows, you can find 
+On Windows, you can find
-### Environment Connection Timeout
+## Environment Connection Timeout
+
+If you are able to launch the environment from `UnityEnvironment` but then
+receive a timeout error, there may be a number of possible causes.
-If you are able to launch the environment from `UnityEnvironment` but 
-then receive a timeout error, there may be a number of possible causes.
- * _Cause_: There may be no Brains in your environment which are set 
- to `External`.  In this case, the environment will not attempt to 
- communicate with python. _Solution_: Set the Brains(s) you wish to 
- externally control through the Python API to `External` from the 
- Unity Editor, and rebuild the environment.
- * _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_: There may be no Brains in your environment which are set to
+  `External`.  In this case, the environment will not attempt to communicate
+  with python. _Solution_: Set the Brains(s) you wish to externally control
+  through the Python API to `External` from the Unity Editor, and rebuild the
+  environment.
+* _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.
-### Communication port {} still in use
+## 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
-`UnityEnvironment(file_name=filename, worker_id=X)`
+```python
+UnityEnvironment(file_name=filename, worker_id=X)
+```
-### Mean reward : nan
+## Mean reward : nan
-If you receive a message `Mean reward : nan` when attempting to train a 
-model using PPO, this is due to the episodes of the learning environment 
-not terminating. In order to address this, set `Max Steps` for either 
-the Academy or Agents within the Scene Inspector to a value greater 
-than 0. Alternatively, it is possible to manually set `done` conditions 
-for episodes from within scripts for custom episode-terminating events.
+If you receive a message `Mean reward : nan` when attempting to train a model
+using PPO, this is due to the episodes of the learning environment not
+terminating. In order to address this, set `Max Steps` for either the Academy or
+Agents within the Scene Inspector to a value greater than 0. Alternatively, it
+is possible to manually set `done` conditions for episodes from within scripts
+for custom episode-terminating events.

docs/Feature-Memory.md

 track of what is important to remember with [LSTM](https://en.wikipedia.org/wiki/Long_short-term_memory). 
 
 ## How to use
-When configuring the trainer parameters in the `trainer_config.yaml` 
+When configuring the trainer parameters in the `config/trainer_config.yaml` 
 file, add the following parameters to the Brain you want to use.
 
 ```json

docs/Getting-Started-with-Balance-Ball.md

 # Getting Started with the 3D Balance Ball Environment
 
-This tutorial walks through the end-to-end process of opening a ML-Agents toolkit
-example environment in Unity, building the Unity executable, training an agent 
-in it, and finally embedding the trained model into the Unity environment. 
+This tutorial walks through the end-to-end process of opening a ML-Agents
+toolkit example environment in Unity, building the Unity executable, training an
+agent in it, and finally embedding the trained model into the Unity environment.
-The ML-Agents toolkit includes a number of [example environments](Learning-Environment-Examples.md) 
-which you can examine to help understand the different ways in which the ML-Agents toolkit 
-can be used. These environments can also serve as templates for new 
-environments or as ways to test new ML algorithms. After reading this tutorial, 
-you should be able to explore and build the example environments.
+The ML-Agents toolkit includes a number of [example
+environments](Learning-Environment-Examples.md) which you can examine to help
+understand the different ways in which the ML-Agents toolkit can be used. These
+environments can also serve as templates for new environments or as ways to test
+new ML algorithms. After reading this tutorial, you should be able to explore
+and build the example environments.
-This walk-through uses the **3D Balance Ball** environment. 3D Balance Ball contains 
-a number of platforms and balls (which are all copies of each other). 
-Each platform tries to keep its ball from falling by rotating either 
-horizontally or vertically. In this environment, a platform is an **agent** 
-that receives a reward for every step that it balances the ball. An agent is 
-also penalized with a negative reward for dropping the ball. The goal of the 
-training process is to have the platforms learn to never drop the ball.
+This walk-through uses the **3D Balance Ball** environment. 3D Balance Ball
+contains a number of platforms and balls (which are all copies of each other).
+Each platform tries to keep its ball from falling by rotating either
+horizontally or vertically. In this environment, a platform is an **agent** that
+receives a reward for every step that it balances the ball. An agent is also
+penalized with a negative reward for dropping the ball. The goal of the training
+process is to have the platforms learn to never drop the ball.
-In order to install and set up the ML-Agents toolkit, the Python dependencies and Unity, 
-see the [installation instructions](Installation.md).
+In order to install and set up the ML-Agents toolkit, the Python dependencies
+and Unity, see the [installation instructions](Installation.md).
-An agent is an autonomous actor that observes and interacts with an 
-_environment_. In the context of Unity, an environment is a scene containing 
-an Academy and one or more Brain and Agent objects, and, of course, the other 
+An agent is an autonomous actor that observes and interacts with an
+_environment_. In the context of Unity, an environment is a scene containing an
+Academy and one or more Brain and Agent objects, and, of course, the other
-**Note:** In Unity, the base object of everything in a scene is the 
-_GameObject_. The GameObject is essentially a container for everything else, 
-including behaviors, graphics, physics, etc. To see the components that make 
-up a GameObject, select the GameObject in the Scene window, and open the 
-Inspector window. The Inspector shows every component on a GameObject. 
- 
-The first thing you may notice after opening the 3D Balance Ball scene is that 
-it contains not one, but several platforms.  Each platform in the scene is an 
-independent agent, but they all share the same brain. 3D Balance Ball does this 
+**Note:** In Unity, the base object of everything in a scene is the
+_GameObject_. The GameObject is essentially a container for everything else,
+including behaviors, graphics, physics, etc. To see the components that make up
+a GameObject, select the GameObject in the Scene window, and open the Inspector
+window. The Inspector shows every component on a GameObject.
+
+The first thing you may notice after opening the 3D Balance Ball scene is that
+it contains not one, but several platforms.  Each platform in the scene is an
+independent agent, but they all share the same brain. 3D Balance Ball does this
-The Academy object for the scene is placed on the Ball3DAcademy GameObject. 
-When you look at an Academy component in the inspector, you can see several 
-properties that control how the environment works. For example, the 
-**Training** and **Inference Configuration**  properties set the graphics and 
-timescale properties for the Unity application. The Academy uses the 
-**Training Configuration**  during training and the **Inference Configuration** 
-when not training. (*Inference* means that the agent is using a trained model 
-or heuristics or direct control — in other words, whenever **not** training.) 
-Typically, you set low graphics quality and a high time scale for the 
-**Training configuration** and a high graphics quality and the timescale to 
-`1.0` for the **Inference Configuration** .
+The Academy object for the scene is placed on the Ball3DAcademy GameObject. When
+you look at an Academy component in the inspector, you can see several
+properties that control how the environment works. For example, the **Training**
+and **Inference Configuration**  properties set the graphics and timescale
+properties for the Unity application. The Academy uses the **Training
+Configuration**  during training and the **Inference Configuration** when not
+training. (*Inference* means that the agent is using a trained model or
+heuristics or direct control — in other words, whenever **not** training.)
+Typically, you set low graphics quality and a high time scale for the **Training
+configuration** and a high graphics quality and the timescale to `1.0` for the
+**Inference Configuration** .
-**Note:** if you want to observe the environment during training, you can 
-adjust the **Inference Configuration** settings to use a larger window and a 
-timescale closer to 1:1. Be sure to set these parameters back when training in 
-earnest; otherwise, training can take a very long time.
+**Note:** if you want to observe the environment during training, you can adjust
+the **Inference Configuration** settings to use a larger window and a timescale
+closer to 1:1. Be sure to set these parameters back when training in earnest;
+otherwise, training can take a very long time.
-Another aspect of an environment to look at is the Academy implementation. 
-Since the base Academy class is abstract, you must always define a subclass. 
-There are three functions you can implement, though they are all optional:
+Another aspect of an environment to look at is the Academy implementation. Since
+the base Academy class is abstract, you must always define a subclass. There are
+three functions you can implement, though they are all optional:
-* Academy.AcademyStep() — Called at every simulation step before 
-Agent.AgentAction() (and after the agents collect their observations).
-* Academy.AcademyReset() — Called when the Academy starts or restarts the 
-simulation (including the first time).
+* Academy.AcademyStep() — Called at every simulation step before
+  Agent.AgentAction() (and after the agents collect their observations).
+* Academy.AcademyReset() — Called when the Academy starts or restarts the
+  simulation (including the first time).
-The 3D Balance Ball environment does not use these functions — each agent 
-resets itself when needed — but many environments do use these functions to 
-control the environment around the agents.
+The 3D Balance Ball environment does not use these functions — each agent resets
+itself when needed — but many environments do use these functions to control the
+environment around the agents.
-The Ball3DBrain GameObject in the scene, which contains a Brain component, 
-is a child of the Academy object. (All Brain objects in a scene must be 
-children of the Academy.) All the agents in the 3D Balance Ball environment 
-use the same Brain instance. 
-A Brain doesn't store any information about an agent, 
-it just routes the agent's collected observations to the decision making 
-process and returns the chosen action to the agent. Thus, all agents can share 
-the same brain, but act independently. The Brain settings tell you quite a bit 
-about how an agent works.
+The Ball3DBrain GameObject in the scene, which contains a Brain component, is a
+child of the Academy object. (All Brain objects in a scene must be children of
+the Academy.) All the agents in the 3D Balance Ball environment use the same
+Brain instance. A Brain doesn't store any information about an agent, it just
+routes the agent's collected observations to the decision making process and
+returns the chosen action to the agent. Thus, all agents can share the same
+brain, but act independently. The Brain settings tell you quite a bit about how
+an agent works.
-The **Brain Type** determines how an agent makes its decisions. The 
-**External** and **Internal** types work together — use **External** when 
-training your agents; use **Internal** when using the trained model. 
-The **Heuristic** brain allows you to hand-code the agent's logic by extending 
-the Decision class. Finally, the **Player** brain lets you map keyboard 
-commands to actions, which can be useful when testing your agents and 
-environment. If none of these types of brains do what you need, you can 
-implement your own CoreBrain to create your own type.
+The **Brain Type** determines how an agent makes its decisions. The **External**
+and **Internal** types work together — use **External** when training your
+agents; use **Internal** when using the trained model. The **Heuristic** brain
+allows you to hand-code the agent's logic by extending the Decision class.
+Finally, the **Player** brain lets you map keyboard commands to actions, which
+can be useful when testing your agents and environment. If none of these types
+of brains do what you need, you can implement your own CoreBrain to create your
+own type.
-In this tutorial, you will set the **Brain Type** to **External** for training; 
+In this tutorial, you will set the **Brain Type** to **External** for training;
-**Vector Observation Space**
+#### Vector Observation Space
-Before making a decision, an agent collects its observation about its state 
-in the world. The vector observation is a vector of floating point numbers
-which contain relevant information for the agent to make decisions. 
+Before making a decision, an agent collects its observation about its state in
+the world. The vector observation is a vector of floating point numbers which
+contain relevant information for the agent to make decisions.
-The Brain instance used in the 3D Balance Ball example uses the **Continuous** 
-vector observation space with a **State Size** of 8. This means that the 
-feature vector containing the agent's observations contains eight elements: 
-the `x` and `z` components of the platform's rotation and the `x`, `y`, and `z`
-components of the ball's relative position and velocity. (The observation
-values are defined in the agent's `CollectObservations()` function.)
+The Brain instance used in the 3D Balance Ball example uses the **Continuous**
+vector observation space with a **State Size** of 8. This means that the feature
+vector containing the agent's observations contains eight elements: the `x` and
+`z` components of the platform's rotation and the `x`, `y`, and `z` components
+of the ball's relative position and velocity. (The observation values are
+defined in the agent's `CollectObservations()` function.)
-**Vector Action Space**
+#### Vector Action Space
-An agent is given instructions from the brain in the form of *actions*. 
-ML-Agents toolkit classifies actions into two types: the **Continuous** 
-vector action space is a vector of numbers that can vary continuously. What 
-each element of the vector means is defined by the agent logic (the PPO
-training process just learns what values are better given particular state 
-observations based on the rewards received when it tries different values). 
-For example, an element might represent a force or torque applied to a 
-`RigidBody` in the agent. The **Discrete** action vector space defines its
-actions as tables. An action given to the agent is an array of indeces into 
-tables. 
+An agent is given instructions from the brain in the form of *actions*.
+ML-Agents toolkit classifies actions into two types: the **Continuous** vector
+action space is a vector of numbers that can vary continuously. What each
+element of the vector means is defined by the agent logic (the PPO training
+process just learns what values are better given particular state observations
+based on the rewards received when it tries different values). For example, an
+element might represent a force or torque applied to a `RigidBody` in the agent.
+The **Discrete** action vector space defines its actions as tables. An action
+given to the agent is an array of indeces into tables. 
-space. 
-You can try training with both settings to observe whether there is a 
-difference. (Set the `Vector Action Space Size` to 4 when using the discrete 
+space. You can try training with both settings to observe whether there is a
+difference. (Set the `Vector Action Space Size` to 4 when using the discrete
- 
+
-The Agent is the actor that observes and takes actions in the environment. 
-In the 3D Balance Ball environment, the Agent components are placed on the 
-twelve Platform GameObjects. The base Agent object has a few properties that 
-affect its behavior:
+The Agent is the actor that observes and takes actions in the environment. In
+the 3D Balance Ball environment, the Agent components are placed on the twelve
+Platform GameObjects. The base Agent object has a few properties that affect its
+behavior:
-* **Brain** — Every agent must have a Brain. The brain determines how an agent 
-makes decisions. All the agents in the 3D Balance Ball scene share the same 
-brain.
+* **Brain** — Every agent must have a Brain. The brain determines how an agent
+  makes decisions. All the agents in the 3D Balance Ball scene share the same
+  brain.
-observe its environment. 3D Balance Ball does not use camera observations.
-* **Max Step** — Defines how many simulation steps can occur before the agent 
-decides it is done. In 3D Balance Ball, an agent restarts after 5000 steps.
+  observe its environment. 3D Balance Ball does not use camera observations.
+* **Max Step** — Defines how many simulation steps can occur before the agent
+  decides it is done. In 3D Balance Ball, an agent restarts after 5000 steps.
-3D Balance Ball sets this true so that the agent restarts after reaching the 
-**Max Step** count or after dropping the ball.
+  3D Balance Ball sets this true so that the agent restarts after reaching the
+  **Max Step** count or after dropping the ball.
-Perhaps the more interesting aspect of an agent is the Agent subclass 
-implementation. When you create an agent, you must extend the base Agent class. 
+Perhaps the more interesting aspect of an agent is the Agent subclass
+implementation. When you create an agent, you must extend the base Agent class.
-* Agent.AgentReset() — Called when the Agent resets, including at the beginning 
-of a session. The Ball3DAgent class uses the reset function to reset the 
-platform and ball. The function randomizes the reset values so that the 
-training generalizes to more than a specific starting position and platform 
-attitude.
-* Agent.CollectObservations() — Called every simulation step. Responsible for 
-collecting the agent's observations of the environment. Since the Brain 
-instance assigned to the agent is set to the continuous vector observation
-space with a state size of 8, the `CollectObservations()` must call 
-`AddVectorObs` 8 times.
+* Agent.AgentReset() — Called when the Agent resets, including at the beginning
+  of a session. The Ball3DAgent class uses the reset function to reset the
+  platform and ball. The function randomizes the reset values so that the
+  training generalizes to more than a specific starting position and platform
+  attitude.
+* Agent.CollectObservations() — Called every simulation step. Responsible for
+  collecting the agent's observations of the environment. Since the Brain
+  instance assigned to the agent is set to the continuous vector observation
+  space with a state size of 8, the `CollectObservations()` must call
+  `AddVectorObs` 8 times.
-by the brain. The Ball3DAgent example handles both the continuous and the 
-discrete action space types. There isn't actually much difference between the 
-two state types in this environment — both vector action spaces result in a
-small change in platform rotation at each step. The `AgentAction()` function
-assigns a reward to the agent; in this example, an agent receives a small 
-positive reward for each step it keeps the ball on the platform and a larger, 
-negative reward for dropping the ball. An agent is also marked as done when it
-drops the ball so that it will reset with a new ball for the next simulation
-step.
+  by the brain. The Ball3DAgent example handles both the continuous and the
+  discrete action space types. There isn't actually much difference between the
+  two state types in this environment — both vector action spaces result in a
+  small change in platform rotation at each step. The `AgentAction()` function
+  assigns a reward to the agent; in this example, an agent receives a small
+  positive reward for each step it keeps the ball on the platform and a larger,
+  negative reward for dropping the ball. An agent is also marked as done when it
+  drops the ball so that it will reset with a new ball for the next simulation
+  step.
 
 ## Training the Brain with Reinforcement Learning
 
 
-In order to train an agent to correctly balance the ball, we will use a 
-Reinforcement Learning algorithm called Proximal Policy Optimization (PPO). 
-This is a method that has been shown to be safe, efficient, and more general 
-purpose than many other RL algorithms, as such we have chosen it as the 
-example algorithm for use with ML-Agents toolkit. For more information on PPO, 
-OpenAI has a recent [blog post](https://blog.openai.com/openai-baselines-ppo/) 
+In order to train an agent to correctly balance the ball, we will use a
+Reinforcement Learning algorithm called Proximal Policy Optimization (PPO). This
+is a method that has been shown to be safe, efficient, and more general purpose
+than many other RL algorithms, as such we have chosen it as the example
+algorithm for use with ML-Agents toolkit. For more information on PPO, OpenAI
+has a recent [blog post](https://blog.openai.com/openai-baselines-ppo/)
+To train the agents within the Ball Balance environment, we will be using the
+python package. We have provided a convenient script called `mlagents-learn`
+which accepts arguments used to configure both training and inference phases.
-To train the agents within the Ball Balance environment, we will be using the python 
-package. We have provided a convenient Python wrapper script called `learn.py` which accepts arguments used to configure both training and inference phases.
-
-We can use `run_id` to identify the experiment and create a folder where the model and summary statistics are stored. When using TensorBoard to observe the training statistics, it helps to set this to a sequential value 
-for each training run. In other words, "BalanceBall1" for the first run, 
-"BalanceBall2" or the second, and so on. If you don't, the summaries for 
-every training run are saved to the same directory and will all be included 
-on the same graph.
+We can use `run_id` to identify the experiment and create a folder where the
+model and summary statistics are stored. When using TensorBoard to observe the
+training statistics, it helps to set this to a sequential value for each
+training run. In other words, "BalanceBall1" for the first run, "BalanceBall2"
+or the second, and so on. If you don't, the summaries for every training run are
+saved to the same directory and will all be included on the same graph.
-To summarize, go to your command line, enter the `ml-agents/python` directory and type: 
+To summarize, go to your command line, enter the `ml-agents` directory and type:
-```
-python3 learn.py --run-id=<run-identifier> --train 
+```shell
+mlagents-learn config/trainer_config.yaml --run-id=<run-identifier> --train
-When the message _"Start training by pressing the Play button in the Unity Editor"_ is displayed on the screen, you can press the :arrow_forward: button in Unity to start training in the Editor.
-
-**Note**: If you're using Anaconda, don't forget to activate the ml-agents environment first.
+When the message _"Start training by pressing the Play button in the Unity
+Editor"_ is displayed on the screen, you can press the :arrow_forward: button in
+Unity to start training in the Editor.
-The `--train` flag tells the ML-Agents toolkit to run in training mode. 
+**Note**: If you're using Anaconda, don't forget to activate the ml-agents
+environment first.
-**Note**: You can train using an executable rather than the Editor. To do so, follow the intructions in 
-[Using an Execuatble](Learning-Environment-Executable.md).
+The `--train` flag tells the ML-Agents toolkit to run in training mode.
+**Note**: You can train using an executable rather than the Editor. To do so,
+follow the intructions in [Using an
+Execuatble](Learning-Environment-Executable.md).
-Once you start training using `learn.py` in the way described in the previous section, the `ml-agents/python` folder will 
-contain a `summaries` directory. In order to observe the training process 
-in more detail, you can use TensorBoard. From the command line navigate to `ml-agents/python` folder and run:
+Once you start training using `mlagents-learn` in the way described in the previous
+section, the `ml-agents` directory will contain a `summaries` directory. In
+order to observe the training process in more detail, you can use TensorBoard.
+From the command line run:
-`tensorboard --logdir=summaries`
+```shell
+tensorboard --logdir=summaries
+```
-* Lesson - only interesting when performing
-[curriculum training](Training-Curriculum-Learning.md). 
-This is not used in the 3D Balance Ball environment. 
-* Cumulative Reward - The mean cumulative episode reward over all agents. 
-Should increase during a successful training session.
-* Entropy - How random the decisions of the model are. Should slowly decrease 
-during a successful training process. If it decreases too quickly, the `beta` 
-hyperparameter should be increased.
-* Episode Length - The mean length of each episode in the environment for all 
-agents.
-* Learning Rate - How large a step the training algorithm takes as it searches 
-for the optimal policy. Should decrease over time.
+* Lesson - only interesting when performing [curriculum
+  training](Training-Curriculum-Learning.md). This is not used in the 3D Balance
+  Ball environment.
+* Cumulative Reward - The mean cumulative episode reward over all agents. Should
+  increase during a successful training session.
+* Entropy - How random the decisions of the model are. Should slowly decrease
+  during a successful training process. If it decreases too quickly, the `beta`
+  hyperparameter should be increased.
+* Episode Length - The mean length of each episode in the environment for all
+  agents.
+* Learning Rate - How large a step the training algorithm takes as it searches
+  for the optimal policy. Should decrease over time.
-much the policy (process for deciding actions) is changing. The magnitude of 
-this should decrease during a successful training session.
-* Value Estimate - The mean value estimate for all states visited by the agent. 
-Should increase during a successful training session.
+  much the policy (process for deciding actions) is changing. The magnitude of
+  this should decrease during a successful training session.
+* Value Estimate - The mean value estimate for all states visited by the agent.
+  Should increase during a successful training session.
-well the model is able to predict the value of each state. This should decrease
-during a successful training session.
+  well the model is able to predict the value of each state. This should
+  decrease during a successful training session.
-Once the training process completes, and the training process saves the model 
-(denoted by the `Saved Model` message) you can add it to the Unity project and 
-use it with agents having an **Internal** brain type.
-**Note:** Do not just close the Unity Window once the `Saved Model` message appears. Either wait for the training process to close the window or press Ctrl+C at the command-line prompt. If you simply close the window manually, the .bytes file containing the trained model is not exported into the ml-agents folder.
+Once the training process completes, and the training process saves the model
+(denoted by the `Saved Model` message) you can add it to the Unity project and
+use it with agents having an **Internal** brain type. **Note:** Do not just
+close the Unity Window once the `Saved Model` message appears. Either wait for
+the training process to close the window or press Ctrl+C at the command-line
+prompt. If you simply close the window manually, the .bytes file containing the
+trained model is not exported into the ml-agents folder.
-Because TensorFlowSharp support is still experimental, it is disabled by 
-default. In order to enable it, you must follow these steps. Please note that 
+Because TensorFlowSharp support is still experimental, it is disabled by
+default. In order to enable it, you must follow these steps. Please note that
-To set up the TensorFlowSharp Support, follow [Setting up ML-Agents Toolkit within Unity](Basic-Guide.md#setting-up-ml-agents-within-unity) section.
-of the Basic Guide page.
+To set up the TensorFlowSharp Support, follow [Setting up ML-Agents Toolkit
+within Unity](Basic-Guide.md#setting-up-ml-agents-within-unity) section. of the
+Basic Guide page.
-To embed the trained model into Unity, follow the later part of [Training the Brain with Reinforcement Learning](Basic-Guide.md#training-the-brain-with-reinforcement-learning) section of the Basic Buides page. 
+To embed the trained model into Unity, follow the later part of [Training the
+Brain with Reinforcement
+Learning](Basic-Guide.md#training-the-brain-with-reinforcement-learning) section
+of the Basic Buides page.

docs/Glossary.md

 # ML-Agents Toolkit Glossary
 
- * **Academy** - Unity Component which controls timing, reset, and 
- training/inference settings of the environment. 
- * **Action** - The carrying-out of a decision on the part of an 
- agent within the environment.
- * **Agent** - Unity Component which produces observations and 
- takes actions in the environment. Agents actions are determined 
- by decisions produced by a linked Brain.
- * **Brain** - Unity Component which makes decisions for the agents 
- linked to it.
- * **Decision** - The specification produced by a Brain for an action 
- to be carried out given an observation. 
- * **Editor** - The Unity Editor, which may include any pane 
- (e.g. Hierarchy, Scene, Inspector). 
- * **Environment** - The Unity scene which contains Agents, Academy, 
- and Brains.
- * **FixedUpdate** - Unity method called each time the the game engine 
- is stepped. ML-Agents logic should be placed here.
- * **Frame** - An instance of rendering the main camera for the 
- display. Corresponds to each `Update` call of the game engine.
- * **Observation** - Partial information describing the state of the 
- environment available to a given agent. (e.g. Vector, Visual, Text)
- * **Policy** - Function for producing decisions from observations.
- * **Reward** - Signal provided at every step used to indicate 
- desirability of an agent’s action within the current state 
- of the environment.
- * **State** - The underlying properties of the environment 
- (including all agents within it) at a given time.
- * **Step** - Corresponds to each `FixedUpdate` call of the game engine. 
- Is the smallest atomic change to the state possible.
- * **Update** - Unity function called each time a frame is rendered. 
- ML-Agents logic should not be placed here.
- * **External Coordinator** - ML-Agents class responsible for 
- communication with outside processes (in this case, the Python API).
- * **Trainer** - Python class which is responsible for training a given 
- external brain. Contains TensorFlow graph which makes decisions 
- for external brain.
+* **Academy** - Unity Component which controls timing, reset, and
+  training/inference settings of the environment.
+* **Action** - The carrying-out of a decision on the part of an agent within the
+  environment.
+* **Agent** - Unity Component which produces observations and takes actions in
+  the environment. Agents actions are determined by decisions produced by a
+  linked Brain.
+* **Brain** - Unity Component which makes decisions for the agents linked to it.
+* **Decision** - The specification produced by a Brain for an action to be
+  carried out given an observation.
+* **Editor** - The Unity Editor, which may include any pane (e.g. Hierarchy,
+  Scene, Inspector).
+* **Environment** - The Unity scene which contains Agents, Academy, and Brains.
+* **FixedUpdate** - Unity method called each time the the game engine is
+  stepped. ML-Agents logic should be placed here.
+* **Frame** - An instance of rendering the main camera for the display.
+  Corresponds to each `Update` call of the game engine.
+* **Observation** - Partial information describing the state of the environment
+  available to a given agent. (e.g. Vector, Visual, Text)
+* **Policy** - Function for producing decisions from observations.
+* **Reward** - Signal provided at every step used to indicate desirability of an
+  agent’s action within the current state of the environment.
+* **State** - The underlying properties of the environment (including all agents
+  within it) at a given time.
+* **Step** - Corresponds to each `FixedUpdate` call of the game engine. Is the
+  smallest atomic change to the state possible.
+* **Update** - Unity function called each time a frame is rendered. ML-Agents
+  logic should not be placed here.
+* **External Coordinator** - ML-Agents class responsible for communication with
+  outside processes (in this case, the Python API).
+* **Trainer** - Python class which is responsible for training a given external
+  brain. Contains TensorFlow graph which makes decisions for external brain.

docs/Installation-Windows.md

 In our example, the files are located in `C:\Downloads`. After you have either cloned or downloaded the files, from the Anaconda Prompt, change to the python directory inside the ml-agents directory:
 
 ```
-cd C:\Downloads\ml-agents\python
+cd C:\Downloads\ml-agents\ml-agents
 ```
 
 Make sure you are connected to the internet and then type in the Anaconda Prompt:

docs/Installation.md

 _Linux Build Support_ component when installing Unity.
 
 <p align="center">
-    <img src="images/unity_linux_build_support.png" 
-        alt="Linux Build Support" 
+    <img src="images/unity_linux_build_support.png"
+        alt="Linux Build Support"
-Once installed, you will want to clone the ML-Agents Toolkit GitHub repository. 
+Once installed, you will want to clone the ML-Agents Toolkit GitHub repository.
-The `unity-environment` directory in this repository contains the Unity Assets
-to add to your projects. The `python` directory contains the training code.
-Both directories are located at the root of the repository. 
+The `MLAgentsSDK` directory in this repository contains the Unity Assets
+to add to your projects. The `python` directory contains python packages
+which provide trainers, a python API to interface with Unity, and a package
+to interface with OpenAI Gym.
-the dependencies listed in the [requirements file](../python/requirements.txt).
+the dependencies listed in the [requirements file](../ml-agents/requirements.txt).
-- [TensorFlow](Background-TensorFlow.md) 
-- [Jupyter](Background-Jupyter.md) 
+
+- [TensorFlow](Background-TensorFlow.md)
+- [Jupyter](Background-Jupyter.md)
-**NOTES**
+### NOTES
+
-- If you are using Anaconda and are having trouble with TensorFlow, please see the following [note](https://www.tensorflow.org/install/install_mac#installing_with_anaconda) on how to install TensorFlow in an Anaconda environment. 
+- If you are using Anaconda and are having trouble with TensorFlow, please see
+  the following
+  [note](https://www.tensorflow.org/install/install_mac#installing_with_anaconda)
+  on how to install TensorFlow in an Anaconda environment.
-If you are a Windows user who is new to Python and TensorFlow, follow [this guide](Installation-Windows.md) to set up your Python environment.
+If you are a Windows user who is new to Python and TensorFlow, follow [this
+guide](Installation-Windows.md) to set up your Python environment.
-[Download](https://www.python.org/downloads/) and install Python 3 if you do not already have it.
+[Download](https://www.python.org/downloads/) and install Python 3 if you do not
+already have it.
-If your Python environment doesn't include `pip`, see these 
+If your Python environment doesn't include `pip`, see these
-To install dependencies, **go into the `python` subdirectory** of the repository,
-and run from the command line:
+To install dependencies, enter the `ml-agents/` directory and run from
+the command line:
-    pip3 install .
+    pip install .
-If you'd like to use Docker for ML-Agents, please follow 
-[this guide](Using-Docker.md). 
+If you'd like to use Docker for ML-Agents, please follow
+[this guide](Using-Docker.md).
-The [Basic Guide](Basic-Guide.md) page contains several short 
-tutorials on setting up the ML-Agents toolkit within Unity, running a pre-trained model, in
+The [Basic Guide](Basic-Guide.md) page contains several short tutorials on
+setting up the ML-Agents toolkit within Unity, running a pre-trained model, in
-If you run into any problems regarding ML-Agents, refer to our [FAQ](FAQ.md) and our [Limitations](Limitations.md) pages. If you can't find anything please
+If you run into any problems regarding ML-Agents, refer to our [FAQ](FAQ.md) and
+our [Limitations](Limitations.md) pages. If you can't find anything please
-make sure to cite relevant information on OS, Python version, and exact error 
-message (whenever possible). 
+make sure to cite relevant information on OS, Python version, and exact error
+message (whenever possible).

docs/Learning-Environment-Create-New.md

 
 2. In a file system window, navigate to the folder containing your cloned ML-Agents repository. 
 
-3. Drag the `ML-Agents` folder from `unity-environments/Assets` to the Unity Editor Project window.
+3. Drag the `ML-Agents` folder from `MLAgentsSDK/Assets` to the Unity Editor Project window.
 
 Your Unity **Project** window should contain the following assets:
 
 
 Press **Play** to run the scene and use the WASD keys to move the agent around the platform. Make sure that there are no errors displayed in the Unity editor Console window and that the agent resets when it reaches its target or falls from the platform. Note that for more involved debugging, the ML-Agents SDK includes a convenient Monitor class that you can use to easily display agent status information in the Game window.
 
-One additional test you can perform is to first ensure that your environment 
-and the Python API work as expected using the `python/Basics` 
-[Jupyter notebook](Background-Jupyter.md). Within `Basics`, be sure to set 
-`env_name` to the name of the environment file you specify when building
-this environment.
+One additional test you can perform is to first ensure that your environment and
+the Python API work as expected using the `notebooks/getting-started.ipynb`
+[Jupyter notebook](Background-Jupyter.md). Within the notebook, be sure to set
+`env_name` to the name of the environment file you specify when building this
+environment.
 
 Now you can train the Agent. To get ready for training, you must first to change the **Brain Type** from **Player** to **External**. From there, the process is the same as described in [Training ML-Agents](Training-ML-Agents.md). 
 

docs/Learning-Environment-Design-External-Internal-Brains.md

     
 4. Once the `environment.bytes` file is imported, drag it from the **Project** window to the **Graph Model** field of the Brain component.
 
-If you are using a model produced by the ML-Agents `learn.py` program, use the default values for the other Internal Brain parameters.
+If you are using a model produced by the ML-Agents `mlagents-learn` command, use the default values for the other Internal Brain parameters.
 
 ### Internal Brain properties
 

docs/Learning-Environment-Examples.md

 
 The Unity ML-Agents toolkit contains an expanding set of example environments which
 demonstrate various features of the platform. Environments are located in 
-`unity-environment/Assets/ML-Agents/Examples` and summarized below. 
+`MLAgentsSDK/Assets/ML-Agents/Examples` and summarized below. 
 Additionally, our 
 [first ML Challenge](https://connect.unity.com/challenges/ml-agents-1)
 contains environments created by the community.

docs/Learning-Environment-Executable.md

 
 1. Launch Unity.
 2. On the Projects dialog, choose the **Open** option at the top of the window.
-3. Using the file dialog that opens, locate the `unity-environment` folder 
+3. Using the file dialog that opens, locate the `MLAgentsSDK` folder 
 within the ML-Agents project and click **Open**.
 4. In the **Project** window, navigate to the folder 
 `Assets/ML-Agents/Examples/3DBall/`.
 the 3DBall Scene is the only one checked. (If the list is empty, than only the 
 current scene is included in the build).
 6. Click **Build**:
-    - In the File dialog, navigate to the `python` folder in your ML-Agents 
-    directory.
+    - In the File dialog, navigate to your ML-Agents directory.
-    - (For Windows）With Unity 2018.1, it will ask you to select a folder instead of a file name. Create a subfolder within `python` folder and select that folder to build. In the following steps you will refer to this subfolder's name as `env_name`. 
+    - (For Windows）With Unity 2018.1, it will ask you to select a folder instead of a file name. Create a subfolder within the ML-Agents folder and select that folder to build. In the following steps you will refer to this subfolder's name as `env_name`. 
 
 ![Build Window](images/mlagents-BuildWindow.png)
 
 If you want to use the [Python API](Python-API.md) to interact with your executable, you can pass the name of the executable with the argument 'file_name' of the `UnityEnvironment`. For instance :
 
 ```python
-from unityagents import UnityEnvironment
+from mlagents.envs import UnityEnvironment
 env = UnityEnvironment(file_name=<env_name>)
 ```
 
 3. Change to the python directory. 
-4. Run `python3 learn.py <env_name> --run-id=<run-identifier> --train`
+4. Run `mlagents-learn <trainer-config-file> --env=<env_name> --run-id=<run-identifier> --train`
-- `<env_name>` is the name and path to the executable you exported from Unity (without extension)
-- `<run-identifier>` is a string used to separate the results of different training runs
-- And the `--train` tells learn.py to run a training session (rather than inference)
+  - `<trainer-config-file>` is the filepath of the trainer configuration yaml.
+  - `<env_name>` is the name and path to the executable you exported from Unity (without extension)
+  - `<run-identifier>` is a string used to separate the results of different training runs
+- And the `--train` tells `mlagents-learn` to run a training session (rather than inference)
-```
-python3 learn.py 3DBall --run-id=firstRun --train
+```shell
+mlagents-learn config/trainer_config.yaml --env=3DBall --run-id=firstRun --train
 ```
 
 ![Training command example](images/training-command-example.png)
-If the learn.py runs correctly and starts training, you should see something like this:
+If `mlagents-learn` runs correctly and starts training, you should see something like this:
-You can press Ctrl+C to stop the training, and your trained model will be at `ml-agents/python/models/<run-identifier>/<env_name>_<run-identifier>.bytes`, which corresponds to your model's latest checkpoint. You can now embed this trained model into your internal brain by following the steps below:
+You can press Ctrl+C to stop the training, and your trained model will be at `models/<run-identifier>/<env_name>_<run-identifier>.bytes`, which corresponds to your model's latest checkpoint. You can now embed this trained model into your internal brain by following the steps below:
-`unity-environment/Assets/ML-Agents/Examples/3DBall/TFModels/`.
+`MLAgentsSDK/Assets/ML-Agents/Examples/3DBall/TFModels/`.
 2. Open the Unity Editor, and select the **3DBall** scene as described above.
 3. Select the **Ball3DBrain** object from the Scene hierarchy.
 4. Change the **Type of Brain** to **Internal**.

docs/ML-Agents-Overview.md

 # ML-Agents Toolkit Overview
 
-**The Unity Machine Learning Agents Toolkit** (ML-Agents Toolkit) is an open-source Unity plugin 
-that enables games and simulations to serve as environments for training
-intelligent agents. Agents can be trained using reinforcement learning,
-imitation learning, neuroevolution, or other machine learning methods through
-a simple-to-use Python API. We also provide implementations (based on
-TensorFlow) of state-of-the-art algorithms to enable game developers
-and hobbyists to easily train intelligent agents for 2D, 3D and VR/AR games.
-These trained agents can be used for multiple purposes, including
+**The Unity Machine Learning Agents Toolkit** (ML-Agents Toolkit) is an
+open-source Unity plugin that enables games and simulations to serve as
+environments for training intelligent agents. Agents can be trained using
+reinforcement learning, imitation learning, neuroevolution, or other machine
+learning methods through a simple-to-use Python API. We also provide
+implementations (based on TensorFlow) of state-of-the-art algorithms to enable
+game developers and hobbyists to easily train intelligent agents for 2D, 3D and
+VR/AR games. These trained agents can be used for multiple purposes, including
-design decisions pre-release. The ML-Agents toolkit is mutually beneficial for both game
-developers and AI researchers as it provides a central platform where advances
-in AI can be evaluated on Unity’s rich environments and then made accessible
-to the wider research and game developer communities. 
+design decisions pre-release. The ML-Agents toolkit is mutually beneficial for
+both game developers and AI researchers as it provides a central platform where
+advances in AI can be evaluated on Unity’s rich environments and then made
+accessible to the wider research and game developer communities.
-Depending on your background (i.e. researcher, game developer, hobbyist),
-you may have very different questions on your mind at the moment.
-To make your transition to the ML-Agents toolkit easier, we provide several background
-pages that include overviews and helpful resources on the 
-[Unity Engine](Background-Unity.md), 
-[machine learning](Background-Machine-Learning.md) and 
-[TensorFlow](Background-TensorFlow.md). We **strongly** recommend browsing
-the relevant background pages if you're not familiar with a Unity scene, 
-basic machine learning concepts or have not previously heard of TensorFlow.
+Depending on your background (i.e. researcher, game developer, hobbyist), you
+may have very different questions on your mind at the moment. To make your
+transition to the ML-Agents toolkit easier, we provide several background pages
+that include overviews and helpful resources on the [Unity
+Engine](Background-Unity.md), [machine learning](Background-Machine-Learning.md)
+and [TensorFlow](Background-TensorFlow.md). We **strongly** recommend browsing
+the relevant background pages if you're not familiar with a Unity scene, basic
+machine learning concepts or have not previously heard of TensorFlow.
-components, different training modes and scenarios. By the end of it, you
-should have a good sense of _what_ the ML-Agents toolkit allows you to do. The subsequent
-documentation pages provide examples of _how_ to use ML-Agents.
+components, different training modes and scenarios. By the end of it, you should
+have a good sense of _what_ the ML-Agents toolkit allows you to do. The
+subsequent documentation pages provide examples of _how_ to use ML-Agents.
-hypothetical, running example throughout. We will explore the
-problem of training the behavior of a non-playable character (NPC) in a game.
-(An NPC is a game character that is never controlled by a human player and
-its behavior is pre-defined by the game developer.) More specifically, let's
-assume we're building a multi-player, war-themed game in which players control 
-the soldiers. In this game, we have a single NPC who serves as a medic, finding 
-and reviving wounded players. Lastly, let us assume that there
-are two teams, each with five players and one NPC medic.
+hypothetical, running example throughout. We will explore the problem of
+training the behavior of a non-playable character (NPC) in a game. (An NPC is a
+game character that is never controlled by a human player and its behavior is
+pre-defined by the game developer.) More specifically, let's assume we're
+building a multi-player, war-themed game in which players control the soldiers.
+In this game, we have a single NPC who serves as a medic, finding and reviving
+wounded players. Lastly, let us assume that there are two teams, each with five
+players and one NPC medic.
-location. Second, it needs to be aware of which of its team members are 
-injured and require assistance. In the case of multiple injuries, it needs to
-assess the degree of injury and decide who to help first. Lastly, a good
-medic will always place itself in a position where it can quickly help its 
-team members. Factoring in all of these traits means that at every instance, 
-the medic needs to measure several attributes of the environment (e.g. 
-position of team members, position of enemies, which of its team members are 
-injured and to what degree) and then decide on an action (e.g. hide from enemy 
-fire, move to help one of its members). Given the large number of settings of 
-the environment and the large number of actions that the medic can take,
-defining and implementing such complex behaviors by hand is challenging and 
-prone to errors.
+location. Second, it needs to be aware of which of its team members are injured
+and require assistance. In the case of multiple injuries, it needs to assess the
+degree of injury and decide who to help first. Lastly, a good medic will always
+place itself in a position where it can quickly help its team members. Factoring
+in all of these traits means that at every instance, the medic needs to measure
+several attributes of the environment (e.g. position of team members, position
+of enemies, which of its team members are injured and to what degree) and then
+decide on an action (e.g. hide from enemy fire, move to help one of its
+members). Given the large number of settings of the environment and the large
+number of actions that the medic can take, defining and implementing such
+complex behaviors by hand is challenging and prone to errors.
-With ML-Agents, it is possible to _train_ the behaviors of such NPCs 
-(called **agents**) using a variety of methods. The basic idea is quite simple. 
-We need to define three entities at every moment of the game 
-(called **environment**):
+With ML-Agents, it is possible to _train_ the behaviors of such NPCs (called
+**agents**) using a variety of methods. The basic idea is quite simple. We need
+to define three entities at every moment of the game (called **environment**):
+
-Observations can be numeric and/or visual. Numeric observations measure 
-attributes of the environment from the point of view of the agent. For
-our medic this would be attributes of the battlefield that are visible to it.
-For most interesting environments, an agent will require 
-several continuous numeric observations. 
-Visual observations, on the other hand, are images generated from the cameras 
-attached to the agent and represent what the agent is seeing at that point
-in time. It is common to confuse an agent's observation with the environment
-(or game) **state**. The environment state represents information about the
-entire scene containing all the game characters. The agents observation, 
-however, only contains information that the agent is aware of and is typically 
-a subset of the environment state. For example, the medic observation cannot
-include information about an enemy in hiding that the medic is unaware of.
-- **Actions** - what actions the medic can take. Similar
-to observations, actions can either be continuous or discrete depending
-on the complexity of the environment and agent. In the case of the medic,
-if the environment is a simple grid world where only their location matters,
-then a discrete action taking on one of four values (north, south, east, west)
-suffices. However, if the environment is more complex and the medic can move
-freely then using two continuous actions (one for direction and another
-for speed) is more appropriate.
+  Observations can be numeric and/or visual. Numeric observations measure
+  attributes of the environment from the point of view of the agent. For our
+  medic this would be attributes of the battlefield that are visible to it. For
+  most interesting environments, an agent will require several continuous
+  numeric observations. Visual observations, on the other hand, are images
+  generated from the cameras attached to the agent and represent what the agent
+  is seeing at that point in time. It is common to confuse an agent's
+  observation with the environment (or game) **state**. The environment state
+  represents information about the entire scene containing all the game
+  characters. The agents observation, however, only contains information that
+  the agent is aware of and is typically a subset of the environment state. For
+  example, the medic observation cannot include information about an enemy in
+  hiding that the medic is unaware of.
+- **Actions** - what actions the medic can take. Similar to observations,
+  actions can either be continuous or discrete depending on the complexity of
+  the environment and agent. In the case of the medic, if the environment is a
+  simple grid world where only their location matters, then a discrete action
+  taking on one of four values (north, south, east, west) suffices. However, if
+  the environment is more complex and the medic can move freely then using two
+  continuous actions (one for direction and another for speed) is more
+  appropriate.
-Note that the reward signal need not be 
-provided at every moment, but only when the medic performs an action that is 
-good or bad. For example, it can receive a large negative reward if it dies, 
-a modest positive reward whenever it revives a wounded team member, and a
-modest negative reward when a wounded team member dies due to lack of
-assistance. Note that the reward signal is how the objectives of the task
-are communicated to the agent, so they need to be set up in a manner where
-maximizing reward generates the desired optimal behavior.
+  Note that the reward signal need not be provided at every moment, but only
+  when the medic performs an action that is good or bad. For example, it can
+  receive a large negative reward if it dies, a modest positive reward whenever
+  it revives a wounded team member, and a modest negative reward when a wounded
+  team member dies due to lack of assistance. Note that the reward signal is how
+  the objectives of the task are communicated to the agent, so they need to be
+  set up in a manner where maximizing reward generates the desired optimal
+  behavior.
-After defining these three entities (the building blocks of a 
-**reinforcement learning task**), 
-we can now _train_ the medic's behavior. This is achieved by simulating the
-environment for many trials where the medic, over time, learns what is the 
-optimal action to take for every observation it measures by maximizing 
-its future reward. The key is that by learning the actions that maximize its
-reward, the medic is learning the behaviors that make it a good medic (i.e.
-one who saves the most number of lives). In **reinforcement learning**
-terminology, the behavior that is learned is called a **policy**, which is
-essentially a (optimal) mapping from observations to actions. Note that
+After defining these three entities (the building blocks of a **reinforcement
+learning task**), we can now _train_ the medic's behavior. This is achieved by
+simulating the environment for many trials where the medic, over time, learns
+what is the optimal action to take for every observation it measures by
+maximizing its future reward. The key is that by learning the actions that
+maximize its reward, the medic is learning the behaviors that make it a good
+medic (i.e. one who saves the most number of lives). In **reinforcement
+learning** terminology, the behavior that is learned is called a **policy**,
+which is essentially a (optimal) mapping from observations to actions. Note that
-**training phase**, while playing the game with an NPC that is using its 
-learned policy is called the **inference phase**.
+**training phase**, while playing the game with an NPC that is using its learned
+policy is called the **inference phase**.
-The ML-Agents toolkit provides all the necessary tools for using Unity as the simulation 
-engine for learning the policies of different objects in a Unity environment.
-In the next few sections, we discuss how the ML-Agents toolkit achieves this and what
-features it provides.
+The ML-Agents toolkit provides all the necessary tools for using Unity as the
+simulation engine for learning the policies of different objects in a Unity
+environment. In the next few sections, we discuss how the ML-Agents toolkit
+achieves this and what features it provides.
-The ML-Agents toolkit is a Unity plugin that contains three high-level components: 
-* **Learning Environment** - which contains the Unity scene and all the game
-characters. 
-* **Python API** - which contains all the machine learning algorithms that are 
-used for training (learning a behavior or policy). Note that, unlike 
-the Learning Environment, the Python API is not part of Unity, but lives
-outside and communicates with Unity through the External Communicator.
-* **External Communicator** - which connects the Learning Environment
-with the Python API. It lives within the Learning Environment.
+The ML-Agents toolkit is a Unity plugin that contains three high-level
+components:
+
+- **Learning Environment** - which contains the Unity scene and all the game
+  characters.
+- **Python API** - which contains all the machine learning algorithms that are
+  used for training (learning a behavior or policy). Note that, unlike the
+  Learning Environment, the Python API is not part of Unity, but lives outside
+  and communicates with Unity through the External Communicator.
+- **External Communicator** - which connects the Learning Environment with the
+  Python API. It lives within the Learning Environment.
 
 <p align="center">
     <img src="images/learning_environment_basic.png" 
 _Simplified block diagram of ML-Agents._
 
 The Learning Environment contains three additional components that help
-organize the Unity scene: 
-* **Agents** - which is attached to a Unity GameObject (any character within a 
-scene) and handles generating its observations, performing the actions it 
-receives and assigning a reward (positive / negative) when appropriate. 
-Each Agent is linked to exactly one Brain.
-* **Brains** - which encapsulates the logic for making decisions for the Agent.
-In essence, the Brain is what holds on to the policy for each Agent and
-determines which actions the Agent should take at each instance. More
-specifically, it is the component that receives the observations and rewards
-from the Agent and returns an action. 
-* **Academy** - which orchestrates the observation and decision making process.
-Within the Academy, several environment-wide parameters such as the rendering
-quality and the speed at which the environment is run can be specified. The
-External Communicator lives within the Academy.
+organize the Unity scene:
-Every Learning Environment will always have one global Academy and one Agent
-for every character in the scene. While each Agent must be linked to a Brain,
-it is possible for Agents that have similar observations and actions to be 
-linked to the same Brain. In our sample game, we have two teams each with
-their own medic. Thus we will have two Agents in our Learning Environment, 
-one for each medic, but both of these medics can be linked to the same Brain.
-Note that these two medics are linked to the same Brain because their _space_
-of observations and actions are similar. This does not mean that at each
-instance they will have identical observation and action _values_. In other
-words, the Brain defines the space of all possible observations and actions, 
-while the Agents connected to it (in this case the medics) can each have
-their own, unique observation and action values. If we expanded our game 
-to include tank driver NPCs, then the Agent attached to those characters 
-cannot share a Brain with the Agent linked to the medics (medics and drivers 
-have different actions).
+- **Agents** - which is attached to a Unity GameObject (any character within a
+  scene) and handles generating its observations, performing the actions it
+  receives and assigning a reward (positive / negative) when appropriate. Each
+  Agent is linked to exactly one Brain.
+- **Brains** - which encapsulates the logic for making decisions for the Agent.
+  In essence, the Brain is what holds on to the policy for each Agent and
+  determines which actions the Agent should take at each instance. More
+  specifically, it is the component that receives the observations and rewards
+  from the Agent and returns an action.
+- **Academy** - which orchestrates the observation and decision making process.
+  Within the Academy, several environment-wide parameters such as the rendering
+  quality and the speed at which the environment is run can be specified. The
+  External Communicator lives within the Academy.
+
+Every Learning Environment will always have one global Academy and one Agent for
+every character in the scene. While each Agent must be linked to a Brain, it is
+possible for Agents that have similar observations and actions to be linked to
+the same Brain. In our sample game, we have two teams each with their own medic.
+Thus we will have two Agents in our Learning Environment, one for each medic,
+but both of these medics can be linked to the same Brain. Note that these two
+medics are linked to the same Brain because their _space_ of observations and
+actions are similar. This does not mean that at each instance they will have
+identical observation and action _values_. In other words, the Brain defines the
+space of all possible observations and actions, while the Agents connected to it
+(in this case the medics) can each have their own, unique observation and action
+values. If we expanded our game to include tank driver NPCs, then the Agent
+attached to those characters cannot share a Brain with the Agent linked to the
+medics (medics and drivers have different actions).
-    <img src="images/learning_environment_example.png" 
-        alt="Example ML-Agents Scene Block Diagram" 
+    <img src="images/learning_environment_example.png"
+        alt="Example ML-Agents Scene Block Diagram"
-We have yet to discuss how the ML-Agents toolkit trains behaviors, and what role the
-Python API and External Communicator play. Before we dive into those details,
-let's summarize the earlier components. Each character is attached to an Agent,
-and each Agent is linked to a Brain. The Brain receives observations and
-rewards from the Agent and returns actions. The Academy ensures that all the
+We have yet to discuss how the ML-Agents toolkit trains behaviors, and what role
+the Python API and External Communicator play. Before we dive into those
+details, let's summarize the earlier components. Each character is attached to
+an Agent, and each Agent is linked to a Brain. The Brain receives observations
+and rewards from the Agent and returns actions. The Academy ensures that all the
-* **External** - where decisions are made using the Python API. Here, the
-observations and rewards collected by the Brain are forwarded to the Python
-API through the External Communicator. The Python API then returns the
-corresponding action that needs to be taken by the Agent.
-* **Internal** - where decisions are made using an embedded 
-[TensorFlow](Background-TensorFlow.md) model. 
-The embedded TensorFlow model represents a learned policy and the Brain 
-directly uses this model to determine the action for each Agent.
-* **Player** - where decisions are made using real input from a keyboard or 
-controller. Here, a human player is controlling the Agent and the observations
-and rewards collected by the Brain are not used to control the Agent.
-* **Heuristic** - where decisions are made using hard-coded behavior. This
-resembles how most character behaviors are currently defined and can be
-helpful for debugging or comparing how an Agent with hard-coded rules compares
-to an Agent whose behavior has been trained. In our example, once we have
-trained a Brain for the medics we could assign a medic on one team to the
-trained Brain and assign the medic on the other team a Heuristic Brain
-with hard-coded behaviors. We can then evaluate which medic is more effective.
+
+- **External** - where decisions are made using the Python API. Here, the
+  observations and rewards collected by the Brain are forwarded to the Python
+  API through the External Communicator. The Python API then returns the
+  corresponding action that needs to be taken by the Agent.
+- **Internal** - where decisions are made using an embedded
+  [TensorFlow](Background-TensorFlow.md) model. The embedded TensorFlow model
+  represents a learned policy and the Brain directly uses this model to
+  determine the action for each Agent.
+- **Player** - where decisions are made using real input from a keyboard or
+  controller. Here, a human player is controlling the Agent and the observations
+  and rewards collected by the Brain are not used to control the Agent.
+- **Heuristic** - where decisions are made using hard-coded behavior. This
+  resembles how most character behaviors are currently defined and can be
+  helpful for debugging or comparing how an Agent with hard-coded rules compares
+  to an Agent whose behavior has been trained. In our example, once we have
+  trained a Brain for the medics we could assign a medic on one team to the
+  trained Brain and assign the medic on the other team a Heuristic Brain with
+  hard-coded behaviors. We can then evaluate which medic is more effective.
-As currently described, it may seem that the External Communicator
-and Python API are only leveraged by the External Brain. This is not true.
-It is possible to configure the Internal, Player and Heuristic Brains to
-also send the observations, rewards and actions to the Python API through
-the External Communicator (a feature called _broadcasting_). As we will see 
-shortly, this enables additional training modes.
+As currently described, it may seem that the External Communicator and Python
+API are only leveraged by the External Brain. This is not true. It is possible
+to configure the Internal, Player and Heuristic Brains to also send the
+observations, rewards and actions to the Python API through the External
+Communicator (a feature called _broadcasting_). As we will see shortly, this
+enables additional training modes.
-    <img src="images/learning_environment.png" 
-        alt="ML-Agents Scene Block Diagram" 
+    <img src="images/learning_environment.png"
+        alt="ML-Agents Scene Block Diagram"
         border="10" />
 </p>
 
 
 ### Built-in Training and Inference
 
-As mentioned previously, the ML-Agents toolkit ships with several implementations of 
-state-of-the-art algorithms for training intelligent agents. In this mode, the 
-Brain type is set to External during training and Internal during inference. 
-More specifically, during training, all the medics in the scene send their
-observations to the Python API through the External Communicator (this is the 
-behavior with an External Brain). The Python API processes these observations
-and sends back actions for each medic to take. During training these actions 
-are mostly exploratory to help the Python API learn the best policy for each 
-medic. Once training concludes, the learned policy for each medic can be 
-exported. Given that all our implementations are based on TensorFlow, the 
-learned policy is just a TensorFlow model file. Then during the inference 
-phase, we switch the Brain type to Internal and include the TensorFlow model 
-generated from the training phase. Now during the inference phase, the medics 
-still  continue to generate their observations, but instead of being sent to
-the Python API, they will be fed into their (internal, embedded) model to
-generate the _optimal_ action for each medic to take at every point in time.
+As mentioned previously, the ML-Agents toolkit ships with several
+implementations of state-of-the-art algorithms for training intelligent agents.
+In this mode, the Brain type is set to External during training and Internal
+during inference. More specifically, during training, all the medics in the
+scene send their observations to the Python API through the External
+Communicator (this is the behavior with an External Brain). The Python API
+processes these observations and sends back actions for each medic to take.
+During training these actions are mostly exploratory to help the Python API
+learn the best policy for each medic. Once training concludes, the learned
+policy for each medic can be exported. Given that all our implementations are
+based on TensorFlow, the learned policy is just a TensorFlow model file. Then
+during the inference phase, we switch the Brain type to Internal and include the
+TensorFlow model generated from the training phase. Now during the inference
+phase, the medics still  continue to generate their observations, but instead of
+being sent to the Python API, they will be fed into their (internal, embedded)
+model to generate the _optimal_ action for each medic to take at every point in
+time.
-To summarize: our built-in implementations are based on TensorFlow, thus,
-during training the Python API uses the observations it receives to learn
-a TensorFlow model. This model is then embedded within the Internal Brain
-during inference to generate the optimal actions for all Agents linked to
-that Brain. **Note that our Internal Brain is currently experimental as it
-is limited to TensorFlow models and leverages the third-party 
-[TensorFlowSharp](https://github.com/migueldeicaza/TensorFlowSharp)
-library.**
+To summarize: our built-in implementations are based on TensorFlow, thus, during
+training the Python API uses the observations it receives to learn a TensorFlow
+model. This model is then embedded within the Internal Brain during inference to
+generate the optimal actions for all Agents linked to that Brain. **Note that
+our Internal Brain is currently experimental as it is limited to TensorFlow
+models and leverages the third-party
+[TensorFlowSharp](https://github.com/migueldeicaza/TensorFlowSharp) library.**
 
 The
 [Getting Started with the 3D Balance Ball Example](Getting-Started-with-Balance-Ball.md)
 
-In the previous mode, the External Brain type was used for training 
-to generate a TensorFlow model that the Internal Brain type can understand
-and use. However, any user of the ML-Agents toolkit can leverage their own algorithms
-for both training and inference. In this case, the Brain type would be set
-to External for both training and inferences phases and the behaviors of
-all the Agents in the scene will be controlled within Python.
+In the previous mode, the External Brain type was used for training to generate
+a TensorFlow model that the Internal Brain type can understand and use. However,
+any user of the ML-Agents toolkit can leverage their own algorithms for both
+training and inference. In this case, the Brain type would be set to External
+for both training and inferences phases and the behaviors of all the Agents in
+the scene will be controlled within Python.
 
 We do not currently have a tutorial highlighting this mode, but you can
 learn more about the Python API [here](Python-API.md).
-This mode is an extension of _Built-in Training and Inference_, and
-is particularly helpful when training intricate behaviors for complex
-environments. Curriculum learning is a way of training a machine learning
-model where more difficult aspects of a problem are gradually introduced in 
-such a way that the model is always optimally challenged. This idea has been 
-around for a long time, and it is how we humans typically learn. If you
-imagine any childhood primary school education, there is an ordering of
-classes and topics. Arithmetic is taught before algebra, for example. 
-Likewise, algebra is taught before calculus. The skills and knowledge learned 
-in the earlier subjects provide a scaffolding for later lessons. The same 
-principle can be applied to machine learning, where training on easier tasks 
-can provide a scaffolding for harder tasks in the future. 
+This mode is an extension of _Built-in Training and Inference_, and is
+particularly helpful when training intricate behaviors for complex environments.
+Curriculum learning is a way of training a machine learning model where more
+difficult aspects of a problem are gradually introduced in such a way that the
+model is always optimally challenged. This idea has been around for a long time,
+and it is how we humans typically learn. If you imagine any childhood primary
+school education, there is an ordering of classes and topics. Arithmetic is
+taught before algebra, for example. Likewise, algebra is taught before calculus.
+The skills and knowledge learned in the earlier subjects provide a scaffolding
+for later lessons. The same principle can be applied to machine learning, where
+training on easier tasks can provide a scaffolding for harder tasks in the
+future.
-    <img src="images/math.png" 
-        alt="Example Math Curriculum" 
+    <img src="images/math.png"
+        alt="Example Math Curriculum"
-_Example of a mathematics curriculum. Lessons progress from simpler topics to more 
-complex ones, with each building on the last._
+_Example of a mathematics curriculum. Lessons progress from simpler topics to
+more complex ones, with each building on the last._
-When we think about how reinforcement learning actually works, the 
-learning signal is reward received occasionally throughout training. 
-The starting point when training an agent to accomplish this task will be a 
-random policy. That starting policy will have the agent running in circles,
-and will likely never, or very rarely achieve the reward for complex
-environments. Thus by simplifying the environment at the beginning of training,
-we allow the agent to quickly update the random policy to a more meaningful
-one that is successively improved as the environment gradually increases in
-complexity. In our example, we can imagine first training the medic when each 
-team only contains one player, and then iteratively increasing the number of
-players (i.e. the environment complexity). The ML-Agents toolkit supports setting
-custom environment parameters within the Academy. This allows
-elements of the environment related to difficulty or complexity to be
-dynamically adjusted based on training progress.
+When we think about how reinforcement learning actually works, the learning
+signal is reward received occasionally throughout training. The starting point
+when training an agent to accomplish this task will be a random policy. That
+starting policy will have the agent running in circles, and will likely never,
+or very rarely achieve the reward for complex environments. Thus by simplifying
+the environment at the beginning of training, we allow the agent to quickly
+update the random policy to a more meaningful one that is successively improved
+as the environment gradually increases in complexity. In our example, we can
+imagine first training the medic when each team only contains one player, and
+then iteratively increasing the number of players (i.e. the environment
+complexity). The ML-Agents toolkit supports setting custom environment
+parameters within the Academy. This allows elements of the environment related
+to difficulty or complexity to be dynamically adjusted based on training
+progress.
 
 The [Training with Curriculum Learning](Training-Curriculum-Learning.md)
 tutorial covers this training mode with the **Wall Area** sample environment.
-It is often more intuitive to simply demonstrate the behavior we
-want an agent to perform, rather than attempting to have it learn via
-trial-and-error methods. For example, instead of training the medic by
-setting up its reward function, this mode allows providing real examples from
-a game controller on how the medic should behave. More specifically,
-in this mode, the Brain type during training is set to Player and all the
-actions performed with the controller (in addition to the agent observations)
-will be recorded and sent to the Python API. The imitation learning algorithm
-will then use these pairs of observations and actions from the human player
-to learn a policy. [Video Link](https://youtu.be/kpb8ZkMBFYs).
+It is often more intuitive to simply demonstrate the behavior we want an agent
+to perform, rather than attempting to have it learn via trial-and-error methods.
+For example, instead of training the medic by setting up its reward function,
+this mode allows providing real examples from a game controller on how the medic
+should behave. More specifically, in this mode, the Brain type during training
+is set to Player and all the actions performed with the controller (in addition
+to the agent observations) will be recorded and sent to the Python API. The
+imitation learning algorithm will then use these pairs of observations and
+actions from the human player to learn a policy. [Video
+Link](https://youtu.be/kpb8ZkMBFYs).
-The [Training with Imitation Learning](Training-Imitation-Learning.md) tutorial covers this 
-training mode with the **Banana Collector** sample environment.
+The [Training with Imitation Learning](Training-Imitation-Learning.md) tutorial
+covers this training mode with the **Banana Collector** sample environment.
-While the discussion so-far has mostly focused on training a single agent, with 
-ML-Agents, several training scenarios are possible.
-We are excited to see what kinds of novel and fun environments the community 
-creates. For those new to training intelligent agents, below are a few examples
-that can serve as inspiration:
-* Single-Agent. A single Agent linked to a single Brain, with its own reward 
-signal. The traditional way of training an agent. An example is any
-single-player game, such as Chicken.
-[Video Link](https://www.youtube.com/watch?v=fiQsmdwEGT8&feature=youtu.be).
-* Simultaneous Single-Agent. Multiple independent Agents with independent
-reward signals linked to a single Brain. A parallelized version of the 
-traditional training scenario, which can speed-up and stabilize the training 
-process. Helpful when you have multiple versions of the same character in an 
-environment who should learn similar behaviors. An example might be training 
-a dozen robot-arms to each open a door simultaneously.
-[Video Link](https://www.youtube.com/watch?v=fq0JBaiCYNA).
-* Adversarial Self-Play. Two interacting Agents with inverse reward signals 
-linked to a single Brain. In two-player games, adversarial self-play can allow
-an agent to become increasingly more skilled, while always having the perfectly 
-matched opponent: itself. This was the strategy employed when training AlphaGo, 
-and more recently used by OpenAI to train a human-beating 1-vs-1 Dota 2 agent.
-* Cooperative Multi-Agent. Multiple interacting Agents with a shared reward 
-signal linked to either a single or multiple different Brains. In this 
-scenario, all agents must work together to accomplish a task that cannot be 
-done alone. Examples include environments where each agent only has access to 
-partial information, which needs to be shared in order to accomplish the task 
-or collaboratively solve a puzzle.
-* Competitive Multi-Agent. Multiple interacting Agents with inverse reward 
-signals linked to either a single or multiple different Brains. In this 
-scenario, agents must compete with one another to either win a competition, 
-or obtain some limited set of resources. All team sports fall into this 
-scenario.
-* Ecosystem. Multiple interacting Agents with independent reward signals
-linked to either a single or multiple different Brains. This scenario can be 
-thought of as creating a small world in which animals with different goals all 
-interact, such as a savanna in which there might be zebras, elephants and 
-giraffes, or an autonomous driving simulation within an urban environment.
+While the discussion so-far has mostly focused on training a single agent, with
+ML-Agents, several training scenarios are possible. We are excited to see what
+kinds of novel and fun environments the community creates. For those new to
+training intelligent agents, below are a few examples that can serve as
+inspiration:
+
+- Single-Agent. A single Agent linked to a single Brain, with its own reward
+  signal. The traditional way of training an agent. An example is any
+  single-player game, such as Chicken. [Video
+  Link](https://www.youtube.com/watch?v=fiQsmdwEGT8&feature=youtu.be).
+- Simultaneous Single-Agent. Multiple independent Agents with independent reward
+  signals linked to a single Brain. A parallelized version of the traditional
+  training scenario, which can speed-up and stabilize the training process.
+  Helpful when you have multiple versions of the same character in an
+  environment who should learn similar behaviors. An example might be training a
+  dozen robot-arms to each open a door simultaneously. [Video
+  Link](https://www.youtube.com/watch?v=fq0JBaiCYNA).
+- Adversarial Self-Play. Two interacting Agents with inverse reward signals
+  linked to a single Brain. In two-player games, adversarial self-play can allow
+  an agent to become increasingly more skilled, while always having the
+  perfectly matched opponent: itself. This was the strategy employed when
+  training AlphaGo, and more recently used by OpenAI to train a human-beating
+  1-vs-1 Dota 2 agent.
+- Cooperative Multi-Agent. Multiple interacting Agents with a shared reward
+  signal linked to either a single or multiple different Brains. In this
+  scenario, all agents must work together to accomplish a task that cannot be
+  done alone. Examples include environments where each agent only has access to
+  partial information, which needs to be shared in order to accomplish the task
+  or collaboratively solve a puzzle.
+- Competitive Multi-Agent. Multiple interacting Agents with inverse reward
+  signals linked to either a single or multiple different Brains. In this
+  scenario, agents must compete with one another to either win a competition, or
+  obtain some limited set of resources. All team sports fall into this scenario.
+- Ecosystem. Multiple interacting Agents with independent reward signals linked
+  to either a single or multiple different Brains. This scenario can be thought
+  of as creating a small world in which animals with different goals all
+  interact, such as a savanna in which there might be zebras, elephants and
+  giraffes, or an autonomous driving simulation within an urban environment.
-Beyond the flexible training scenarios available, the ML-Agents toolkit includes 
+Beyond the flexible training scenarios available, the ML-Agents toolkit includes
-* **On Demand Decision Making** - With the ML-Agents toolkit it is possible to have agents 
-request decisions only when needed as opposed to requesting decisions at 
-every step of the environment. This enables training of turn based games, 
-games where agents 
-must react to events or games where agents can take actions of variable 
-duration. Switching between decision taking at every step and 
-on-demand-decision is one button click away. You can learn more about the 
-on-demand-decision feature 
-[here](Learning-Environment-Design-Agents.md#on-demand-decision-making).
+- **On Demand Decision Making** - With the ML-Agents toolkit it is possible to
+  have agents request decisions only when needed as opposed to requesting
+  decisions at every step of the environment. This enables training of turn
+  based games, games where agents must react to events or games where agents can
+  take actions of variable duration. Switching between decision taking at every
+  step and on-demand-decision is one button click away. You can learn more about
+  the on-demand-decision feature
+  [here](Learning-Environment-Design-Agents.md#on-demand-decision-making).
-* **Memory-enhanced Agents** - In some scenarios, agents must learn to 
-remember the past in order to take the 
-best decision. When an agent only has partial observability of the environment, 
-keeping track of past observations can help the agent learn. We provide an 
-implementation of _Long Short-term Memory_ 
-([LSTM](https://en.wikipedia.org/wiki/Long_short-term_memory))
-in our trainers that enable the agent to store memories to be used in future 
-steps. You can learn more about enabling LSTM during training
-[here](Feature-Memory.md).
+- **Memory-enhanced Agents** - In some scenarios, agents must learn to remember
+  the past in order to take the best decision. When an agent only has partial
+  observability of the environment, keeping track of past observations can help
+  the agent learn. We provide an implementation of _Long Short-term Memory_
+  ([LSTM](https://en.wikipedia.org/wiki/Long_short-term_memory)) in our trainers
+  that enable the agent to store memories to be used in future steps. You can
+  learn more about enabling LSTM during training [here](Feature-Memory.md).
+
+- **Monitoring Agent’s Decision Making** - Since communication in ML-Agents is a
+  two-way street, we provide an agent Monitor class in Unity which can display
+  aspects of the trained agent, such as the agents perception on how well it is
+  doing (called **value estimates**) within the Unity environment itself. By
+  leveraging Unity as a visualization tool and providing these outputs in
+  real-time, researchers and developers can more easily debug an agent’s
+  behavior. You can learn more about using the Monitor class
+  [here](Feature-Monitor.md).
-* **Monitoring Agent’s Decision Making** - Since communication in ML-Agents
-is a two-way street, we provide an agent Monitor class in Unity which can
-display aspects of the trained agent, such as the agents perception on how
-well it is doing (called **value estimates**) within the Unity environment
-itself. By leveraging Unity as a visualization tool and providing these 
-outputs in real-time, researchers and developers can more easily debug an 
-agent’s behavior. You can learn more about using the Monitor class 
-[here](Feature-Monitor.md).
+- **Complex Visual Observations** - Unlike other platforms, where the agent’s
+  observation might be limited to a single vector or image, the ML-Agents
+  toolkit allows multiple cameras to be used for observations per agent. This
+  enables agents to learn to integrate information from multiple visual streams.
+  This can be helpful in several scenarios such as training a self-driving car
+  which requires multiple cameras with different viewpoints, or a navigational
+  agent which might need to integrate aerial and first-person visuals. You can
+  learn more about adding visual observations to an agent
+  [here](Learning-Environment-Design-Agents.md#multiple-visual-observations).
-* **Complex Visual Observations** - Unlike other platforms, where the agent’s
-observation might be limited to a single vector or image, the ML-Agents toolkit allows
-multiple cameras to be used for observations per agent. This enables agents to
-learn to integrate information from multiple visual streams. This can be
-helpful in several scenarios such as training a self-driving car which requires 
-multiple cameras with different viewpoints, or a navigational agent which might 
-need to integrate aerial and first-person visuals. You can learn more about
-adding visual observations to an agent 
-[here](Learning-Environment-Design-Agents.md#multiple-visual-observations).
-        
-* **Broadcasting** - As discussed earlier, an External Brain sends the
-observations for all its Agents to the Python API by default. This is helpful 
-for training or inference. Broadcasting is a feature which can be enabled
-for the other three modes (Player, Internal, Heuristic) where the Agent
-observations and actions are also sent to the Python API (despite the fact
-that the Agent is **not** controlled by the Python API). This feature is
-leveraged by Imitation Learning, where the observations and actions for a
-Player Brain are used to learn the policies of an agent through demonstration.
-However, this could also be helpful for the Heuristic and Internal Brains,
-particularly when debugging agent behaviors. You can learn more about using 
-the broadcasting feature 
-[here](Learning-Environment-Design-Brains.md#using-the-broadcast-feature).
+- **Broadcasting** - As discussed earlier, an External Brain sends the
+  observations for all its Agents to the Python API by default. This is helpful
+  for training or inference. Broadcasting is a feature which can be enabled for
+  the other three modes (Player, Internal, Heuristic) where the Agent
+  observations and actions are also sent to the Python API (despite the fact
+  that the Agent is **not** controlled by the Python API). This feature is
+  leveraged by Imitation Learning, where the observations and actions for a
+  Player Brain are used to learn the policies of an agent through demonstration.
+  However, this could also be helpful for the Heuristic and Internal Brains,
+  particularly when debugging agent behaviors. You can learn more about using
+  the broadcasting feature
+  [here](Learning-Environment-Design-Brains.md#using-the-broadcast-feature).
-* **Docker Set-up (Experimental)** - To facilitate setting up ML-Agents
-without installing Python or TensorFlow directly, we provide a 
-[guide](Using-Docker.md) on how
-to create and run a Docker container.
+- **Docker Set-up (Experimental)** - To facilitate setting up ML-Agents without
+  installing Python or TensorFlow directly, we provide a
+  [guide](Using-Docker.md) on how to create and run a Docker container.
-* **Cloud Training on AWS** - To facilitate using the ML-Agents toolkit on
-Amazon Web Services (AWS) machines, we provide a 
-[guide](Training-on-Amazon-Web-Service.md)
-on how to set-up EC2 instances in addition to a public pre-configured Amazon 
-Machine Image (AMI).
+- **Cloud Training on AWS** - To facilitate using the ML-Agents toolkit on
+  Amazon Web Services (AWS) machines, we provide a
+  [guide](Training-on-Amazon-Web-Service.md) on how to set-up EC2 instances in
+  addition to a public pre-configured Amazon Machine Image (AMI).
-* **Cloud Training on Microsoft Azure** - To facilitate using the ML-Agents toolkit on
-Azure machines, we provide a 
-[guide](Training-on-Microsoft-Azure.md)
-on how to set-up virtual machine instances in addition to a pre-configured data science image.
+- **Cloud Training on Microsoft Azure** - To facilitate using the ML-Agents
+  toolkit on Azure machines, we provide a
+  [guide](Training-on-Microsoft-Azure.md) on how to set-up virtual machine
+  instances in addition to a pre-configured data science image.
-To briefly summarize: The ML-Agents toolkit enables games and simulations built in Unity
-to serve as the platform for training intelligent agents. It is designed
-to enable a large variety of training modes and scenarios and comes packed
-with several features to enable researchers and developers to leverage
+To briefly summarize: The ML-Agents toolkit enables games and simulations built
+in Unity to serve as the platform for training intelligent agents. It is
+designed to enable a large variety of training modes and scenarios and comes
+packed with several features to enable researchers and developers to leverage
-To help you use ML-Agents, we've created several in-depth tutorials 
-for [installing ML-Agents](Installation.md), 
-[getting started](Getting-Started-with-Balance-Ball.md) 
-with the 3D Balance Ball environment (one of our many 
-[sample environments](Learning-Environment-Examples.md)) and 
+To help you use ML-Agents, we've created several in-depth tutorials for
+[installing ML-Agents](Installation.md),
+[getting started](Getting-Started-with-Balance-Ball.md) with the 3D Balance Ball
+environment (one of our many
+[sample environments](Learning-Environment-Examples.md)) and
-

docs/Python-API.md

 # Python API
 
-The ML-Agents toolkit provides a Python API for controlling the agent simulation loop of a environment or game built with Unity. This API is used by the ML-Agent training algorithms (run with `learn.py`), but you can also write your Python programs using this API. 
+The ML-Agents toolkit provides a Python API for controlling the agent simulation
+loop of a environment or game built with Unity. This API is used by the ML-Agent
+training algorithms (run with `mlagents-learn`), but you can also write your Python
+programs using this API.
-* **UnityEnvironment** — the main interface between the Unity application and your code. Use UnityEnvironment to start and control a simulation or training session.
-* **BrainInfo** — contains all the data from agents in the simulation, such as observations and rewards.
-* **BrainParameters** — describes the data elements in a BrainInfo object. For example, provides the array length of an observation in BrainInfo.
+- **UnityEnvironment** — the main interface between the Unity application and
+  your code. Use UnityEnvironment to start and control a simulation or training
+  session.
+- **BrainInfo** — contains all the data from agents in the simulation, such as
+  observations and rewards.
+- **BrainParameters** — describes the data elements in a BrainInfo object. For
+  example, provides the array length of an observation in BrainInfo.
-These classes are all defined in the `python/unityagents` folder of the ML-Agents SDK.
+These classes are all defined in the `ml-agents/mlagents/envs` folder of
+the ML-Agents SDK.
-To communicate with an agent in a Unity environment from a Python program, the agent must either use an **External** brain or use a brain that is broadcasting (has its **Broadcast** property set to true). Your code is expected to return actions for agents with external brains, but can only observe broadcasting brains (the information you receive for an agent is the same in both cases). See [Using the Broadcast Feature](Learning-Environment-Design-Brains.md#using-the-broadcast-feature).
+To communicate with an agent in a Unity environment from a Python program, the
+agent must either use an **External** brain or use a brain that is broadcasting
+(has its **Broadcast** property set to true). Your code is expected to return
+actions for agents with external brains, but can only observe broadcasting
+brains (the information you receive for an agent is the same in both cases). See
+[Using the Broadcast
+Feature](Learning-Environment-Design-Brains.md#using-the-broadcast-feature).
-For a simple example of using the Python API to interact with a Unity environment, see the Basic [Jupyter](Background-Jupyter.md) notebook (`python/notebooks/getting-started.ipynb`), which opens an environment, runs a few simulation steps taking random actions, and closes the environment. 
+For a simple example of using the Python API to interact with a Unity
+environment, see the Basic [Jupyter](Background-Jupyter.md) notebook
+(`notebooks/getting-started.ipynb`), which opens an environment, runs a few
+simulation steps taking random actions, and closes the environment.
-_Notice: Currently communication between Unity and Python takes place over an open socket without authentication. As such, please make sure that the network where training takes place is secure. This will be addressed in a future release._
+_Notice: Currently communication between Unity and Python takes place over an
+open socket without authentication. As such, please make sure that the network
+where training takes place is secure. This will be addressed in a future
+release._
-Python-side communication happens through `UnityEnvironment` which is located in `python/unityagents`. To load a Unity environment from a built binary file, put the file in the same directory as `unityagents`. For example, if the filename of your Unity environment is 3DBall.app, in python, run:
+Python-side communication happens through `UnityEnvironment` which is located in
+`ml-agents/mlagents/envs`. To load a Unity environment from a built binary
+file, put the file in the same directory as `envs`. For example, if the filename
+of your Unity environment is 3DBall.app, in python, run:
-from unityagents import UnityEnvironment
+from mlagents.env import UnityEnvironment
-* `file_name` is the name of the environment binary (located in the root directory of the python project).
-* `worker_id` indicates which port to use for communication with the environment. For use in parallel training regimes such as A3C.
-* `seed` indicates the seed to use when generating random numbers during the training process. In environments which do not involve physics calculations, setting the seed enables reproducible experimentation by ensuring that the environment and trainers utilize the same random seed.
+- `file_name` is the name of the environment binary (located in the root
+  directory of the python project).
+- `worker_id` indicates which port to use for communication with the
+  environment. For use in parallel training regimes such as A3C.
+- `seed` indicates the seed to use when generating random numbers during the
+  training process. In environments which do not involve physics calculations,
+  setting the seed enables reproducible experimentation by ensuring that the
+  environment and trainers utilize the same random seed.
-If you want to directly interact with the Editor, you need to use `file_name=None`, then press the :arrow_forward: button in the Editor when the message _"Start training by pressing the Play button in the Unity Editor"_ is displayed on the screen
+If you want to directly interact with the Editor, you need to use
+`file_name=None`, then press the :arrow_forward: button in the Editor when the
+message _"Start training by pressing the Play button in the Unity Editor"_ is
+displayed on the screen
-* **`visual_observations`** : A list of 4 dimensional numpy arrays. Matrix n of the list corresponds to the n<sup>th</sup> observation of the brain. 
-* **`vector_observations`** : A two dimensional numpy array of dimension `(batch size, vector observation size)`.
-* **`text_observations`** : A list of string corresponding to the agents text observations.
-* **`memories`** : A two dimensional numpy array of dimension `(batch size, memory size)` which corresponds to the memories sent at the previous step.
-* **`rewards`** : A list as long as the number of agents using the brain containing the rewards they each obtained at the previous step. 
-* **`local_done`** : A list as long as the number of agents using the brain containing  `done` flags (whether or not the agent is done). 
-* **`max_reached`** : A list as long as the number of agents using the brain containing true if the agents reached their max steps.
-* **`agents`** : A list of the unique ids of the agents using the brain.
-* **`previous_actions`** : A two dimensional numpy array of dimension `(batch size, vector action size)` if the vector action space is continuous and `(batch size, number of branches)` if the vector action space is discrete.
+- **`visual_observations`** : A list of 4 dimensional numpy arrays. Matrix n of
+  the list corresponds to the n<sup>th</sup> observation of the brain. 
+- **`vector_observations`** : A two dimensional numpy array of dimension `(batch
+  size, vector observation size)`.
+- **`text_observations`** : A list of string corresponding to the agents text
+  observations.
+- **`memories`** : A two dimensional numpy array of dimension `(batch size,
+  memory size)` which corresponds to the memories sent at the previous step.
+- **`rewards`** : A list as long as the number of agents using the brain
+  containing the rewards they each obtained at the previous step. 
+- **`local_done`** : A list as long as the number of agents using the brain
+  containing  `done` flags (whether or not the agent is done). 
+- **`max_reached`** : A list as long as the number of agents using the brain
+  containing true if the agents reached their max steps.
+- **`agents`** : A list of the unique ids of the agents using the brain.
+- **`previous_actions`** : A two dimensional numpy array of dimension `(batch
+  size, vector action size)` if the vector action space is continuous and
+  `(batch size, number of branches)` if the vector action space is discrete.
-Once loaded, you can use your UnityEnvironment object, which referenced by a variable named `env` in this example, can be used in the following way:  
+Once loaded, you can use your UnityEnvironment object, which referenced by a
+variable named `env` in this example, can be used in the following way:  
+
-Prints all parameters relevant to the loaded environment and the external brains.  
+  Prints all parameters relevant to the loaded environment and the external
+  brains.  
-Send a reset signal to the environment, and provides a dictionary mapping brain names to BrainInfo objects.  
-    - `train_model` indicates whether to run the environment in train (`True`) or test (`False`) mode.
-    - `config` is an optional dictionary of configuration flags specific to the environment. For generic environments, `config` can be ignored. `config` is a dictionary of strings to floats where the keys are the names of the `resetParameters` and the values are their corresponding float values. Define the reset parameters on the [Academy Inspector](Learning-Environment-Design-Academy.md#academy-properties) window in the Unity Editor.
+  Send a reset signal to the environment, and provides a dictionary mapping
+  brain names to BrainInfo objects.  
+  - `train_model` indicates whether to run the environment in train (`True`) or
+    test (`False`) mode.
+  - `config` is an optional dictionary of configuration flags specific to the
+    environment. For generic environments, `config` can be ignored. `config` is
+    a dictionary of strings to floats where the keys are the names of the
+    `resetParameters` and the values are their corresponding float values.
+    Define the reset parameters on the [Academy
+    Inspector](Learning-Environment-Design-Academy.md#academy-properties) window
+    in the Unity Editor.
-Sends a step signal to the environment using the actions. For each brain : 
-    - `action` can be one dimensional arrays or two dimensional arrays if you have multiple agents per brains.
-    - `memory` is an optional input that can be used to send a list of floats per agents to be retrieved at the next step.
-    - `text_action` is an optional input that be used to send a single string per agent.
+  Sends a step signal to the environment using the actions. For each brain :
+  - `action` can be one dimensional arrays or two dimensional arrays if you have
+    multiple agents per brains.
+  - `memory` is an optional input that can be used to send a list of floats per
+    agents to be retrieved at the next step.
+  - `text_action` is an optional input that be used to send a single string per
+    agent.
-    
-    For example, to access the BrainInfo belonging to a brain called 'brain_name', and the BrainInfo field 'vector_observations':
+
+    For example, to access the BrainInfo belonging to a brain called
+    'brain_name', and the BrainInfo field 'vector_observations':
-    ``` 
+    ```
-    Note that if you have more than one external brain in the environment, you must provide dictionaries from brain names to arrays for     `action`, `memory` and `value`. For example: If you have two external brains named `brain1` and `brain2` each with one agent taking     two continuous actions, then you can have:
+    Note that if you have more than one external brain in the environment, you
+    must provide dictionaries from brain names to arrays for `action`, `memory`
+    and `value`. For example: If you have two external brains named `brain1` and
+    `brain2` each with one agent taking two continuous actions, then you can
+    have:
-Returns a dictionary mapping brain names to BrainInfo objects.  
-- **Close : `env.close()`**  
-Sends a shutdown signal to the environment and closes the communication socket.
+    Returns a dictionary mapping brain names to BrainInfo objects.  
+- **Close : `env.close()`**
+  Sends a shutdown signal to the environment and closes the communication
+  socket.

docs/Readme.md

 # Unity ML-Agents Toolkit Documentation
 
 ## Installation & Set-up
- * [Installation](Installation.md)
-    * [Background: Jupyter Notebooks](Background-Jupyter.md)
-    * [Docker Set-up](Using-Docker.md)
- * [Basic Guide](Basic-Guide.md)
+
+* [Installation](Installation.md)
+  * [Background: Jupyter Notebooks](Background-Jupyter.md)
+  * [Docker Set-up](Using-Docker.md)
+* [Basic Guide](Basic-Guide.md)
- * [ML-Agents Toolkit Overview](ML-Agents-Overview.md)
-    * [Background: Unity](Background-Unity.md)
-    * [Background: Machine Learning](Background-Machine-Learning.md)
-    * [Background: TensorFlow](Background-TensorFlow.md)
- * [Getting Started with the 3D Balance Ball Environment](Getting-Started-with-Balance-Ball.md)
- * [Example Environments](Learning-Environment-Examples.md)
+
+* [ML-Agents Toolkit Overview](ML-Agents-Overview.md)
+  * [Background: Unity](Background-Unity.md)
+  * [Background: Machine Learning](Background-Machine-Learning.md)
+  * [Background: TensorFlow](Background-TensorFlow.md)
+* [Getting Started with the 3D Balance Ball Environment](Getting-Started-with-Balance-Ball.md)
+* [Example Environments](Learning-Environment-Examples.md)
- * [Making a New Learning Environment](Learning-Environment-Create-New.md)
- * [Designing a Learning Environment](Learning-Environment-Design.md)
-     * [Agents](Learning-Environment-Design-Agents.md)
-     * [Academy](Learning-Environment-Design-Academy.md)
-     * [Brains](Learning-Environment-Design-Brains.md): [Player](Learning-Environment-Design-Player-Brains.md), [Heuristic](Learning-Environment-Design-Heuristic-Brains.md), [Internal & External](Learning-Environment-Design-External-Internal-Brains.md)
- * [Learning Environment Best Practices](Learning-Environment-Best-Practices.md)
- * [Using the Monitor](Feature-Monitor.md)
- * [Using an Executable Environment](Learning-Environment-Executable.md)
- * [TensorFlowSharp in Unity (Experimental)](Using-TensorFlow-Sharp-in-Unity.md)
- 
+
+* [Making a New Learning Environment](Learning-Environment-Create-New.md)
+* [Designing a Learning Environment](Learning-Environment-Design.md)
+  * [Agents](Learning-Environment-Design-Agents.md)
+  * [Academy](Learning-Environment-Design-Academy.md)
+  * [Brains](Learning-Environment-Design-Brains.md):
+    [Player](Learning-Environment-Design-Player-Brains.md),
+    [Heuristic](Learning-Environment-Design-Heuristic-Brains.md),
+    [Internal & External](Learning-Environment-Design-External-Internal-Brains.md)
+* [Learning Environment Best Practices](Learning-Environment-Best-Practices.md)
+* [Using the Monitor](Feature-Monitor.md)
+* [Using an Executable Environment](Learning-Environment-Executable.md)
+* [TensorFlowSharp in Unity (Experimental)](Using-TensorFlow-Sharp-in-Unity.md)
+
- * [Training ML-Agents](Training-ML-Agents.md)
- * [Training with Proximal Policy Optimization](Training-PPO.md)
- * [Training with Curriculum Learning](Training-Curriculum-Learning.md)
- * [Training with Imitation Learning](Training-Imitation-Learning.md)
- * [Training with LSTM](Feature-Memory.md)
- * [Training on the Cloud with Amazon Web Services](Training-on-Amazon-Web-Service.md)
- * [Training on the Cloud with Microsoft Azure](Training-on-Microsoft-Azure.md)
- * [Using TensorBoard to Observe Training](Using-Tensorboard.md)
+
+* [Training ML-Agents](Training-ML-Agents.md)
+* [Training with Proximal Policy Optimization](Training-PPO.md)
+* [Training with Curriculum Learning](Training-Curriculum-Learning.md)
+* [Training with Imitation Learning](Training-Imitation-Learning.md)
+* [Training with LSTM](Feature-Memory.md)
+* [Training on the Cloud with Amazon Web Services](Training-on-Amazon-Web-Service.md)
+* [Training on the Cloud with Microsoft Azure](Training-on-Microsoft-Azure.md)
+* [Using TensorBoard to Observe Training](Using-Tensorboard.md)
- * [Migrating from earlier versions of ML-Agents](Migrating.md)
- * [Frequently Asked Questions](FAQ.md)
- * [ML-Agents Glossary](Glossary.md)
- * [Limitations](Limitations.md)
- 
+
+* [Migrating from earlier versions of ML-Agents](Migrating.md)
+* [Frequently Asked Questions](FAQ.md)
+* [ML-Agents Glossary](Glossary.md)
+* [Limitations](Limitations.md)
+
- * [API Reference](API-Reference.md)
- * [How to use the Python API](Python-API.md)
- * [Wrapping Learning Environment as a Gym](../gym-unity/Readme.md)
+
+* [API Reference](API-Reference.md)
+* [How to use the Python API](Python-API.md)
+* [Wrapping Learning Environment as a Gym](../gym-unity/Readme.md)

docs/Training-Curriculum-Learning.md

 
 ### Specifying a Metacurriculum
 
-We first create a folder inside `python/curricula/` for the environment we want
+We first create a folder inside `config/curricula/` for the environment we want
-`python/curricula/wall-jump/`. We will place our curriculums inside this folder.
+`config/curricula/wall-jump/`. We will place our curriculums inside this folder.
 
 ### Specifying a Curriculum
 
 
 Once our curriculum is defined, we have to use the reset parameters we defined
 and modify the environment from the agent's `AgentReset()` function. See
-[WallJumpAgent.cs](https://github.com/Unity-Technologies/ml-agents/blob/master/unity-environment/Assets/ML-Agents/Examples/WallJump/Scripts/WallJumpAgent.cs)
+[WallJumpAgent.cs](https://github.com/Unity-Technologies/ml-agents/blob/master/MLAgentsSDK/Assets/ML-Agents/Examples/WallJump/Scripts/WallJumpAgent.cs)
 for an example. Note that if the Academy's __Max Steps__ is not set to some
 positive number the environment will never be reset. The Academy must reset
 for the environment to reset.
 brains---BigWallBrain and SmallWallBrain. If we want to define a curriculum for
 the BigWallBrain, we will save `BigWallBrain.json` into
-`python/curricula/wall-jump/`.
+`curricula/wall-jump/`.
-`learn.py` using the `–curriculum` flag to point to the metacurriculum folder
-and PPO will train using Curriculum Learning. For example, to train agents in
-the Wall Jump environment with curriculum learning, we can run `python learn.py
---curriculum=curricula/wall-jump/ --run-id=wall-jump-curriculum --train`. We can
-then keep track of the current lessons and progresses via TensorBoard.
+`mlagents-learn` using the `–curriculum` flag to point to the metacurriculum
+folder and PPO will train using Curriculum Learning. For example, to train
+agents in the Wall Jump environment with curriculum learning, we can run
+
+```shell
+mlagents-learn config/trainer_config.yaml --curriculum=curricula/wall-jump/ --run-id=wall-jump-curriculum --train
+```
+
+We can then keep track of the current
+lessons and progresses via TensorBoard.

docs/Training-Imitation-Learning.md

 2. Set the "Teacher" brain to Player mode, and properly configure the inputs to map to the corresponding actions. **Ensure that "Broadcast" is checked within the Brain inspector window.**
 3. Set the "Student" brain to External mode.
 4. Link the brains to the desired agents (one agent as the teacher and at least one agent as a student).
-5. In `trainer_config.yaml`, add an entry for the "Student" brain. Set the `trainer` parameter of this entry to `imitation`, and the `brain_to_imitate` parameter to the name of the teacher brain: "Teacher". Additionally, set `batches_per_epoch`, which controls how much training to do each moment. Increase the `max_steps` option if you'd like to keep training the agents for a longer period of time.
-6. Launch the training process with `python3 python/learn.py --train --slow`, and press the :arrow_forward: button in Unity when the message _"Start training by pressing the Play button in the Unity Editor"_ is displayed on the screen
+5. In `config/trainer_config.yaml`, add an entry for the "Student" brain. Set the `trainer` parameter of this entry to `imitation`, and the `brain_to_imitate` parameter to the name of the teacher brain: "Teacher". Additionally, set `batches_per_epoch`, which controls how much training to do each moment. Increase the `max_steps` option if you'd like to keep training the agents for a longer period of time.
+6. Launch the training process with `mlagents-learn config/trainer_config.yaml --train --slow`, and press the :arrow_forward: button in Unity when the message _"Start training by pressing the Play button in the Unity Editor"_ is displayed on the screen
 7. From the Unity window, control the agent with the Teacher brain by providing "teacher demonstrations" of the behavior you would like to see.
 8. Watch as the agent(s) with the student brain attached begin to behave similarly to the demonstrations.
 9. Once the Student agents are exhibiting the desired behavior, end the training process with `CTL+C` from the command line.

docs/Training-ML-Agents.md

 
 The output of the training process is a model file containing the optimized policy. This model file is a TensorFlow data graph containing the mathematical operations and the optimized weights selected during the training process. You can use the generated model file with the Internal Brain type in your Unity project to decide the best course of action for an agent. 
 
-Use the Python program, `learn.py` to train your agents. This program can be found in the `python` directory of the ML-Agents SDK. The [configuration file](#training-config-file), `trainer_config.yaml` specifies the hyperparameters used during training. You can edit this file with a text editor to add a specific configuration for each brain.
+Use the command `mlagents-learn` to train your agents. This command is installed with the `mlagents` package
+and its implementation can be found at `ml-agents/learn.py`. The [configuration file](#training-config-file), `config/trainer_config.yaml` specifies the hyperparameters used during training. You can edit this file with a text editor to add a specific configuration for each brain.
-## Training with learn.py
+## Training with mlagents-learn
-Use the Python `learn.py` program to train agents. `learn.py` supports training with [reinforcement learning](Background-Machine-Learning.md#reinforcement-learning), [curriculum learning](Training-Curriculum-Learning.md), and [behavioral cloning imitation learning](Training-Imitation-Learning.md).
+Use the `mlagents-learn` command to train agents. `mlagents-learn` supports training with [reinforcement learning](Background-Machine-Learning.md#reinforcement-learning), [curriculum learning](Training-Curriculum-Learning.md), and [behavioral cloning imitation learning](Training-Imitation-Learning.md).
-Run `learn.py` from the command line to launch the training process. Use the command line patterns and the `trainer_config.yaml` file to control training options.
+Run `mlagents-learn` from the command line to launch the training process. Use the command line patterns and the `config/trainer_config.yaml` file to control training options.
-    python3 learn.py <env_name> --run-id=<run-identifier> --train
+```shell
+mlagents-learn <trainer-config-file> --env=<env_name> --run-id=<run-identifier> --train
+```
-where 
+where
+
+ * `<trainer-config-file>` is the filepath of the trainer configuration yaml.
  * `<env_name>`__(Optional)__ is the name (including path) of your Unity executable containing the agents to be trained. If `<env_name>` is not passed, the training will happen in the Editor. Press the :arrow_forward: button in Unity when the message _"Start training by pressing the Play button in the Unity Editor"_ is displayed on the screen.
  * `<run-identifier>` is an optional identifier you can use to identify the results of individual training runs.
 
 3. Navigate to the ml-agents `python` folder.
 4. Run the following to launch the training process using the path to the Unity environment you built in step 1:
 
-        python3 learn.py ../../projects/Cats/CatsOnBicycles.app --run-id=cob_1 --train
+        mlagents-learn config/trainer_config.yaml --env=../../projects/Cats/CatsOnBicycles.app --run-id=cob_1 --train
 
 During a training session, the training program prints out and saves updates at regular intervals (specified by the `summary_freq` option). The saved statistics are grouped by the `run-id` value so you should assign a unique id to each training run if you plan to view the statistics. You can view these statistics using TensorBoard during or after training by running the following command (from the ML-Agents python directory):
 
  
-When training is finished, you can find the saved model in the `python/models` folder under the assigned run-id — in the cats example, the path to the model would be `python/models/cob_1/CatsOnBicycles_cob_1.bytes`.
+When training is finished, you can find the saved model in the `models` folder
+under the assigned run-id — in the cats example, the path to the model would be
+`models/cob_1/CatsOnBicycles_cob_1.bytes`.
-In addition to passing the path of the Unity executable containing your training environment, you can set the following command line options when invoking `learn.py`:
+In addition to passing the path of the Unity executable containing your training environment, you can set the following command line options when invoking `mlagents-learn`:
+* `--env=<env>` - Specify an executable environment to train.
-* `--load` – If set, the training code loads an already trained model to initialize the neural network before training. The learning code looks for the model in `python/models/<run-id>/` (which is also where it saves models at the end of training). When not set (the default), the neural network weights are randomly initialized and an existing model is not loaded.
+* `--load` – If set, the training code loads an already trained model to initialize the neural network before training. The learning code looks for the model in `models/<run-id>/` (which is also where it saves models at the end of training). When not set (the default), the neural network weights are randomly initialized and an existing model is not loaded.
 * `--num-runs=<n>` - Sets the number of concurrent training sessions to perform. Default is set to 1. Set to higher values when benchmarking performance and multiple training sessions is desired. Training sessions are independent, and do not improve learning performance.
 * `--run-id=<path>` – Specifies an identifier for each training run. This identifier is used to name the subdirectories in which the trained model and summary statistics are saved as well as the saved model itself. The default id is "ppo". If you use TensorBoard to view the training statistics, always set a unique run-id for each training run. (The statistics for all runs with the same id are combined as if they were produced by a the same session.)
 * `--save-freq=<n>` Specifies how often (in  steps) to save the model during training. Defaults to 50000.
-* `--worker-id=<n>` – When you are running more than one training environment at the same time, assign each a unique worker-id number. The worker-id is added to the communication port opened between the current instance of learn.py and the ExternalCommunicator object in the Unity environment. Defaults to 0.
+* `--worker-id=<n>` – When you are running more than one training environment at the same time, assign each a unique worker-id number. The worker-id is added to the communication port opened between the current instance of `mlagents-learn` and the ExternalCommunicator object in the Unity environment. Defaults to 0.
-The training config file, `trainer_config.yaml` specifies the training method, the hyperparameters, and a few additional values to use during training. The file is divided into sections. The **default** section defines the default values for all the available settings. You can also add new sections to override these defaults to train specific Brains. Name each of these override sections after the GameObject containing the Brain component that should use these settings. (This GameObject will be a child of the Academy in your scene.) Sections for the example environments are included in the provided config file. `Learn.py` finds the config file by name and looks for it in the same directory as itself.
+The training config file, `config/trainer_config.yaml` specifies the training method, the hyperparameters, and a few additional values to use during training. The file is divided into sections. The **default** section defines the default values for all the available settings. You can also add new sections to override these defaults to train specific Brains. Name each of these override sections after the GameObject containing the Brain component that should use these settings. (This GameObject will be a child of the Academy in your scene.) Sections for the example environments are included in the provided config file.
 
 | ** Setting ** | **Description** | **Applies To Trainer**|
 | :--                | :--                       | :--                                  |
 * [Training with Curriculum Learning](Training-Curriculum-Learning.md)
 * [Training with Imitation Learning](Training-Imitation-Learning.md)
 
-You can also compare the [example environments](Learning-Environment-Examples.md) to the corresponding sections of the `trainer-config.yaml` file for each example to see how the hyperparameters and other configuration variables have been changed from the defaults.
+You can also compare the [example environments](Learning-Environment-Examples.md) to the corresponding sections of the `config/trainer_config.yaml` file for each example to see how the hyperparameters and other configuration variables have been changed from the defaults.

docs/Training-on-Amazon-Web-Service.md

 3. Select Linux as the Target Platform, and x86_64 as the target architecture.
 4. Check Headless Mode (If you haven't setup the X Server).
 5. Click Build to build the Unity environment executable.
-6. Upload the executable to your EC2 instance within `ml-agents/python` folder.
+6. Upload the executable to your EC2 instance within `ml-agents` folder.
 7. Test the instance setup from Python using:
 
     ```python

docs/Training-on-Microsoft-Azure.md

 
 ## Installing ML-Agents
 
-2. [Move](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/copy-files-to-linux-vm-using-scp) the `python` sub-folder of this ml-agents repo to the remote Azure instance, and set it as the working directory.
+2. [Move](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/copy-files-to-linux-vm-using-scp) the `ml-agents` sub-folder of this ml-agents repo to the remote Azure instance, and set it as the working directory.
 2. Install the required packages with `pip3 install .`.
 
 ## Testing
 To run your training on the VM:
 
 1.  [Move](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/copy-files-to-linux-vm-using-scp) your built Unity application to your Virtual Machine.
-2.  Set the `python` sub-folder of the ml-agents repo to your working directory.
+2.  Set the `ml-agents` sub-folder of the ml-agents repo to your working directory.
-python3 learn.py <your_app> --run-id=<run_id> --train
+mlagents-learn <trainer_config> --env=<your_app> --run-id=<run_id> --train
 ```
 
 Where `<your_app>` is the path to your app (i.e. `~/unity-volume/3DBallHeadless`) and `<run_id>` is an identifer you would like to identify your training run with.

docs/Using-Docker.md

 # Using Docker For ML-Agents
 
-We currently offer a solution for Windows and Mac users who would like to do training or inference using Docker. This option may be appealing to those who would like to avoid installing Python and TensorFlow themselves. The current setup forces both TensorFlow and Unity to _only_ rely on the CPU for computations. Consequently, our Docker simulation does not use a GPU and uses [`Xvfb`](https://en.wikipedia.org/wiki/Xvfb) to do visual rendering. `Xvfb` is a utility that enables `ML-Agents` (or any other application) to do rendering virtually i.e. it does not assume that the machine running `ML-Agents` has a GPU or a display attached to it. This means that rich environments which involve agents using camera-based visual observations might be slower.
+We currently offer a solution for Windows and Mac users who would like to do
+training or inference using Docker. This option may be appealing to those who
+would like to avoid installing Python and TensorFlow themselves. The current
+setup forces both TensorFlow and Unity to _only_ rely on the CPU for
+computations. Consequently, our Docker simulation does not use a GPU and uses
+[`Xvfb`](https://en.wikipedia.org/wiki/Xvfb) to do visual rendering. `Xvfb` is a
+utility that enables `ML-Agents` (or any other application) to do rendering
+virtually i.e. it does not assume that the machine running `ML-Agents` has a GPU
+or a display attached to it. This means that rich environments which involve
+agents using camera-based visual observations might be slower.
+## Requirements
-## Requirements
-- [Download](https://unity3d.com/get-unity/download) the Unity Installer and
-add the _Linux Build Support_ Component
+- [Download](https://unity3d.com/get-unity/download) the Unity Installer and add
+  the _Linux Build Support_ Component
-- [Download](https://www.docker.com/community-edition#/download) and
-install Docker if you don't have it setup on your machine.
+- [Download](https://www.docker.com/community-edition#/download) and install
+  Docker if you don't have it setup on your machine.
-- Since Docker runs a container in an environment that is isolated from the host machine, a mounted directory in your host machine is used to share data, e.g. the Unity executable, curriculum files and TensorFlow graph. For convenience, we created an empty `unity-volume` directory at the root of the repository for this purpose, but feel free to use any other directory. The remainder of this guide assumes that the `unity-volume` directory is the one used.
+- Since Docker runs a container in an environment that is isolated from the host
+  machine, a mounted directory in your host machine is used to share data, e.g.
+  the Unity executable, curriculum files and TensorFlow graph. For convenience,
+  we created an empty `unity-volume` directory at the root of the repository for
+  this purpose, but feel free to use any other directory. The remainder of this
+  guide assumes that the `unity-volume` directory is the one used.
-Using Docker for ML-Agents involves three steps: building the Unity environment with specific flags, building a Docker container and, finally, running the container. If you are not familiar with building a Unity environment for ML-Agents, please read through our [Getting Started with the 3D Balance Ball Example](Getting-Started-with-Balance-Ball.md) guide first.
+Using Docker for ML-Agents involves three steps: building the Unity environment
+with specific flags, building a Docker container and, finally, running the
+container. If you are not familiar with building a Unity environment for
+ML-Agents, please read through our [Getting Started with the 3D Balance Ball
+Example](Getting-Started-with-Balance-Ball.md) guide first.
+
-Since Docker typically runs a container sharing a (linux) kernel with the host machine, the 
-Unity environment **has** to be built for the **linux platform**. When building a Unity environment, please select the following options from the the Build Settings window:
+Since Docker typically runs a container sharing a (linux) kernel with the host
+machine, the Unity environment **has** to be built for the **linux platform**.
+When building a Unity environment, please select the following options from the
+the Build Settings window:
+
-- If the environment does not contain visual observations, you can select the `headless` option here.
+- If the environment does not contain visual observations, you can select the
+  `headless` option here.
-Then click `Build`, pick an environment name (e.g. `3DBall`) and set the output directory to `unity-volume`. After building, ensure that the file `<environment-name>.x86_64` and subdirectory `<environment-name>_Data/` are created under `unity-volume`.
+Then click `Build`, pick an environment name (e.g. `3DBall`) and set the output
+directory to `unity-volume`. After building, ensure that the file
+`<environment-name>.x86_64` and subdirectory `<environment-name>_Data/` are
+created under `unity-volume`.
-First, make sure the Docker engine is running on your machine. Then build the Docker container by calling the following command at the top-level of the repository:
+First, make sure the Docker engine is running on your machine. Then build the
+Docker container by calling the following command at the top-level of the
+repository:
-```
+```shell
-``` 
-Replace `<image-name>` with a name for the Docker image, e.g. `balance.ball.v0.1`.
+```
-**Note** if you modify hyperparameters in `trainer_config.yaml` you will have to build a new Docker Container before running.
+Replace `<image-name>` with a name for the Docker image, e.g.
+`balance.ball.v0.1`.
-Run the Docker container by calling the following command at the top-level of the repository:
+Run the Docker container by calling the following command at the top-level of
+the repository:
-```
+```shell
-           <image-name>:latest <environment-name> \
+           <image-name>:latest \
+           <trainer-config-path> \
+           --env=<environment-name> \
-- `<container-name>` is used to identify the container (in case you want to interrupt and terminate it). This is optional and Docker will generate a random name if this is not set. _Note that this must be unique for every run of a Docker image._
+
+- `<container-name>` is used to identify the container (in case you want to
+  interrupt and terminate it). This is optional and Docker will generate a
+  random name if this is not set. _Note that this must be unique for every run
+  of a Docker image._
-- `<environemnt-name>` __(Optional)__: If you are training with a linux executable, this is the name of the executable. If you are training in the Editor, do not pass a `<environemnt-name>` argument and press the :arrow_forward: button in Unity when the message _"Start training by pressing the Play button in the Unity Editor"_ is displayed on the screen.
-- `source`: Reference to the path in your host OS where you will store the Unity executable. 
-- `target`: Tells Docker to mount the `source` path as a disk with this name. 
-- `docker-target-name`: Tells the ML-Agents Python package what the name of the disk where it can read the Unity executable and store the graph. **This should therefore be identical to `target`.**
-- `train`, `run-id`: ML-Agents arguments passed to `learn.py`. `train` trains the algorithm, `run-id` is used to tag each experiment with a unique identifier. 
+- `<environment-name>` __(Optional)__: If you are training with a linux
+  executable, this is the name of the executable. If you are training in the
+  Editor, do not pass a `<environment-name>` argument and press the
+  :arrow_forward: button in Unity when the message _"Start training by pressing
+  the Play button in the Unity Editor"_ is displayed on the screen.
+- `source`: Reference to the path in your host OS where you will store the Unity
+  executable.
+- `target`: Tells Docker to mount the `source` path as a disk with this name.
+- `docker-target-name`: Tells the ML-Agents Python package what the name of the
+  disk where it can read the Unity executable and store the graph. **This should
+  therefore be identical to `target`.**
+- `trainer-config-path`, `train`, `run-id`: ML-Agents arguments passed to
+  `mlagents-learn`. `trainer-config-path` is the filepath of the trainer config
+  file, `train` trains the algorithm, and `run-id` is used to tag each
+  experiment with a unique identifier. We recommend placing the trainer-config
+  file inside `unity-volume` so that the container has access to the file.
-```
+```shell
+           <trainer-config-path> \
-For more detail on Docker mounts, check out [these](https://docs.docker.com/storage/bind-mounts/) docs from Docker.
-
+For more detail on Docker mounts, check out
+[these](https://docs.docker.com/storage/bind-mounts/) docs from Docker.
-If you are satisfied with the training progress, you can stop the Docker container while saving state by either using `Ctrl+C` or `⌘+C` (Mac) or by using the following command:
+If you are satisfied with the training progress, you can stop the Docker
+container while saving state by either using `Ctrl+C` or `⌘+C` (Mac) or by using
+the following command:
-```
+```shell
-`<container-name>` is the name of the container specified in the earlier `docker run` command. If you didn't specify one, you can find the randomly generated identifier by running `docker container ls`.
+`<container-name>` is the name of the container specified in the earlier `docker
+run` command. If you didn't specify one, you can find the randomly generated
+identifier by running `docker container ls`.

docs/Using-Tensorboard.md

 
 The ML-Agents toolkit saves statistics during learning session that you can view with a TensorFlow utility named, [TensorBoard](https://www.tensorflow.org/programmers_guide/summaries_and_tensorboard).
 
-The `learn.py` program saves training statistics to a folder named `summaries`, organized by the `run-id` value you assign to a training session.
+The `mlagents-learn` command saves training statistics to a folder named `summaries`, organized by the `run-id` value you assign to a training session.
 
 In order to observe the training process, either during training or afterward, 
 start TensorBoard:
 
 4. Open a browser window and navigate to [localhost:6006](http://localhost:6006).
 
-**Note:** If you don't assign a `run-id` identifier, `learn.py` uses the default string, "ppo". All the statistics will be saved to the same sub-folder and displayed as one session in TensorBoard. After a few runs, the displays can become difficult to interpret in this situation. You can delete the folders under the `summaries` directory to clear out old statistics.
+**Note:** If you don't assign a `run-id` identifier, `mlagents-learn` uses the default string, "ppo". All the statistics will be saved to the same sub-folder and displayed as one session in TensorBoard. After a few runs, the displays can become difficult to interpret in this situation. You can delete the folders under the `summaries` directory to clear out old statistics.
-When you run the training program, `learn.py`, you can use the `--save-freq` option to specify how frequently to save the statistics.
+When you run the training program, `mlagents-learn`, you can use the `--save-freq` option to specify how frequently to save the statistics.
 
 ## The ML-Agents toolkit training statistics
 

docs/dox-ml-agents.conf

 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = ../unity-environment/Assets/ML-Agents/Scripts/Academy.cs \
-                         ../unity-environment/Assets/ML-Agents/Scripts/Agent.cs \
-                         ../unity-environment/Assets/ML-Agents/Scripts/Monitor.cs \
-                         ../unity-environment/Assets/ML-Agents/Scripts/Decision.cs
+INPUT                  = ../MLAgentsSDK/Assets/ML-Agents/Scripts/Academy.cs \
+                         ../MLAgentsSDK/Assets/ML-Agents/Scripts/Agent.cs \
+                         ../MLAgentsSDK/Assets/ML-Agents/Scripts/Monitor.cs \
+                         ../MLAgentsSDK/Assets/ML-Agents/Scripts/Decision.cs
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses

gym-unity/Readme.md

 
 The returned environment `env` will function as a gym.
 
-For more on using the gym interface, see our [Jupyter Notebook tutorial](../python/notebooks/getting-started-gym.ipynb).
-
+For more on using the gym interface, see our [Jupyter Notebook tutorial](../notebooks/getting-started-gym.ipynb).
- * It is only possible to use an environment with a single Brain.
- * By default the first visual observation is provided as the `observation`, if present. Otherwise vector observations are provided. 
- * All `BrainInfo` output from the environment can still be accessed from the `info` provided by `env.step(action)`.
- * Stacked vector observations are not supported.
- * Environment registration for use with `gym.make()` is currently not supported.
-
+* It is only possible to use an environment with a single Brain.
+* By default the first visual observation is provided as the `observation`, if
+  present. Otherwise vector observations are provided. 
+* All `BrainInfo` output from the environment can still be accessed from the
+  `info` provided by `env.step(action)`.
+* Stacked vector observations are not supported.
+* Environment registration for use with `gym.make()` is currently not supported.
 
 ## Running OpenAI Baselines Algorithms
 

gym-unity/gym_unity/envs/unity_env.py

 import gym
 import numpy as np
-from unityagents import UnityEnvironment
+from mlagents.envs import UnityEnvironment
 from gym import error, spaces, logger
 
 

gym-unity/setup.py

       author_email='ML-Agents@unity3d.com',
       url='https://github.com/Unity-Technologies/ml-agents',
       packages=find_packages(),
-      install_requires = ['gym', 'unityagents']
+      install_requires = ['gym', 'mlagents']
      )

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityToExternalGrpc.cs.meta

 fileFormatVersion: 2
-guid: d3ea7da815b0b4d938c13e621f57db04
+guid: 0378b2871a6c649f69c2f32d5c0fb045
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityToExternalGrpc.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/unity_to_external.proto
+//     source: mlagents/envs/communicator_objects/unity_to_external.proto
-#pragma warning disable 1591
+#pragma warning disable 0414, 1591
 #region Designer generated code
 
 using grpc = global::Grpc.Core;
   {
     static readonly string __ServiceName = "communicator_objects.UnityToExternal";
 
-    static readonly grpc::Marshaller<global::MLAgents.CommunicatorObjects.UnityMessage> __Marshaller_UnityMessage = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::MLAgents.CommunicatorObjects.UnityMessage.Parser.ParseFrom);
+    static readonly grpc::Marshaller<global::MLAgents.CommunicatorObjects.UnityMessage> __Marshaller_communicator_objects_UnityMessage = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::MLAgents.CommunicatorObjects.UnityMessage.Parser.ParseFrom);
-        __Marshaller_UnityMessage,
-        __Marshaller_UnityMessage);
+        __Marshaller_communicator_objects_UnityMessage,
+        __Marshaller_communicator_objects_UnityMessage);
 
     /// <summary>Service descriptor</summary>
     public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityToExternal.cs.meta

 fileFormatVersion: 2
-guid: 553c6b5d2feba4ef69206f0e0a2a92a3
+guid: 199e76fc828bc4561abad51402438e07
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityToExternal.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/unity_to_external.proto
+//     source: mlagents/envs/communicator_objects/unity_to_external.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/unity_to_external.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/unity_to_external.proto</summary>
-    /// <summary>File descriptor for communicator_objects/unity_to_external.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/unity_to_external.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Cixjb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV90b19leHRlcm5hbC5wcm90",
-            "bxIUY29tbXVuaWNhdG9yX29iamVjdHMaKGNvbW11bmljYXRvcl9vYmplY3Rz",
-            "L3VuaXR5X21lc3NhZ2UucHJvdG8yZwoPVW5pdHlUb0V4dGVybmFsElQKCEV4",
-            "Y2hhbmdlEiIuY29tbXVuaWNhdG9yX29iamVjdHMuVW5pdHlNZXNzYWdlGiIu",
-            "Y29tbXVuaWNhdG9yX29iamVjdHMuVW5pdHlNZXNzYWdlIgBCH6oCHE1MQWdl",
-            "bnRzLkNvbW11bmljYXRvck9iamVjdHNiBnByb3RvMw=="));
+            "CjptbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X3Rv",
+            "X2V4dGVybmFsLnByb3RvEhRjb21tdW5pY2F0b3Jfb2JqZWN0cxo2bWxhZ2Vu",
+            "dHMvZW52cy9jb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9tZXNzYWdlLnBy",
+            "b3RvMmcKD1VuaXR5VG9FeHRlcm5hbBJUCghFeGNoYW5nZRIiLmNvbW11bmlj",
+            "YXRvcl9vYmplY3RzLlVuaXR5TWVzc2FnZRoiLmNvbW11bmljYXRvcl9vYmpl",
+            "Y3RzLlVuaXR5TWVzc2FnZSIAQh+qAhxNTEFnZW50cy5Db21tdW5pY2F0b3JP",
+            "YmplY3RzYgZwcm90bzM="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.UnityMessageReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(null, null));

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityRlOutput.cs.meta

 fileFormatVersion: 2
-guid: a6665911e84e24b7e970f63662f55713
+guid: af13b8fefefa74a948934dd273f94c4a
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityRlOutput.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/unity_rl_output.proto
+//     source: mlagents/envs/communicator_objects/unity_rl_output.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/unity_rl_output.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/unity_rl_output.proto</summary>
-    /// <summary>File descriptor for communicator_objects/unity_rl_output.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/unity_rl_output.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Cipjb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9ybF9vdXRwdXQucHJvdG8S",
-            "FGNvbW11bmljYXRvcl9vYmplY3RzGitjb21tdW5pY2F0b3Jfb2JqZWN0cy9h",
-            "Z2VudF9pbmZvX3Byb3RvLnByb3RvIqMCCg1Vbml0eVJMT3V0cHV0EhMKC2ds",
-            "b2JhbF9kb25lGAEgASgIEkcKCmFnZW50SW5mb3MYAiADKAsyMy5jb21tdW5p",
-            "Y2F0b3Jfb2JqZWN0cy5Vbml0eVJMT3V0cHV0LkFnZW50SW5mb3NFbnRyeRpJ",
-            "ChJMaXN0QWdlbnRJbmZvUHJvdG8SMwoFdmFsdWUYASADKAsyJC5jb21tdW5p",
-            "Y2F0b3Jfb2JqZWN0cy5BZ2VudEluZm9Qcm90bxppCg9BZ2VudEluZm9zRW50",
-            "cnkSCwoDa2V5GAEgASgJEkUKBXZhbHVlGAIgASgLMjYuY29tbXVuaWNhdG9y",
-            "X29iamVjdHMuVW5pdHlSTE91dHB1dC5MaXN0QWdlbnRJbmZvUHJvdG86AjgB",
-            "Qh+qAhxNTEFnZW50cy5Db21tdW5pY2F0b3JPYmplY3RzYgZwcm90bzM="));
+            "CjhtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X3Js",
+            "X291dHB1dC5wcm90bxIUY29tbXVuaWNhdG9yX29iamVjdHMaOW1sYWdlbnRz",
+            "L2VudnMvY29tbXVuaWNhdG9yX29iamVjdHMvYWdlbnRfaW5mb19wcm90by5w",
+            "cm90byKjAgoNVW5pdHlSTE91dHB1dBITCgtnbG9iYWxfZG9uZRgBIAEoCBJH",
+            "CgphZ2VudEluZm9zGAIgAygLMjMuY29tbXVuaWNhdG9yX29iamVjdHMuVW5p",
+            "dHlSTE91dHB1dC5BZ2VudEluZm9zRW50cnkaSQoSTGlzdEFnZW50SW5mb1By",
+            "b3RvEjMKBXZhbHVlGAEgAygLMiQuY29tbXVuaWNhdG9yX29iamVjdHMuQWdl",
+            "bnRJbmZvUHJvdG8aaQoPQWdlbnRJbmZvc0VudHJ5EgsKA2tleRgBIAEoCRJF",
+            "CgV2YWx1ZRgCIAEoCzI2LmNvbW11bmljYXRvcl9vYmplY3RzLlVuaXR5UkxP",
+            "dXRwdXQuTGlzdEFnZW50SW5mb1Byb3RvOgI4AUIfqgIcTUxBZ2VudHMuQ29t",
+            "bXVuaWNhdG9yT2JqZWN0c2IGcHJvdG8z"));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.AgentInfoProtoReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityRlInput.cs.meta

 fileFormatVersion: 2
-guid: 0283aaaebbbaf4c438db36396a5e3885
+guid: 24680ffa432734c09b4660d82303cbd2
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityRlInput.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/unity_rl_input.proto
+//     source: mlagents/envs/communicator_objects/unity_rl_input.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/unity_rl_input.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/unity_rl_input.proto</summary>
-    /// <summary>File descriptor for communicator_objects/unity_rl_input.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/unity_rl_input.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Ciljb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9ybF9pbnB1dC5wcm90bxIU",
-            "Y29tbXVuaWNhdG9yX29iamVjdHMaLWNvbW11bmljYXRvcl9vYmplY3RzL2Fn",
-            "ZW50X2FjdGlvbl9wcm90by5wcm90bxo3Y29tbXVuaWNhdG9yX29iamVjdHMv",
-            "ZW52aXJvbm1lbnRfcGFyYW1ldGVyc19wcm90by5wcm90bxooY29tbXVuaWNh",
-            "dG9yX29iamVjdHMvY29tbWFuZF9wcm90by5wcm90byK0AwoMVW5pdHlSTElu",
-            "cHV0EksKDWFnZW50X2FjdGlvbnMYASADKAsyNC5jb21tdW5pY2F0b3Jfb2Jq",
-            "ZWN0cy5Vbml0eVJMSW5wdXQuQWdlbnRBY3Rpb25zRW50cnkSUAoWZW52aXJv",
-            "bm1lbnRfcGFyYW1ldGVycxgCIAEoCzIwLmNvbW11bmljYXRvcl9vYmplY3Rz",
-            "LkVudmlyb25tZW50UGFyYW1ldGVyc1Byb3RvEhMKC2lzX3RyYWluaW5nGAMg",
-            "ASgIEjMKB2NvbW1hbmQYBCABKA4yIi5jb21tdW5pY2F0b3Jfb2JqZWN0cy5D",
-            "b21tYW5kUHJvdG8aTQoUTGlzdEFnZW50QWN0aW9uUHJvdG8SNQoFdmFsdWUY",
-            "ASADKAsyJi5jb21tdW5pY2F0b3Jfb2JqZWN0cy5BZ2VudEFjdGlvblByb3Rv",
-            "GmwKEUFnZW50QWN0aW9uc0VudHJ5EgsKA2tleRgBIAEoCRJGCgV2YWx1ZRgC",
-            "IAEoCzI3LmNvbW11bmljYXRvcl9vYmplY3RzLlVuaXR5UkxJbnB1dC5MaXN0",
-            "QWdlbnRBY3Rpb25Qcm90bzoCOAFCH6oCHE1MQWdlbnRzLkNvbW11bmljYXRv",
-            "ck9iamVjdHNiBnByb3RvMw=="));
+            "CjdtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X3Js",
+            "X2lucHV0LnByb3RvEhRjb21tdW5pY2F0b3Jfb2JqZWN0cxo7bWxhZ2VudHMv",
+            "ZW52cy9jb21tdW5pY2F0b3Jfb2JqZWN0cy9hZ2VudF9hY3Rpb25fcHJvdG8u",
+            "cHJvdG8aRW1sYWdlbnRzL2VudnMvY29tbXVuaWNhdG9yX29iamVjdHMvZW52",
+            "aXJvbm1lbnRfcGFyYW1ldGVyc19wcm90by5wcm90bxo2bWxhZ2VudHMvZW52",
+            "cy9jb21tdW5pY2F0b3Jfb2JqZWN0cy9jb21tYW5kX3Byb3RvLnByb3RvIrQD",
+            "CgxVbml0eVJMSW5wdXQSSwoNYWdlbnRfYWN0aW9ucxgBIAMoCzI0LmNvbW11",
+            "bmljYXRvcl9vYmplY3RzLlVuaXR5UkxJbnB1dC5BZ2VudEFjdGlvbnNFbnRy",
+            "eRJQChZlbnZpcm9ubWVudF9wYXJhbWV0ZXJzGAIgASgLMjAuY29tbXVuaWNh",
+            "dG9yX29iamVjdHMuRW52aXJvbm1lbnRQYXJhbWV0ZXJzUHJvdG8SEwoLaXNf",
+            "dHJhaW5pbmcYAyABKAgSMwoHY29tbWFuZBgEIAEoDjIiLmNvbW11bmljYXRv",
+            "cl9vYmplY3RzLkNvbW1hbmRQcm90bxpNChRMaXN0QWdlbnRBY3Rpb25Qcm90",
+            "bxI1CgV2YWx1ZRgBIAMoCzImLmNvbW11bmljYXRvcl9vYmplY3RzLkFnZW50",
+            "QWN0aW9uUHJvdG8abAoRQWdlbnRBY3Rpb25zRW50cnkSCwoDa2V5GAEgASgJ",
+            "EkYKBXZhbHVlGAIgASgLMjcuY29tbXVuaWNhdG9yX29iamVjdHMuVW5pdHlS",
+            "TElucHV0Lkxpc3RBZ2VudEFjdGlvblByb3RvOgI4AUIfqgIcTUxBZ2VudHMu",
+            "Q29tbXVuaWNhdG9yT2JqZWN0c2IGcHJvdG8z"));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.AgentActionProtoReflection.Descriptor, global::MLAgents.CommunicatorObjects.EnvironmentParametersProtoReflection.Descriptor, global::MLAgents.CommunicatorObjects.CommandProtoReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public UnityRLInput(UnityRLInput other) : this() {
       agentActions_ = other.agentActions_.Clone();
-      EnvironmentParameters = other.environmentParameters_ != null ? other.EnvironmentParameters.Clone() : null;
+      environmentParameters_ = other.environmentParameters_ != null ? other.environmentParameters_.Clone() : null;
       isTraining_ = other.isTraining_;
       command_ = other.command_;
       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityRlInitializationOutput.cs.meta

 fileFormatVersion: 2
-guid: cfac266f05f674dbd8dc50e8e9b29753
+guid: f7ac9dd525a2246688054b2442eda28a
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityRlInitializationOutput.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/unity_rl_initialization_output.proto
+//     source: mlagents/envs/communicator_objects/unity_rl_initialization_output.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/unity_rl_initialization_output.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/unity_rl_initialization_output.proto</summary>
-    /// <summary>File descriptor for communicator_objects/unity_rl_initialization_output.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/unity_rl_initialization_output.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Cjljb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9ybF9pbml0aWFsaXphdGlv",
-            "bl9vdXRwdXQucHJvdG8SFGNvbW11bmljYXRvcl9vYmplY3RzGjFjb21tdW5p",
-            "Y2F0b3Jfb2JqZWN0cy9icmFpbl9wYXJhbWV0ZXJzX3Byb3RvLnByb3RvGjdj",
-            "b21tdW5pY2F0b3Jfb2JqZWN0cy9lbnZpcm9ubWVudF9wYXJhbWV0ZXJzX3By",
-            "b3RvLnByb3RvIuYBChtVbml0eVJMSW5pdGlhbGl6YXRpb25PdXRwdXQSDAoE",
-            "bmFtZRgBIAEoCRIPCgd2ZXJzaW9uGAIgASgJEhAKCGxvZ19wYXRoGAMgASgJ",
-            "EkQKEGJyYWluX3BhcmFtZXRlcnMYBSADKAsyKi5jb21tdW5pY2F0b3Jfb2Jq",
-            "ZWN0cy5CcmFpblBhcmFtZXRlcnNQcm90bxJQChZlbnZpcm9ubWVudF9wYXJh",
-            "bWV0ZXJzGAYgASgLMjAuY29tbXVuaWNhdG9yX29iamVjdHMuRW52aXJvbm1l",
-            "bnRQYXJhbWV0ZXJzUHJvdG9CH6oCHE1MQWdlbnRzLkNvbW11bmljYXRvck9i",
-            "amVjdHNiBnByb3RvMw=="));
+            "CkdtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X3Js",
+            "X2luaXRpYWxpemF0aW9uX291dHB1dC5wcm90bxIUY29tbXVuaWNhdG9yX29i",
+            "amVjdHMaP21sYWdlbnRzL2VudnMvY29tbXVuaWNhdG9yX29iamVjdHMvYnJh",
+            "aW5fcGFyYW1ldGVyc19wcm90by5wcm90bxpFbWxhZ2VudHMvZW52cy9jb21t",
+            "dW5pY2F0b3Jfb2JqZWN0cy9lbnZpcm9ubWVudF9wYXJhbWV0ZXJzX3Byb3Rv",
+            "LnByb3RvIuYBChtVbml0eVJMSW5pdGlhbGl6YXRpb25PdXRwdXQSDAoEbmFt",
+            "ZRgBIAEoCRIPCgd2ZXJzaW9uGAIgASgJEhAKCGxvZ19wYXRoGAMgASgJEkQK",
+            "EGJyYWluX3BhcmFtZXRlcnMYBSADKAsyKi5jb21tdW5pY2F0b3Jfb2JqZWN0",
+            "cy5CcmFpblBhcmFtZXRlcnNQcm90bxJQChZlbnZpcm9ubWVudF9wYXJhbWV0",
+            "ZXJzGAYgASgLMjAuY29tbXVuaWNhdG9yX29iamVjdHMuRW52aXJvbm1lbnRQ",
+            "YXJhbWV0ZXJzUHJvdG9CH6oCHE1MQWdlbnRzLkNvbW11bmljYXRvck9iamVj",
+            "dHNiBnByb3RvMw=="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.BrainParametersProtoReflection.Descriptor, global::MLAgents.CommunicatorObjects.EnvironmentParametersProtoReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
       version_ = other.version_;
       logPath_ = other.logPath_;
       brainParameters_ = other.brainParameters_.Clone();
-      EnvironmentParameters = other.environmentParameters_ != null ? other.EnvironmentParameters.Clone() : null;
+      environmentParameters_ = other.environmentParameters_ != null ? other.environmentParameters_.Clone() : null;
       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
     }
 

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityRlInitializationInput.cs.meta

 fileFormatVersion: 2
-guid: d9c1712ba119a47458082c7190c838b0
+guid: 6c81750abd5a9432babe1834534122c0
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityRlInitializationInput.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/unity_rl_initialization_input.proto
+//     source: mlagents/envs/communicator_objects/unity_rl_initialization_input.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/unity_rl_initialization_input.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/unity_rl_initialization_input.proto</summary>
-    /// <summary>File descriptor for communicator_objects/unity_rl_initialization_input.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/unity_rl_initialization_input.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Cjhjb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9ybF9pbml0aWFsaXphdGlv",
-            "bl9pbnB1dC5wcm90bxIUY29tbXVuaWNhdG9yX29iamVjdHMiKgoaVW5pdHlS",
-            "TEluaXRpYWxpemF0aW9uSW5wdXQSDAoEc2VlZBgBIAEoBUIfqgIcTUxBZ2Vu",
-            "dHMuQ29tbXVuaWNhdG9yT2JqZWN0c2IGcHJvdG8z"));
+            "CkZtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X3Js",
+            "X2luaXRpYWxpemF0aW9uX2lucHV0LnByb3RvEhRjb21tdW5pY2F0b3Jfb2Jq",
+            "ZWN0cyIqChpVbml0eVJMSW5pdGlhbGl6YXRpb25JbnB1dBIMCgRzZWVkGAEg",
+            "ASgFQh+qAhxNTEFnZW50cy5Db21tdW5pY2F0b3JPYmplY3RzYgZwcm90bzM="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityOutput.cs.meta

 fileFormatVersion: 2
-guid: 546f38fe479d240eabdf11ac55ecf7d4
+guid: 5b7166f97831f45ef86df5eed0042240
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityOutput.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/unity_output.proto
+//     source: mlagents/envs/communicator_objects/unity_output.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/unity_output.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/unity_output.proto</summary>
-    /// <summary>File descriptor for communicator_objects/unity_output.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/unity_output.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Cidjb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9vdXRwdXQucHJvdG8SFGNv",
-            "bW11bmljYXRvcl9vYmplY3RzGipjb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0",
-            "eV9ybF9vdXRwdXQucHJvdG8aOWNvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5",
-            "X3JsX2luaXRpYWxpemF0aW9uX291dHB1dC5wcm90byKaAQoLVW5pdHlPdXRw",
-            "dXQSNgoJcmxfb3V0cHV0GAEgASgLMiMuY29tbXVuaWNhdG9yX29iamVjdHMu",
-            "VW5pdHlSTE91dHB1dBJTChhybF9pbml0aWFsaXphdGlvbl9vdXRwdXQYAiAB",
-            "KAsyMS5jb21tdW5pY2F0b3Jfb2JqZWN0cy5Vbml0eVJMSW5pdGlhbGl6YXRp",
-            "b25PdXRwdXRCH6oCHE1MQWdlbnRzLkNvbW11bmljYXRvck9iamVjdHNiBnBy",
-            "b3RvMw=="));
+            "CjVtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X291",
+            "dHB1dC5wcm90bxIUY29tbXVuaWNhdG9yX29iamVjdHMaOG1sYWdlbnRzL2Vu",
+            "dnMvY29tbXVuaWNhdG9yX29iamVjdHMvdW5pdHlfcmxfb3V0cHV0LnByb3Rv",
+            "GkdtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X3Js",
+            "X2luaXRpYWxpemF0aW9uX291dHB1dC5wcm90byKaAQoLVW5pdHlPdXRwdXQS",
+            "NgoJcmxfb3V0cHV0GAEgASgLMiMuY29tbXVuaWNhdG9yX29iamVjdHMuVW5p",
+            "dHlSTE91dHB1dBJTChhybF9pbml0aWFsaXphdGlvbl9vdXRwdXQYAiABKAsy",
+            "MS5jb21tdW5pY2F0b3Jfb2JqZWN0cy5Vbml0eVJMSW5pdGlhbGl6YXRpb25P",
+            "dXRwdXRCH6oCHE1MQWdlbnRzLkNvbW11bmljYXRvck9iamVjdHNiBnByb3Rv",
+            "Mw=="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.UnityRlOutputReflection.Descriptor, global::MLAgents.CommunicatorObjects.UnityRlInitializationOutputReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
 
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public UnityOutput(UnityOutput other) : this() {
-      RlOutput = other.rlOutput_ != null ? other.RlOutput.Clone() : null;
-      RlInitializationOutput = other.rlInitializationOutput_ != null ? other.RlInitializationOutput.Clone() : null;
+      rlOutput_ = other.rlOutput_ != null ? other.rlOutput_.Clone() : null;
+      rlInitializationOutput_ = other.rlInitializationOutput_ != null ? other.rlInitializationOutput_.Clone() : null;
       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
     }
 

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityMessage.cs.meta

 fileFormatVersion: 2
-guid: 10dca984632854b079476d5fb6df329c
+guid: d270bf9ce3d564bb48b2095802c15ff9
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityMessage.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/unity_message.proto
+//     source: mlagents/envs/communicator_objects/unity_message.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/unity_message.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/unity_message.proto</summary>
-    /// <summary>File descriptor for communicator_objects/unity_message.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/unity_message.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Cihjb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9tZXNzYWdlLnByb3RvEhRj",
-            "b21tdW5pY2F0b3Jfb2JqZWN0cxonY29tbXVuaWNhdG9yX29iamVjdHMvdW5p",
-            "dHlfb3V0cHV0LnByb3RvGiZjb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9p",
-            "bnB1dC5wcm90bxohY29tbXVuaWNhdG9yX29iamVjdHMvaGVhZGVyLnByb3Rv",
-            "IqwBCgxVbml0eU1lc3NhZ2USLAoGaGVhZGVyGAEgASgLMhwuY29tbXVuaWNh",
-            "dG9yX29iamVjdHMuSGVhZGVyEjcKDHVuaXR5X291dHB1dBgCIAEoCzIhLmNv",
-            "bW11bmljYXRvcl9vYmplY3RzLlVuaXR5T3V0cHV0EjUKC3VuaXR5X2lucHV0",
-            "GAMgASgLMiAuY29tbXVuaWNhdG9yX29iamVjdHMuVW5pdHlJbnB1dEIfqgIc",
-            "TUxBZ2VudHMuQ29tbXVuaWNhdG9yT2JqZWN0c2IGcHJvdG8z"));
+            "CjZtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X21l",
+            "c3NhZ2UucHJvdG8SFGNvbW11bmljYXRvcl9vYmplY3RzGjVtbGFnZW50cy9l",
+            "bnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X291dHB1dC5wcm90bxo0",
+            "bWxhZ2VudHMvZW52cy9jb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9pbnB1",
+            "dC5wcm90bxovbWxhZ2VudHMvZW52cy9jb21tdW5pY2F0b3Jfb2JqZWN0cy9o",
+            "ZWFkZXIucHJvdG8irAEKDFVuaXR5TWVzc2FnZRIsCgZoZWFkZXIYASABKAsy",
+            "HC5jb21tdW5pY2F0b3Jfb2JqZWN0cy5IZWFkZXISNwoMdW5pdHlfb3V0cHV0",
+            "GAIgASgLMiEuY29tbXVuaWNhdG9yX29iamVjdHMuVW5pdHlPdXRwdXQSNQoL",
+            "dW5pdHlfaW5wdXQYAyABKAsyIC5jb21tdW5pY2F0b3Jfb2JqZWN0cy5Vbml0",
+            "eUlucHV0Qh+qAhxNTEFnZW50cy5Db21tdW5pY2F0b3JPYmplY3RzYgZwcm90",
+            "bzM="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.UnityOutputReflection.Descriptor, global::MLAgents.CommunicatorObjects.UnityInputReflection.Descriptor, global::MLAgents.CommunicatorObjects.HeaderReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
 
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public UnityMessage(UnityMessage other) : this() {
-      Header = other.header_ != null ? other.Header.Clone() : null;
-      UnityOutput = other.unityOutput_ != null ? other.UnityOutput.Clone() : null;
-      UnityInput = other.unityInput_ != null ? other.UnityInput.Clone() : null;
+      header_ = other.header_ != null ? other.header_.Clone() : null;
+      unityOutput_ = other.unityOutput_ != null ? other.unityOutput_.Clone() : null;
+      unityInput_ = other.unityInput_ != null ? other.unityInput_.Clone() : null;
       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
     }
 

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityInput.cs.meta

 fileFormatVersion: 2
-guid: c97e6e2cde58d404cba31008c0489454
+guid: 25e46cd9eca204e19a08fa938802ef9d
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/UnityInput.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/unity_input.proto
+//     source: mlagents/envs/communicator_objects/unity_input.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/unity_input.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/unity_input.proto</summary>
-    /// <summary>File descriptor for communicator_objects/unity_input.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/unity_input.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "CiZjb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9pbnB1dC5wcm90bxIUY29t",
-            "bXVuaWNhdG9yX29iamVjdHMaKWNvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5",
-            "X3JsX2lucHV0LnByb3RvGjhjb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9y",
-            "bF9pbml0aWFsaXphdGlvbl9pbnB1dC5wcm90byKVAQoKVW5pdHlJbnB1dBI0",
-            "CghybF9pbnB1dBgBIAEoCzIiLmNvbW11bmljYXRvcl9vYmplY3RzLlVuaXR5",
-            "UkxJbnB1dBJRChdybF9pbml0aWFsaXphdGlvbl9pbnB1dBgCIAEoCzIwLmNv",
-            "bW11bmljYXRvcl9vYmplY3RzLlVuaXR5UkxJbml0aWFsaXphdGlvbklucHV0",
-            "Qh+qAhxNTEFnZW50cy5Db21tdW5pY2F0b3JPYmplY3RzYgZwcm90bzM="));
+            "CjRtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X2lu",
+            "cHV0LnByb3RvEhRjb21tdW5pY2F0b3Jfb2JqZWN0cxo3bWxhZ2VudHMvZW52",
+            "cy9jb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9ybF9pbnB1dC5wcm90bxpG",
+            "bWxhZ2VudHMvZW52cy9jb21tdW5pY2F0b3Jfb2JqZWN0cy91bml0eV9ybF9p",
+            "bml0aWFsaXphdGlvbl9pbnB1dC5wcm90byKVAQoKVW5pdHlJbnB1dBI0Cghy",
+            "bF9pbnB1dBgBIAEoCzIiLmNvbW11bmljYXRvcl9vYmplY3RzLlVuaXR5UkxJ",
+            "bnB1dBJRChdybF9pbml0aWFsaXphdGlvbl9pbnB1dBgCIAEoCzIwLmNvbW11",
+            "bmljYXRvcl9vYmplY3RzLlVuaXR5UkxJbml0aWFsaXphdGlvbklucHV0Qh+q",
+            "AhxNTEFnZW50cy5Db21tdW5pY2F0b3JPYmplY3RzYgZwcm90bzM="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.UnityRlInputReflection.Descriptor, global::MLAgents.CommunicatorObjects.UnityRlInitializationInputReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
 
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public UnityInput(UnityInput other) : this() {
-      RlInput = other.rlInput_ != null ? other.RlInput.Clone() : null;
-      RlInitializationInput = other.rlInitializationInput_ != null ? other.RlInitializationInput.Clone() : null;
+      rlInput_ = other.rlInput_ != null ? other.rlInput_.Clone() : null;
+      rlInitializationInput_ = other.rlInitializationInput_ != null ? other.rlInitializationInput_.Clone() : null;
       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
     }
 

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/SpaceTypeProto.cs.meta

 fileFormatVersion: 2
-guid: bf7e44e20999448ef846526541819077
+guid: 3e61637749b07412284363ff304da763
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/SpaceTypeProto.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/space_type_proto.proto
+//     source: mlagents/envs/communicator_objects/space_type_proto.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/space_type_proto.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/space_type_proto.proto</summary>
-    /// <summary>File descriptor for communicator_objects/space_type_proto.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/space_type_proto.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Citjb21tdW5pY2F0b3Jfb2JqZWN0cy9zcGFjZV90eXBlX3Byb3RvLnByb3Rv",
-            "EhRjb21tdW5pY2F0b3Jfb2JqZWN0cxorY29tbXVuaWNhdG9yX29iamVjdHMv",
-            "cmVzb2x1dGlvbl9wcm90by5wcm90byouCg5TcGFjZVR5cGVQcm90bxIMCghk",
-            "aXNjcmV0ZRAAEg4KCmNvbnRpbnVvdXMQAUIfqgIcTUxBZ2VudHMuQ29tbXVu",
-            "aWNhdG9yT2JqZWN0c2IGcHJvdG8z"));
+            "CjltbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3NwYWNlX3R5",
+            "cGVfcHJvdG8ucHJvdG8SFGNvbW11bmljYXRvcl9vYmplY3RzGjltbGFnZW50",
+            "cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3Jlc29sdXRpb25fcHJvdG8u",
+            "cHJvdG8qLgoOU3BhY2VUeXBlUHJvdG8SDAoIZGlzY3JldGUQABIOCgpjb250",
+            "aW51b3VzEAFCH6oCHE1MQWdlbnRzLkNvbW11bmljYXRvck9iamVjdHNiBnBy",
+            "b3RvMw=="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.ResolutionProtoReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(new[] {typeof(global::MLAgents.CommunicatorObjects.SpaceTypeProto), }, null));

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/ResolutionProto.cs.meta

 fileFormatVersion: 2
-guid: ca2454611610e4136a412b5cd6afee4d
+guid: eae234f817240444a9d18b3d7366f260
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/ResolutionProto.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/resolution_proto.proto
+//     source: mlagents/envs/communicator_objects/resolution_proto.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/resolution_proto.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/resolution_proto.proto</summary>
-    /// <summary>File descriptor for communicator_objects/resolution_proto.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/resolution_proto.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Citjb21tdW5pY2F0b3Jfb2JqZWN0cy9yZXNvbHV0aW9uX3Byb3RvLnByb3Rv",
-            "EhRjb21tdW5pY2F0b3Jfb2JqZWN0cyJECg9SZXNvbHV0aW9uUHJvdG8SDQoF",
-            "d2lkdGgYASABKAUSDgoGaGVpZ2h0GAIgASgFEhIKCmdyYXlfc2NhbGUYAyAB",
-            "KAhCH6oCHE1MQWdlbnRzLkNvbW11bmljYXRvck9iamVjdHNiBnByb3RvMw=="));
+            "CjltbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3Jlc29sdXRp",
+            "b25fcHJvdG8ucHJvdG8SFGNvbW11bmljYXRvcl9vYmplY3RzIkQKD1Jlc29s",
+            "dXRpb25Qcm90bxINCgV3aWR0aBgBIAEoBRIOCgZoZWlnaHQYAiABKAUSEgoK",
+            "Z3JheV9zY2FsZRgDIAEoCEIfqgIcTUxBZ2VudHMuQ29tbXVuaWNhdG9yT2Jq",
+            "ZWN0c2IGcHJvdG8z"));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/Header.cs.meta

 fileFormatVersion: 2
-guid: e582b089dfedc438d9cbce9d4017b807
+guid: 8bb8aabfab48b408381733bccccd5af9
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/Header.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/header.proto
+//     source: mlagents/envs/communicator_objects/header.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/header.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/header.proto</summary>
-    /// <summary>File descriptor for communicator_objects/header.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/header.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "CiFjb21tdW5pY2F0b3Jfb2JqZWN0cy9oZWFkZXIucHJvdG8SFGNvbW11bmlj",
-            "YXRvcl9vYmplY3RzIikKBkhlYWRlchIOCgZzdGF0dXMYASABKAUSDwoHbWVz",
-            "c2FnZRgCIAEoCUIfqgIcTUxBZ2VudHMuQ29tbXVuaWNhdG9yT2JqZWN0c2IG",
-            "cHJvdG8z"));
+            "Ci9tbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL2hlYWRlci5w",
+            "cm90bxIUY29tbXVuaWNhdG9yX29iamVjdHMiKQoGSGVhZGVyEg4KBnN0YXR1",
+            "cxgBIAEoBRIPCgdtZXNzYWdlGAIgASgJQh+qAhxNTEFnZW50cy5Db21tdW5p",
+            "Y2F0b3JPYmplY3RzYgZwcm90bzM="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/EnvironmentParametersProto.cs.meta

 fileFormatVersion: 2
-guid: 312dc062dfab44416a31b8b273cda29a
+guid: be8c5f75bdcff41488a8e85748541100
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/EnvironmentParametersProto.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/environment_parameters_proto.proto
+//     source: mlagents/envs/communicator_objects/environment_parameters_proto.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/environment_parameters_proto.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/environment_parameters_proto.proto</summary>
-    /// <summary>File descriptor for communicator_objects/environment_parameters_proto.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/environment_parameters_proto.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Cjdjb21tdW5pY2F0b3Jfb2JqZWN0cy9lbnZpcm9ubWVudF9wYXJhbWV0ZXJz",
-            "X3Byb3RvLnByb3RvEhRjb21tdW5pY2F0b3Jfb2JqZWN0cyK1AQoaRW52aXJv",
-            "bm1lbnRQYXJhbWV0ZXJzUHJvdG8SXwoQZmxvYXRfcGFyYW1ldGVycxgBIAMo",
-            "CzJFLmNvbW11bmljYXRvcl9vYmplY3RzLkVudmlyb25tZW50UGFyYW1ldGVy",
-            "c1Byb3RvLkZsb2F0UGFyYW1ldGVyc0VudHJ5GjYKFEZsb2F0UGFyYW1ldGVy",
-            "c0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoAjoCOAFCH6oCHE1M",
-            "QWdlbnRzLkNvbW11bmljYXRvck9iamVjdHNiBnByb3RvMw=="));
+            "CkVtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL2Vudmlyb25t",
+            "ZW50X3BhcmFtZXRlcnNfcHJvdG8ucHJvdG8SFGNvbW11bmljYXRvcl9vYmpl",
+            "Y3RzIrUBChpFbnZpcm9ubWVudFBhcmFtZXRlcnNQcm90bxJfChBmbG9hdF9w",
+            "YXJhbWV0ZXJzGAEgAygLMkUuY29tbXVuaWNhdG9yX29iamVjdHMuRW52aXJv",
+            "bm1lbnRQYXJhbWV0ZXJzUHJvdG8uRmxvYXRQYXJhbWV0ZXJzRW50cnkaNgoU",
+            "RmxvYXRQYXJhbWV0ZXJzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIg",
+            "ASgCOgI4AUIfqgIcTUxBZ2VudHMuQ29tbXVuaWNhdG9yT2JqZWN0c2IGcHJv",
+            "dG8z"));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/EngineConfigurationProto.cs.meta

 fileFormatVersion: 2
-guid: fac934345fc664df8823b494ea9b1ca8
+guid: 2cebeb1263d7846b4b3c7c6e5d5e193f
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/EngineConfigurationProto.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/engine_configuration_proto.proto
+//     source: mlagents/envs/communicator_objects/engine_configuration_proto.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/engine_configuration_proto.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/engine_configuration_proto.proto</summary>
-    /// <summary>File descriptor for communicator_objects/engine_configuration_proto.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/engine_configuration_proto.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "CjVjb21tdW5pY2F0b3Jfb2JqZWN0cy9lbmdpbmVfY29uZmlndXJhdGlvbl9w",
-            "cm90by5wcm90bxIUY29tbXVuaWNhdG9yX29iamVjdHMilQEKGEVuZ2luZUNv",
-            "bmZpZ3VyYXRpb25Qcm90bxINCgV3aWR0aBgBIAEoBRIOCgZoZWlnaHQYAiAB",
-            "KAUSFQoNcXVhbGl0eV9sZXZlbBgDIAEoBRISCgp0aW1lX3NjYWxlGAQgASgC",
-            "EhkKEXRhcmdldF9mcmFtZV9yYXRlGAUgASgFEhQKDHNob3dfbW9uaXRvchgG",
-            "IAEoCEIfqgIcTUxBZ2VudHMuQ29tbXVuaWNhdG9yT2JqZWN0c2IGcHJvdG8z"));
+            "CkNtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL2VuZ2luZV9j",
+            "b25maWd1cmF0aW9uX3Byb3RvLnByb3RvEhRjb21tdW5pY2F0b3Jfb2JqZWN0",
+            "cyKVAQoYRW5naW5lQ29uZmlndXJhdGlvblByb3RvEg0KBXdpZHRoGAEgASgF",
+            "Eg4KBmhlaWdodBgCIAEoBRIVCg1xdWFsaXR5X2xldmVsGAMgASgFEhIKCnRp",
+            "bWVfc2NhbGUYBCABKAISGQoRdGFyZ2V0X2ZyYW1lX3JhdGUYBSABKAUSFAoM",
+            "c2hvd19tb25pdG9yGAYgASgIQh+qAhxNTEFnZW50cy5Db21tdW5pY2F0b3JP",
+            "YmplY3RzYgZwcm90bzM="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/CommandProto.cs.meta

 fileFormatVersion: 2
-guid: 19e8be280f78249c188fde36f0855094
+guid: 6b2ff9fe2c38b4e79aba78908cc5492c
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/CommandProto.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/command_proto.proto
+//     source: mlagents/envs/communicator_objects/command_proto.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/command_proto.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/command_proto.proto</summary>
-    /// <summary>File descriptor for communicator_objects/command_proto.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/command_proto.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Cihjb21tdW5pY2F0b3Jfb2JqZWN0cy9jb21tYW5kX3Byb3RvLnByb3RvEhRj",
-            "b21tdW5pY2F0b3Jfb2JqZWN0cyotCgxDb21tYW5kUHJvdG8SCAoEU1RFUBAA",
-            "EgkKBVJFU0VUEAESCAoEUVVJVBACQh+qAhxNTEFnZW50cy5Db21tdW5pY2F0",
-            "b3JPYmplY3RzYgZwcm90bzM="));
+            "CjZtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL2NvbW1hbmRf",
+            "cHJvdG8ucHJvdG8SFGNvbW11bmljYXRvcl9vYmplY3RzKi0KDENvbW1hbmRQ",
+            "cm90bxIICgRTVEVQEAASCQoFUkVTRVQQARIICgRRVUlUEAJCH6oCHE1MQWdl",
+            "bnRzLkNvbW11bmljYXRvck9iamVjdHNiBnByb3RvMw=="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { },
           new pbr::GeneratedClrTypeInfo(new[] {typeof(global::MLAgents.CommunicatorObjects.CommandProto), }, null));

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/BrainTypeProto.cs.meta

 fileFormatVersion: 2
-guid: d2e4f3cea300049b7a4cd65fbee2ee95
+guid: 8a44faf5235584f06ae45eb976a247a9
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/BrainTypeProto.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/brain_type_proto.proto
+//     source: mlagents/envs/communicator_objects/brain_type_proto.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/brain_type_proto.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/brain_type_proto.proto</summary>
-    /// <summary>File descriptor for communicator_objects/brain_type_proto.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/brain_type_proto.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Citjb21tdW5pY2F0b3Jfb2JqZWN0cy9icmFpbl90eXBlX3Byb3RvLnByb3Rv",
-            "EhRjb21tdW5pY2F0b3Jfb2JqZWN0cxorY29tbXVuaWNhdG9yX29iamVjdHMv",
-            "cmVzb2x1dGlvbl9wcm90by5wcm90bypHCg5CcmFpblR5cGVQcm90bxIKCgZQ",
-            "bGF5ZXIQABINCglIZXVyaXN0aWMQARIMCghFeHRlcm5hbBACEgwKCEludGVy",
-            "bmFsEANCH6oCHE1MQWdlbnRzLkNvbW11bmljYXRvck9iamVjdHNiBnByb3Rv",
-            "Mw=="));
+            "CjltbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL2JyYWluX3R5",
+            "cGVfcHJvdG8ucHJvdG8SFGNvbW11bmljYXRvcl9vYmplY3RzGjltbGFnZW50",
+            "cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3Jlc29sdXRpb25fcHJvdG8u",
+            "cHJvdG8qRwoOQnJhaW5UeXBlUHJvdG8SCgoGUGxheWVyEAASDQoJSGV1cmlz",
+            "dGljEAESDAoIRXh0ZXJuYWwQAhIMCghJbnRlcm5hbBADQh+qAhxNTEFnZW50",
+            "cy5Db21tdW5pY2F0b3JPYmplY3RzYgZwcm90bzM="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.ResolutionProtoReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(new[] {typeof(global::MLAgents.CommunicatorObjects.BrainTypeProto), }, null));

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/BrainParametersProto.cs.meta

 fileFormatVersion: 2
-guid: 91e3353985a4c4c08a8004648a81de4f
+guid: 7b41acc4d406e4a3c94df3399b2a6471
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/BrainParametersProto.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/brain_parameters_proto.proto
+//     source: mlagents/envs/communicator_objects/brain_parameters_proto.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/brain_parameters_proto.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/brain_parameters_proto.proto</summary>
-    /// <summary>File descriptor for communicator_objects/brain_parameters_proto.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/brain_parameters_proto.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "CjFjb21tdW5pY2F0b3Jfb2JqZWN0cy9icmFpbl9wYXJhbWV0ZXJzX3Byb3Rv",
-            "LnByb3RvEhRjb21tdW5pY2F0b3Jfb2JqZWN0cxorY29tbXVuaWNhdG9yX29i",
-            "amVjdHMvcmVzb2x1dGlvbl9wcm90by5wcm90bxorY29tbXVuaWNhdG9yX29i",
-            "amVjdHMvYnJhaW5fdHlwZV9wcm90by5wcm90bxorY29tbXVuaWNhdG9yX29i",
-            "amVjdHMvc3BhY2VfdHlwZV9wcm90by5wcm90byL5AgoUQnJhaW5QYXJhbWV0",
-            "ZXJzUHJvdG8SHwoXdmVjdG9yX29ic2VydmF0aW9uX3NpemUYASABKAUSJwof",
-            "bnVtX3N0YWNrZWRfdmVjdG9yX29ic2VydmF0aW9ucxgCIAEoBRIaChJ2ZWN0",
-            "b3JfYWN0aW9uX3NpemUYAyADKAUSQQoSY2FtZXJhX3Jlc29sdXRpb25zGAQg",
-            "AygLMiUuY29tbXVuaWNhdG9yX29iamVjdHMuUmVzb2x1dGlvblByb3RvEiIK",
-            "GnZlY3Rvcl9hY3Rpb25fZGVzY3JpcHRpb25zGAUgAygJEkYKGHZlY3Rvcl9h",
-            "Y3Rpb25fc3BhY2VfdHlwZRgGIAEoDjIkLmNvbW11bmljYXRvcl9vYmplY3Rz",
-            "LlNwYWNlVHlwZVByb3RvEhIKCmJyYWluX25hbWUYByABKAkSOAoKYnJhaW5f",
-            "dHlwZRgIIAEoDjIkLmNvbW11bmljYXRvcl9vYmplY3RzLkJyYWluVHlwZVBy",
-            "b3RvQh+qAhxNTEFnZW50cy5Db21tdW5pY2F0b3JPYmplY3RzYgZwcm90bzM="));
+            "Cj9tbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL2JyYWluX3Bh",
+            "cmFtZXRlcnNfcHJvdG8ucHJvdG8SFGNvbW11bmljYXRvcl9vYmplY3RzGjlt",
+            "bGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3Jlc29sdXRpb25f",
+            "cHJvdG8ucHJvdG8aOW1sYWdlbnRzL2VudnMvY29tbXVuaWNhdG9yX29iamVj",
+            "dHMvYnJhaW5fdHlwZV9wcm90by5wcm90bxo5bWxhZ2VudHMvZW52cy9jb21t",
+            "dW5pY2F0b3Jfb2JqZWN0cy9zcGFjZV90eXBlX3Byb3RvLnByb3RvIvkCChRC",
+            "cmFpblBhcmFtZXRlcnNQcm90bxIfChd2ZWN0b3Jfb2JzZXJ2YXRpb25fc2l6",
+            "ZRgBIAEoBRInCh9udW1fc3RhY2tlZF92ZWN0b3Jfb2JzZXJ2YXRpb25zGAIg",
+            "ASgFEhoKEnZlY3Rvcl9hY3Rpb25fc2l6ZRgDIAMoBRJBChJjYW1lcmFfcmVz",
+            "b2x1dGlvbnMYBCADKAsyJS5jb21tdW5pY2F0b3Jfb2JqZWN0cy5SZXNvbHV0",
+            "aW9uUHJvdG8SIgoadmVjdG9yX2FjdGlvbl9kZXNjcmlwdGlvbnMYBSADKAkS",
+            "RgoYdmVjdG9yX2FjdGlvbl9zcGFjZV90eXBlGAYgASgOMiQuY29tbXVuaWNh",
+            "dG9yX29iamVjdHMuU3BhY2VUeXBlUHJvdG8SEgoKYnJhaW5fbmFtZRgHIAEo",
+            "CRI4CgpicmFpbl90eXBlGAggASgOMiQuY29tbXVuaWNhdG9yX29iamVjdHMu",
+            "QnJhaW5UeXBlUHJvdG9CH6oCHE1MQWdlbnRzLkNvbW11bmljYXRvck9iamVj",
+            "dHNiBnByb3RvMw=="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.ResolutionProtoReflection.Descriptor, global::MLAgents.CommunicatorObjects.BrainTypeProtoReflection.Descriptor, global::MLAgents.CommunicatorObjects.SpaceTypeProtoReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/AgentInfoProto.cs.meta

 fileFormatVersion: 2
-guid: 9a2cd47d5b7a84d45b66748c405edf5a
+guid: 791522439b8324bff85f84309db90ecc
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/AgentInfoProto.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/agent_info_proto.proto
+//     source: mlagents/envs/communicator_objects/agent_info_proto.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/agent_info_proto.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/agent_info_proto.proto</summary>
-    /// <summary>File descriptor for communicator_objects/agent_info_proto.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/agent_info_proto.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Citjb21tdW5pY2F0b3Jfb2JqZWN0cy9hZ2VudF9pbmZvX3Byb3RvLnByb3Rv",
-            "EhRjb21tdW5pY2F0b3Jfb2JqZWN0cyKSAgoOQWdlbnRJbmZvUHJvdG8SIgoa",
-            "c3RhY2tlZF92ZWN0b3Jfb2JzZXJ2YXRpb24YASADKAISGwoTdmlzdWFsX29i",
-            "c2VydmF0aW9ucxgCIAMoDBIYChB0ZXh0X29ic2VydmF0aW9uGAMgASgJEh0K",
-            "FXN0b3JlZF92ZWN0b3JfYWN0aW9ucxgEIAMoAhIbChNzdG9yZWRfdGV4dF9h",
-            "Y3Rpb25zGAUgASgJEhAKCG1lbW9yaWVzGAYgAygCEg4KBnJld2FyZBgHIAEo",
-            "AhIMCgRkb25lGAggASgIEhgKEG1heF9zdGVwX3JlYWNoZWQYCSABKAgSCgoC",
-            "aWQYCiABKAUSEwoLYWN0aW9uX21hc2sYCyADKAhCH6oCHE1MQWdlbnRzLkNv",
-            "bW11bmljYXRvck9iamVjdHNiBnByb3RvMw=="));
+            "CjltbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL2FnZW50X2lu",
+            "Zm9fcHJvdG8ucHJvdG8SFGNvbW11bmljYXRvcl9vYmplY3RzIpICCg5BZ2Vu",
+            "dEluZm9Qcm90bxIiChpzdGFja2VkX3ZlY3Rvcl9vYnNlcnZhdGlvbhgBIAMo",
+            "AhIbChN2aXN1YWxfb2JzZXJ2YXRpb25zGAIgAygMEhgKEHRleHRfb2JzZXJ2",
+            "YXRpb24YAyABKAkSHQoVc3RvcmVkX3ZlY3Rvcl9hY3Rpb25zGAQgAygCEhsK",
+            "E3N0b3JlZF90ZXh0X2FjdGlvbnMYBSABKAkSEAoIbWVtb3JpZXMYBiADKAIS",
+            "DgoGcmV3YXJkGAcgASgCEgwKBGRvbmUYCCABKAgSGAoQbWF4X3N0ZXBfcmVh",
+            "Y2hlZBgJIAEoCBIKCgJpZBgKIAEoBRITCgthY3Rpb25fbWFzaxgLIAMoCEIf",
+            "qgIcTUxBZ2VudHMuQ29tbXVuaWNhdG9yT2JqZWN0c2IGcHJvdG8z"));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/AgentActionProto.cs.meta

 fileFormatVersion: 2
-guid: 93eec67e32dc3484ca9b8e3ea98909c7
+guid: 4482f127d4a874cf8a11da2b2cc27dc9
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MLAgentsSDK/Assets/ML-Agents/Scripts/CommunicatorObjects/AgentActionProto.cs

 // <auto-generated>
 //     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: communicator_objects/agent_action_proto.proto
+//     source: mlagents/envs/communicator_objects/agent_action_proto.proto
 // </auto-generated>
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code
 using scg = global::System.Collections.Generic;
 namespace MLAgents.CommunicatorObjects {
 
-  /// <summary>Holder for reflection information generated from communicator_objects/agent_action_proto.proto</summary>
+  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/agent_action_proto.proto</summary>
-    /// <summary>File descriptor for communicator_objects/agent_action_proto.proto</summary>
+    /// <summary>File descriptor for mlagents/envs/communicator_objects/agent_action_proto.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
-            "Ci1jb21tdW5pY2F0b3Jfb2JqZWN0cy9hZ2VudF9hY3Rpb25fcHJvdG8ucHJv",
-            "dG8SFGNvbW11bmljYXRvcl9vYmplY3RzImEKEEFnZW50QWN0aW9uUHJvdG8S",
-            "FgoOdmVjdG9yX2FjdGlvbnMYASADKAISFAoMdGV4dF9hY3Rpb25zGAIgASgJ",
-            "EhAKCG1lbW9yaWVzGAMgAygCEg0KBXZhbHVlGAQgASgCQh+qAhxNTEFnZW50",
-            "cy5Db21tdW5pY2F0b3JPYmplY3RzYgZwcm90bzM="));
+            "CjttbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL2FnZW50X2Fj",
+            "dGlvbl9wcm90by5wcm90bxIUY29tbXVuaWNhdG9yX29iamVjdHMiYQoQQWdl",
+            "bnRBY3Rpb25Qcm90bxIWCg52ZWN0b3JfYWN0aW9ucxgBIAMoAhIUCgx0ZXh0",
+            "X2FjdGlvbnMYAiABKAkSEAoIbWVtb3JpZXMYAyADKAISDQoFdmFsdWUYBCAB",
+            "KAJCH6oCHE1MQWdlbnRzLkNvbW11bmljYXRvck9iamVjdHNiBnByb3RvMw=="));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {

MLAgentsSDK/Assets/ML-Agents/Scripts/Academy.cs

                 var pythonParameters = brainBatcher.SendAcademyParameters(academyParameters);
                 Random.InitState(pythonParameters.Seed);
                 Application.logMessageReceived += HandleLog;
-                logPath = Path.GetFullPath(".") + "/unity-environment.log";
+                logPath = Path.GetFullPath(".") + "/MLAgentsSDK.log";
                 logWriter = new StreamWriter(logPath, false);
                 logWriter.WriteLine(System.DateTime.Now.ToString());
                 logWriter.WriteLine(" ");

ml-agents/tests/trainers/test_curriculum.py

 import json
 from unittest.mock import patch, mock_open
 
-from unitytrainers.exception import CurriculumError
-from unitytrainers import Curriculum
+from mlagents.trainers.exception import CurriculumError
+from mlagents.trainers import Curriculum
 
 
 dummy_curriculum_json_str = '''

ml-agents/tests/trainers/test_trainer_controller.py

 import pytest
 import tensorflow as tf
 
-from unitytrainers.trainer_controller import TrainerController
-from unitytrainers.buffer import Buffer
-from unitytrainers.ppo.trainer import PPOTrainer
-from unitytrainers.bc.trainer import BehavioralCloningTrainer
-from unitytrainers.curriculum import Curriculum
-from unitytrainers.exception import CurriculumError
-from unityagents.exception import UnityEnvironmentException
-from .mock_communicator import MockCommunicator
+from mlagents.trainers.trainer_controller import TrainerController
+from mlagents.trainers.buffer import Buffer
+from mlagents.trainers.ppo.trainer import PPOTrainer
+from mlagents.trainers.bc.trainer import BehavioralCloningTrainer
+from mlagents.trainers.curriculum import Curriculum
+from mlagents.trainers.exception import CurriculumError
+from mlagents.envs.exception import UnityEnvironmentException
+from tests.mock_communicator import MockCommunicator
 
 
 @pytest.fixture
         ''')
 
 
-@mock.patch('unityagents.UnityEnvironment.executable_launcher')
-@mock.patch('unityagents.UnityEnvironment.get_communicator')
+@mock.patch('mlagents.envs.UnityEnvironment.executable_launcher')
+@mock.patch('mlagents.envs.UnityEnvironment.get_communicator')
-                           1, 1, 1, '', "tests/test_unitytrainers.py", False)
+                           1, 1, 1, '', "tests/test_mlagents.trainers.py", False)
-@mock.patch('unityagents.UnityEnvironment.executable_launcher')
-@mock.patch('unityagents.UnityEnvironment.get_communicator')
+@mock.patch('mlagents.envs.UnityEnvironment.executable_launcher')
+@mock.patch('mlagents.envs.UnityEnvironment.get_communicator')
-    open_name = 'unitytrainers.trainer_controller' + '.open'
+    open_name = 'mlagents.trainers.trainer_controller' + '.open'
     with mock.patch('yaml.load') as mock_load:
         with mock.patch(open_name, create=True) as _:
             mock_load.return_value = dummy_config
             assert(config['default']['trainer'] == "ppo")
 
 
-@mock.patch('unityagents.UnityEnvironment.executable_launcher')
-@mock.patch('unityagents.UnityEnvironment.get_communicator')
+@mock.patch('mlagents.envs.UnityEnvironment.executable_launcher')
+@mock.patch('mlagents.envs.UnityEnvironment.get_communicator')
-    open_name = 'unitytrainers.trainer_controller' + '.open'
+    open_name = 'mlagents.trainers.trainer_controller' + '.open'
-                                   1, 1, '', "tests/test_unitytrainers.py",
+                                   1, 1, '', "tests/test_mlagents.trainers.py",
                                    False)
 
             # Test for PPO trainer

ml-agents/tests/mock_communicator.py

-
-from unityagents.communicator import Communicator
-from communicator_objects import UnityMessage, UnityOutput, UnityInput,\
+from mlagents.envs.communicator import Communicator
+from mlagents.envs.communicator_objects import UnityMessage, UnityOutput, UnityInput,\
     ResolutionProto, BrainParametersProto, UnityRLInitializationOutput,\
     AgentInfoProto, UnityRLOutput
 

ml-agents/mlagents/envs/communicator_objects/unity_to_external_pb2_grpc.py

 # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
 import grpc
 
-from communicator_objects import unity_message_pb2 as communicator__objects_dot_unity__message__pb2
+from mlagents.envs.communicator_objects import unity_message_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_unity__message__pb2
 
 
 class UnityToExternalStub(object):
     """
     self.Exchange = channel.unary_unary(
         '/communicator_objects.UnityToExternal/Exchange',
-        request_serializer=communicator__objects_dot_unity__message__pb2.UnityMessage.SerializeToString,
-        response_deserializer=communicator__objects_dot_unity__message__pb2.UnityMessage.FromString,
+        request_serializer=mlagents_dot_envs_dot_communicator__objects_dot_unity__message__pb2.UnityMessage.SerializeToString,
+        response_deserializer=mlagents_dot_envs_dot_communicator__objects_dot_unity__message__pb2.UnityMessage.FromString,
         )
 
 
   rpc_method_handlers = {
       'Exchange': grpc.unary_unary_rpc_method_handler(
           servicer.Exchange,
-          request_deserializer=communicator__objects_dot_unity__message__pb2.UnityMessage.FromString,
-          response_serializer=communicator__objects_dot_unity__message__pb2.UnityMessage.SerializeToString,
+          request_deserializer=mlagents_dot_envs_dot_communicator__objects_dot_unity__message__pb2.UnityMessage.FromString,
+          response_serializer=mlagents_dot_envs_dot_communicator__objects_dot_unity__message__pb2.UnityMessage.SerializeToString,
       ),
   }
   generic_handler = grpc.method_handlers_generic_handler(

ml-agents/mlagents/envs/communicator_objects/unity_to_external_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/unity_to_external.proto
+# source: mlagents/envs/communicator_objects/unity_to_external.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 _sym_db = _symbol_database.Default()
 
 
-from communicator_objects import unity_message_pb2 as communicator__objects_dot_unity__message__pb2
+from mlagents.envs.communicator_objects import unity_message_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_unity__message__pb2
-  name='communicator_objects/unity_to_external.proto',
+  name='mlagents/envs/communicator_objects/unity_to_external.proto',
-  serialized_pb=_b('\n,communicator_objects/unity_to_external.proto\x12\x14\x63ommunicator_objects\x1a(communicator_objects/unity_message.proto2g\n\x0fUnityToExternal\x12T\n\x08\x45xchange\x12\".communicator_objects.UnityMessage\x1a\".communicator_objects.UnityMessage\"\x00\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_pb=_b('\n:mlagents/envs/communicator_objects/unity_to_external.proto\x12\x14\x63ommunicator_objects\x1a\x36mlagents/envs/communicator_objects/unity_message.proto2g\n\x0fUnityToExternal\x12T\n\x08\x45xchange\x12\".communicator_objects.UnityMessage\x1a\".communicator_objects.UnityMessage\"\x00\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[communicator__objects_dot_unity__message__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_unity__message__pb2.DESCRIPTOR,])
 
 
 
   file=DESCRIPTOR,
   index=0,
   options=None,
-  serialized_start=112,
-  serialized_end=215,
+  serialized_start=140,
+  serialized_end=243,
   methods=[
   _descriptor.MethodDescriptor(
     name='Exchange',
-    input_type=communicator__objects_dot_unity__message__pb2._UNITYMESSAGE,
-    output_type=communicator__objects_dot_unity__message__pb2._UNITYMESSAGE,
+    input_type=mlagents_dot_envs_dot_communicator__objects_dot_unity__message__pb2._UNITYMESSAGE,
+    output_type=mlagents_dot_envs_dot_communicator__objects_dot_unity__message__pb2._UNITYMESSAGE,
     options=None,
   ),
 ])

ml-agents/mlagents/envs/communicator_objects/unity_rl_output_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/unity_rl_output.proto
+# source: mlagents/envs/communicator_objects/unity_rl_output.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
-from communicator_objects import agent_info_proto_pb2 as communicator__objects_dot_agent__info__proto__pb2
+from mlagents.envs.communicator_objects import agent_info_proto_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_agent__info__proto__pb2
-  name='communicator_objects/unity_rl_output.proto',
+  name='mlagents/envs/communicator_objects/unity_rl_output.proto',
-  serialized_pb=_b('\n*communicator_objects/unity_rl_output.proto\x12\x14\x63ommunicator_objects\x1a+communicator_objects/agent_info_proto.proto\"\xa3\x02\n\rUnityRLOutput\x12\x13\n\x0bglobal_done\x18\x01 \x01(\x08\x12G\n\nagentInfos\x18\x02 \x03(\x0b\x32\x33.communicator_objects.UnityRLOutput.AgentInfosEntry\x1aI\n\x12ListAgentInfoProto\x12\x33\n\x05value\x18\x01 \x03(\x0b\x32$.communicator_objects.AgentInfoProto\x1ai\n\x0f\x41gentInfosEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x45\n\x05value\x18\x02 \x01(\x0b\x32\x36.communicator_objects.UnityRLOutput.ListAgentInfoProto:\x02\x38\x01\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n8mlagents/envs/communicator_objects/unity_rl_output.proto\x12\x14\x63ommunicator_objects\x1a\x39mlagents/envs/communicator_objects/agent_info_proto.proto\"\xa3\x02\n\rUnityRLOutput\x12\x13\n\x0bglobal_done\x18\x01 \x01(\x08\x12G\n\nagentInfos\x18\x02 \x03(\x0b\x32\x33.communicator_objects.UnityRLOutput.AgentInfosEntry\x1aI\n\x12ListAgentInfoProto\x12\x33\n\x05value\x18\x01 \x03(\x0b\x32$.communicator_objects.AgentInfoProto\x1ai\n\x0f\x41gentInfosEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x45\n\x05value\x18\x02 \x01(\x0b\x32\x36.communicator_objects.UnityRLOutput.ListAgentInfoProto:\x02\x38\x01\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[communicator__objects_dot_agent__info__proto__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_agent__info__proto__pb2.DESCRIPTOR,])
 
 
 
       has_default_value=False, default_value=[],
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=225,
-  serialized_end=298,
+  serialized_start=253,
+  serialized_end=326,
 )
 
 _UNITYRLOUTPUT_AGENTINFOSENTRY = _descriptor.Descriptor(
       has_default_value=False, default_value=_b("").decode('utf-8'),
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='value', full_name='communicator_objects.UnityRLOutput.AgentInfosEntry.value', index=1,
       number=2, type=11, cpp_type=10, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=_descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001')),
+  serialized_options=_b('8\001'),
-  serialized_start=300,
-  serialized_end=405,
+  serialized_start=328,
+  serialized_end=433,
 )
 
 _UNITYRLOUTPUT = _descriptor.Descriptor(
       has_default_value=False, default_value=False,
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='agentInfos', full_name='communicator_objects.UnityRLOutput.agentInfos', index=1,
       number=2, type=11, cpp_type=10, label=3,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=114,
-  serialized_end=405,
+  serialized_start=142,
+  serialized_end=433,
-_UNITYRLOUTPUT_LISTAGENTINFOPROTO.fields_by_name['value'].message_type = communicator__objects_dot_agent__info__proto__pb2._AGENTINFOPROTO
+_UNITYRLOUTPUT_LISTAGENTINFOPROTO.fields_by_name['value'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_agent__info__proto__pb2._AGENTINFOPROTO
 _UNITYRLOUTPUT_LISTAGENTINFOPROTO.containing_type = _UNITYRLOUTPUT
 _UNITYRLOUTPUT_AGENTINFOSENTRY.fields_by_name['value'].message_type = _UNITYRLOUTPUT_LISTAGENTINFOPROTO
 _UNITYRLOUTPUT_AGENTINFOSENTRY.containing_type = _UNITYRLOUTPUT
 
   ListAgentInfoProto = _reflection.GeneratedProtocolMessageType('ListAgentInfoProto', (_message.Message,), dict(
     DESCRIPTOR = _UNITYRLOUTPUT_LISTAGENTINFOPROTO,
-    __module__ = 'communicator_objects.unity_rl_output_pb2'
+    __module__ = 'mlagents.envs.communicator_objects.unity_rl_output_pb2'
     # @@protoc_insertion_point(class_scope:communicator_objects.UnityRLOutput.ListAgentInfoProto)
     ))
   ,
-    __module__ = 'communicator_objects.unity_rl_output_pb2'
+    __module__ = 'mlagents.envs.communicator_objects.unity_rl_output_pb2'
-  __module__ = 'communicator_objects.unity_rl_output_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.unity_rl_output_pb2'
   # @@protoc_insertion_point(class_scope:communicator_objects.UnityRLOutput)
   ))
 _sym_db.RegisterMessage(UnityRLOutput)
 
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
-_UNITYRLOUTPUT_AGENTINFOSENTRY.has_options = True
-_UNITYRLOUTPUT_AGENTINFOSENTRY._options = _descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001'))
+DESCRIPTOR._options = None
+_UNITYRLOUTPUT_AGENTINFOSENTRY._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/unity_rl_input_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/unity_rl_input.proto
+# source: mlagents/envs/communicator_objects/unity_rl_input.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
-from communicator_objects import agent_action_proto_pb2 as communicator__objects_dot_agent__action__proto__pb2
-from communicator_objects import environment_parameters_proto_pb2 as communicator__objects_dot_environment__parameters__proto__pb2
-from communicator_objects import command_proto_pb2 as communicator__objects_dot_command__proto__pb2
+from mlagents.envs.communicator_objects import agent_action_proto_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_agent__action__proto__pb2
+from mlagents.envs.communicator_objects import environment_parameters_proto_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__proto__pb2
+from mlagents.envs.communicator_objects import command_proto_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_command__proto__pb2
-  name='communicator_objects/unity_rl_input.proto',
+  name='mlagents/envs/communicator_objects/unity_rl_input.proto',
-  serialized_pb=_b('\n)communicator_objects/unity_rl_input.proto\x12\x14\x63ommunicator_objects\x1a-communicator_objects/agent_action_proto.proto\x1a\x37\x63ommunicator_objects/environment_parameters_proto.proto\x1a(communicator_objects/command_proto.proto\"\xb4\x03\n\x0cUnityRLInput\x12K\n\ragent_actions\x18\x01 \x03(\x0b\x32\x34.communicator_objects.UnityRLInput.AgentActionsEntry\x12P\n\x16\x65nvironment_parameters\x18\x02 \x01(\x0b\x32\x30.communicator_objects.EnvironmentParametersProto\x12\x13\n\x0bis_training\x18\x03 \x01(\x08\x12\x33\n\x07\x63ommand\x18\x04 \x01(\x0e\x32\".communicator_objects.CommandProto\x1aM\n\x14ListAgentActionProto\x12\x35\n\x05value\x18\x01 \x03(\x0b\x32&.communicator_objects.AgentActionProto\x1al\n\x11\x41gentActionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x46\n\x05value\x18\x02 \x01(\x0b\x32\x37.communicator_objects.UnityRLInput.ListAgentActionProto:\x02\x38\x01\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n7mlagents/envs/communicator_objects/unity_rl_input.proto\x12\x14\x63ommunicator_objects\x1a;mlagents/envs/communicator_objects/agent_action_proto.proto\x1a\x45mlagents/envs/communicator_objects/environment_parameters_proto.proto\x1a\x36mlagents/envs/communicator_objects/command_proto.proto\"\xb4\x03\n\x0cUnityRLInput\x12K\n\ragent_actions\x18\x01 \x03(\x0b\x32\x34.communicator_objects.UnityRLInput.AgentActionsEntry\x12P\n\x16\x65nvironment_parameters\x18\x02 \x01(\x0b\x32\x30.communicator_objects.EnvironmentParametersProto\x12\x13\n\x0bis_training\x18\x03 \x01(\x08\x12\x33\n\x07\x63ommand\x18\x04 \x01(\x0e\x32\".communicator_objects.CommandProto\x1aM\n\x14ListAgentActionProto\x12\x35\n\x05value\x18\x01 \x03(\x0b\x32&.communicator_objects.AgentActionProto\x1al\n\x11\x41gentActionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x46\n\x05value\x18\x02 \x01(\x0b\x32\x37.communicator_objects.UnityRLInput.ListAgentActionProto:\x02\x38\x01\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[communicator__objects_dot_agent__action__proto__pb2.DESCRIPTOR,communicator__objects_dot_environment__parameters__proto__pb2.DESCRIPTOR,communicator__objects_dot_command__proto__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_agent__action__proto__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__proto__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_command__proto__pb2.DESCRIPTOR,])
 
 
 
       has_default_value=False, default_value=[],
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=463,
-  serialized_end=540,
+  serialized_start=519,
+  serialized_end=596,
 )
 
 _UNITYRLINPUT_AGENTACTIONSENTRY = _descriptor.Descriptor(
       has_default_value=False, default_value=_b("").decode('utf-8'),
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='value', full_name='communicator_objects.UnityRLInput.AgentActionsEntry.value', index=1,
       number=2, type=11, cpp_type=10, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=_descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001')),
+  serialized_options=_b('8\001'),
-  serialized_start=542,
-  serialized_end=650,
+  serialized_start=598,
+  serialized_end=706,
 )
 
 _UNITYRLINPUT = _descriptor.Descriptor(
       has_default_value=False, default_value=[],
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='environment_parameters', full_name='communicator_objects.UnityRLInput.environment_parameters', index=1,
       number=2, type=11, cpp_type=10, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='is_training', full_name='communicator_objects.UnityRLInput.is_training', index=2,
       number=3, type=8, cpp_type=7, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='command', full_name='communicator_objects.UnityRLInput.command', index=3,
       number=4, type=14, cpp_type=8, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=214,
-  serialized_end=650,
+  serialized_start=270,
+  serialized_end=706,
-_UNITYRLINPUT_LISTAGENTACTIONPROTO.fields_by_name['value'].message_type = communicator__objects_dot_agent__action__proto__pb2._AGENTACTIONPROTO
+_UNITYRLINPUT_LISTAGENTACTIONPROTO.fields_by_name['value'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_agent__action__proto__pb2._AGENTACTIONPROTO
-_UNITYRLINPUT.fields_by_name['environment_parameters'].message_type = communicator__objects_dot_environment__parameters__proto__pb2._ENVIRONMENTPARAMETERSPROTO
-_UNITYRLINPUT.fields_by_name['command'].enum_type = communicator__objects_dot_command__proto__pb2._COMMANDPROTO
+_UNITYRLINPUT.fields_by_name['environment_parameters'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__proto__pb2._ENVIRONMENTPARAMETERSPROTO
+_UNITYRLINPUT.fields_by_name['command'].enum_type = mlagents_dot_envs_dot_communicator__objects_dot_command__proto__pb2._COMMANDPROTO
 DESCRIPTOR.message_types_by_name['UnityRLInput'] = _UNITYRLINPUT
 _sym_db.RegisterFileDescriptor(DESCRIPTOR)
 
     DESCRIPTOR = _UNITYRLINPUT_LISTAGENTACTIONPROTO,
-    __module__ = 'communicator_objects.unity_rl_input_pb2'
+    __module__ = 'mlagents.envs.communicator_objects.unity_rl_input_pb2'
     # @@protoc_insertion_point(class_scope:communicator_objects.UnityRLInput.ListAgentActionProto)
     ))
   ,
-    __module__ = 'communicator_objects.unity_rl_input_pb2'
+    __module__ = 'mlagents.envs.communicator_objects.unity_rl_input_pb2'
-  __module__ = 'communicator_objects.unity_rl_input_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.unity_rl_input_pb2'
   # @@protoc_insertion_point(class_scope:communicator_objects.UnityRLInput)
   ))
 _sym_db.RegisterMessage(UnityRLInput)
 
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
-_UNITYRLINPUT_AGENTACTIONSENTRY.has_options = True
-_UNITYRLINPUT_AGENTACTIONSENTRY._options = _descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001'))
+DESCRIPTOR._options = None
+_UNITYRLINPUT_AGENTACTIONSENTRY._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/unity_rl_initialization_output_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/unity_rl_initialization_output.proto
+# source: mlagents/envs/communicator_objects/unity_rl_initialization_output.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
-from communicator_objects import brain_parameters_proto_pb2 as communicator__objects_dot_brain__parameters__proto__pb2
-from communicator_objects import environment_parameters_proto_pb2 as communicator__objects_dot_environment__parameters__proto__pb2
+from mlagents.envs.communicator_objects import brain_parameters_proto_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_brain__parameters__proto__pb2
+from mlagents.envs.communicator_objects import environment_parameters_proto_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__proto__pb2
-  name='communicator_objects/unity_rl_initialization_output.proto',
+  name='mlagents/envs/communicator_objects/unity_rl_initialization_output.proto',
-  serialized_pb=_b('\n9communicator_objects/unity_rl_initialization_output.proto\x12\x14\x63ommunicator_objects\x1a\x31\x63ommunicator_objects/brain_parameters_proto.proto\x1a\x37\x63ommunicator_objects/environment_parameters_proto.proto\"\xe6\x01\n\x1bUnityRLInitializationOutput\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0f\n\x07version\x18\x02 \x01(\t\x12\x10\n\x08log_path\x18\x03 \x01(\t\x12\x44\n\x10\x62rain_parameters\x18\x05 \x03(\x0b\x32*.communicator_objects.BrainParametersProto\x12P\n\x16\x65nvironment_parameters\x18\x06 \x01(\x0b\x32\x30.communicator_objects.EnvironmentParametersProtoB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\nGmlagents/envs/communicator_objects/unity_rl_initialization_output.proto\x12\x14\x63ommunicator_objects\x1a?mlagents/envs/communicator_objects/brain_parameters_proto.proto\x1a\x45mlagents/envs/communicator_objects/environment_parameters_proto.proto\"\xe6\x01\n\x1bUnityRLInitializationOutput\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0f\n\x07version\x18\x02 \x01(\t\x12\x10\n\x08log_path\x18\x03 \x01(\t\x12\x44\n\x10\x62rain_parameters\x18\x05 \x03(\x0b\x32*.communicator_objects.BrainParametersProto\x12P\n\x16\x65nvironment_parameters\x18\x06 \x01(\x0b\x32\x30.communicator_objects.EnvironmentParametersProtoB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[communicator__objects_dot_brain__parameters__proto__pb2.DESCRIPTOR,communicator__objects_dot_environment__parameters__proto__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_brain__parameters__proto__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__proto__pb2.DESCRIPTOR,])
 
 
 
       has_default_value=False, default_value=_b("").decode('utf-8'),
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='version', full_name='communicator_objects.UnityRLInitializationOutput.version', index=1,
       number=2, type=9, cpp_type=9, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='log_path', full_name='communicator_objects.UnityRLInitializationOutput.log_path', index=2,
       number=3, type=9, cpp_type=9, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='brain_parameters', full_name='communicator_objects.UnityRLInitializationOutput.brain_parameters', index=3,
       number=5, type=11, cpp_type=10, label=3,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='environment_parameters', full_name='communicator_objects.UnityRLInitializationOutput.environment_parameters', index=4,
       number=6, type=11, cpp_type=10, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=192,
-  serialized_end=422,
+  serialized_start=234,
+  serialized_end=464,
-_UNITYRLINITIALIZATIONOUTPUT.fields_by_name['brain_parameters'].message_type = communicator__objects_dot_brain__parameters__proto__pb2._BRAINPARAMETERSPROTO
-_UNITYRLINITIALIZATIONOUTPUT.fields_by_name['environment_parameters'].message_type = communicator__objects_dot_environment__parameters__proto__pb2._ENVIRONMENTPARAMETERSPROTO
+_UNITYRLINITIALIZATIONOUTPUT.fields_by_name['brain_parameters'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_brain__parameters__proto__pb2._BRAINPARAMETERSPROTO
+_UNITYRLINITIALIZATIONOUTPUT.fields_by_name['environment_parameters'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__proto__pb2._ENVIRONMENTPARAMETERSPROTO
-  __module__ = 'communicator_objects.unity_rl_initialization_output_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.unity_rl_initialization_output_pb2'
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/unity_rl_initialization_input_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/unity_rl_initialization_input.proto
+# source: mlagents/envs/communicator_objects/unity_rl_initialization_input.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
 
 DESCRIPTOR = _descriptor.FileDescriptor(
-  name='communicator_objects/unity_rl_initialization_input.proto',
+  name='mlagents/envs/communicator_objects/unity_rl_initialization_input.proto',
-  serialized_pb=_b('\n8communicator_objects/unity_rl_initialization_input.proto\x12\x14\x63ommunicator_objects\"*\n\x1aUnityRLInitializationInput\x12\x0c\n\x04seed\x18\x01 \x01(\x05\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\nFmlagents/envs/communicator_objects/unity_rl_initialization_input.proto\x12\x14\x63ommunicator_objects\"*\n\x1aUnityRLInitializationInput\x12\x0c\n\x04seed\x18\x01 \x01(\x05\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
 )
 
 
       has_default_value=False, default_value=0,
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=82,
-  serialized_end=124,
+  serialized_start=96,
+  serialized_end=138,
 )
 
 DESCRIPTOR.message_types_by_name['UnityRLInitializationInput'] = _UNITYRLINITIALIZATIONINPUT
   DESCRIPTOR = _UNITYRLINITIALIZATIONINPUT,
-  __module__ = 'communicator_objects.unity_rl_initialization_input_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.unity_rl_initialization_input_pb2'
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/unity_output_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/unity_output.proto
+# source: mlagents/envs/communicator_objects/unity_output.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
-from communicator_objects import unity_rl_output_pb2 as communicator__objects_dot_unity__rl__output__pb2
-from communicator_objects import unity_rl_initialization_output_pb2 as communicator__objects_dot_unity__rl__initialization__output__pb2
+from mlagents.envs.communicator_objects import unity_rl_output_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__output__pb2
+from mlagents.envs.communicator_objects import unity_rl_initialization_output_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__initialization__output__pb2
-  name='communicator_objects/unity_output.proto',
+  name='mlagents/envs/communicator_objects/unity_output.proto',
-  serialized_pb=_b('\n\'communicator_objects/unity_output.proto\x12\x14\x63ommunicator_objects\x1a*communicator_objects/unity_rl_output.proto\x1a\x39\x63ommunicator_objects/unity_rl_initialization_output.proto\"\x9a\x01\n\x0bUnityOutput\x12\x36\n\trl_output\x18\x01 \x01(\x0b\x32#.communicator_objects.UnityRLOutput\x12S\n\x18rl_initialization_output\x18\x02 \x01(\x0b\x32\x31.communicator_objects.UnityRLInitializationOutputB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n5mlagents/envs/communicator_objects/unity_output.proto\x12\x14\x63ommunicator_objects\x1a\x38mlagents/envs/communicator_objects/unity_rl_output.proto\x1aGmlagents/envs/communicator_objects/unity_rl_initialization_output.proto\"\x9a\x01\n\x0bUnityOutput\x12\x36\n\trl_output\x18\x01 \x01(\x0b\x32#.communicator_objects.UnityRLOutput\x12S\n\x18rl_initialization_output\x18\x02 \x01(\x0b\x32\x31.communicator_objects.UnityRLInitializationOutputB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[communicator__objects_dot_unity__rl__output__pb2.DESCRIPTOR,communicator__objects_dot_unity__rl__initialization__output__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__output__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__initialization__output__pb2.DESCRIPTOR,])
 
 
 
       has_default_value=False, default_value=None,
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='rl_initialization_output', full_name='communicator_objects.UnityOutput.rl_initialization_output', index=1,
       number=2, type=11, cpp_type=10, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=169,
-  serialized_end=323,
+  serialized_start=211,
+  serialized_end=365,
-_UNITYOUTPUT.fields_by_name['rl_output'].message_type = communicator__objects_dot_unity__rl__output__pb2._UNITYRLOUTPUT
-_UNITYOUTPUT.fields_by_name['rl_initialization_output'].message_type = communicator__objects_dot_unity__rl__initialization__output__pb2._UNITYRLINITIALIZATIONOUTPUT
+_UNITYOUTPUT.fields_by_name['rl_output'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__output__pb2._UNITYRLOUTPUT
+_UNITYOUTPUT.fields_by_name['rl_initialization_output'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__initialization__output__pb2._UNITYRLINITIALIZATIONOUTPUT
-  __module__ = 'communicator_objects.unity_output_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.unity_output_pb2'
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/unity_message_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/unity_message.proto
+# source: mlagents/envs/communicator_objects/unity_message.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
-from communicator_objects import unity_output_pb2 as communicator__objects_dot_unity__output__pb2
-from communicator_objects import unity_input_pb2 as communicator__objects_dot_unity__input__pb2
-from communicator_objects import header_pb2 as communicator__objects_dot_header__pb2
+from mlagents.envs.communicator_objects import unity_output_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_unity__output__pb2
+from mlagents.envs.communicator_objects import unity_input_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_unity__input__pb2
+from mlagents.envs.communicator_objects import header_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_header__pb2
-  name='communicator_objects/unity_message.proto',
+  name='mlagents/envs/communicator_objects/unity_message.proto',
-  serialized_pb=_b('\n(communicator_objects/unity_message.proto\x12\x14\x63ommunicator_objects\x1a\'communicator_objects/unity_output.proto\x1a&communicator_objects/unity_input.proto\x1a!communicator_objects/header.proto\"\xac\x01\n\x0cUnityMessage\x12,\n\x06header\x18\x01 \x01(\x0b\x32\x1c.communicator_objects.Header\x12\x37\n\x0cunity_output\x18\x02 \x01(\x0b\x32!.communicator_objects.UnityOutput\x12\x35\n\x0bunity_input\x18\x03 \x01(\x0b\x32 .communicator_objects.UnityInputB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n6mlagents/envs/communicator_objects/unity_message.proto\x12\x14\x63ommunicator_objects\x1a\x35mlagents/envs/communicator_objects/unity_output.proto\x1a\x34mlagents/envs/communicator_objects/unity_input.proto\x1a/mlagents/envs/communicator_objects/header.proto\"\xac\x01\n\x0cUnityMessage\x12,\n\x06header\x18\x01 \x01(\x0b\x32\x1c.communicator_objects.Header\x12\x37\n\x0cunity_output\x18\x02 \x01(\x0b\x32!.communicator_objects.UnityOutput\x12\x35\n\x0bunity_input\x18\x03 \x01(\x0b\x32 .communicator_objects.UnityInputB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[communicator__objects_dot_unity__output__pb2.DESCRIPTOR,communicator__objects_dot_unity__input__pb2.DESCRIPTOR,communicator__objects_dot_header__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_unity__output__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_unity__input__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_header__pb2.DESCRIPTOR,])
 
 
 
       has_default_value=False, default_value=None,
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='unity_output', full_name='communicator_objects.UnityMessage.unity_output', index=1,
       number=2, type=11, cpp_type=10, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='unity_input', full_name='communicator_objects.UnityMessage.unity_input', index=2,
       number=3, type=11, cpp_type=10, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=183,
-  serialized_end=355,
+  serialized_start=239,
+  serialized_end=411,
-_UNITYMESSAGE.fields_by_name['header'].message_type = communicator__objects_dot_header__pb2._HEADER
-_UNITYMESSAGE.fields_by_name['unity_output'].message_type = communicator__objects_dot_unity__output__pb2._UNITYOUTPUT
-_UNITYMESSAGE.fields_by_name['unity_input'].message_type = communicator__objects_dot_unity__input__pb2._UNITYINPUT
+_UNITYMESSAGE.fields_by_name['header'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_header__pb2._HEADER
+_UNITYMESSAGE.fields_by_name['unity_output'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_unity__output__pb2._UNITYOUTPUT
+_UNITYMESSAGE.fields_by_name['unity_input'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_unity__input__pb2._UNITYINPUT
-  __module__ = 'communicator_objects.unity_message_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.unity_message_pb2'
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/unity_input_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/unity_input.proto
+# source: mlagents/envs/communicator_objects/unity_input.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
-from communicator_objects import unity_rl_input_pb2 as communicator__objects_dot_unity__rl__input__pb2
-from communicator_objects import unity_rl_initialization_input_pb2 as communicator__objects_dot_unity__rl__initialization__input__pb2
+from mlagents.envs.communicator_objects import unity_rl_input_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__input__pb2
+from mlagents.envs.communicator_objects import unity_rl_initialization_input_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__initialization__input__pb2
-  name='communicator_objects/unity_input.proto',
+  name='mlagents/envs/communicator_objects/unity_input.proto',
-  serialized_pb=_b('\n&communicator_objects/unity_input.proto\x12\x14\x63ommunicator_objects\x1a)communicator_objects/unity_rl_input.proto\x1a\x38\x63ommunicator_objects/unity_rl_initialization_input.proto\"\x95\x01\n\nUnityInput\x12\x34\n\x08rl_input\x18\x01 \x01(\x0b\x32\".communicator_objects.UnityRLInput\x12Q\n\x17rl_initialization_input\x18\x02 \x01(\x0b\x32\x30.communicator_objects.UnityRLInitializationInputB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n4mlagents/envs/communicator_objects/unity_input.proto\x12\x14\x63ommunicator_objects\x1a\x37mlagents/envs/communicator_objects/unity_rl_input.proto\x1a\x46mlagents/envs/communicator_objects/unity_rl_initialization_input.proto\"\x95\x01\n\nUnityInput\x12\x34\n\x08rl_input\x18\x01 \x01(\x0b\x32\".communicator_objects.UnityRLInput\x12Q\n\x17rl_initialization_input\x18\x02 \x01(\x0b\x32\x30.communicator_objects.UnityRLInitializationInputB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[communicator__objects_dot_unity__rl__input__pb2.DESCRIPTOR,communicator__objects_dot_unity__rl__initialization__input__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__input__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__initialization__input__pb2.DESCRIPTOR,])
 
 
 
       has_default_value=False, default_value=None,
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='rl_initialization_input', full_name='communicator_objects.UnityInput.rl_initialization_input', index=1,
       number=2, type=11, cpp_type=10, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=166,
-  serialized_end=315,
+  serialized_start=208,
+  serialized_end=357,
-_UNITYINPUT.fields_by_name['rl_input'].message_type = communicator__objects_dot_unity__rl__input__pb2._UNITYRLINPUT
-_UNITYINPUT.fields_by_name['rl_initialization_input'].message_type = communicator__objects_dot_unity__rl__initialization__input__pb2._UNITYRLINITIALIZATIONINPUT
+_UNITYINPUT.fields_by_name['rl_input'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__input__pb2._UNITYRLINPUT
+_UNITYINPUT.fields_by_name['rl_initialization_input'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_unity__rl__initialization__input__pb2._UNITYRLINITIALIZATIONINPUT
-  __module__ = 'communicator_objects.unity_input_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.unity_input_pb2'
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/space_type_proto_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/space_type_proto.proto
+# source: mlagents/envs/communicator_objects/space_type_proto.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import reflection as _reflection
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
-from communicator_objects import resolution_proto_pb2 as communicator__objects_dot_resolution__proto__pb2
+from mlagents.envs.communicator_objects import resolution_proto_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_resolution__proto__pb2
-  name='communicator_objects/space_type_proto.proto',
+  name='mlagents/envs/communicator_objects/space_type_proto.proto',
-  serialized_pb=_b('\n+communicator_objects/space_type_proto.proto\x12\x14\x63ommunicator_objects\x1a+communicator_objects/resolution_proto.proto*.\n\x0eSpaceTypeProto\x12\x0c\n\x08\x64iscrete\x10\x00\x12\x0e\n\ncontinuous\x10\x01\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n9mlagents/envs/communicator_objects/space_type_proto.proto\x12\x14\x63ommunicator_objects\x1a\x39mlagents/envs/communicator_objects/resolution_proto.proto*.\n\x0eSpaceTypeProto\x12\x0c\n\x08\x64iscrete\x10\x00\x12\x0e\n\ncontinuous\x10\x01\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[communicator__objects_dot_resolution__proto__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_resolution__proto__pb2.DESCRIPTOR,])
 
 _SPACETYPEPROTO = _descriptor.EnumDescriptor(
   name='SpaceTypeProto',
   values=[
     _descriptor.EnumValueDescriptor(
       name='discrete', index=0, number=0,
-      options=None,
+      serialized_options=None,
-      options=None,
+      serialized_options=None,
-  options=None,
-  serialized_start=114,
-  serialized_end=160,
+  serialized_options=None,
+  serialized_start=142,
+  serialized_end=188,
 )
 _sym_db.RegisterEnumDescriptor(_SPACETYPEPROTO)
 
 _sym_db.RegisterFileDescriptor(DESCRIPTOR)
 
 
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/resolution_proto_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/resolution_proto.proto
+# source: mlagents/envs/communicator_objects/resolution_proto.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
 
 DESCRIPTOR = _descriptor.FileDescriptor(
-  name='communicator_objects/resolution_proto.proto',
+  name='mlagents/envs/communicator_objects/resolution_proto.proto',
-  serialized_pb=_b('\n+communicator_objects/resolution_proto.proto\x12\x14\x63ommunicator_objects\"D\n\x0fResolutionProto\x12\r\n\x05width\x18\x01 \x01(\x05\x12\x0e\n\x06height\x18\x02 \x01(\x05\x12\x12\n\ngray_scale\x18\x03 \x01(\x08\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n9mlagents/envs/communicator_objects/resolution_proto.proto\x12\x14\x63ommunicator_objects\"D\n\x0fResolutionProto\x12\r\n\x05width\x18\x01 \x01(\x05\x12\x0e\n\x06height\x18\x02 \x01(\x05\x12\x12\n\ngray_scale\x18\x03 \x01(\x08\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
 )
 
 
       has_default_value=False, default_value=0,
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='height', full_name='communicator_objects.ResolutionProto.height', index=1,
       number=2, type=5, cpp_type=1, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='gray_scale', full_name='communicator_objects.ResolutionProto.gray_scale', index=2,
       number=3, type=8, cpp_type=7, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=69,
-  serialized_end=137,
+  serialized_start=83,
+  serialized_end=151,
 )
 
 DESCRIPTOR.message_types_by_name['ResolutionProto'] = _RESOLUTIONPROTO
   DESCRIPTOR = _RESOLUTIONPROTO,
-  __module__ = 'communicator_objects.resolution_proto_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.resolution_proto_pb2'
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/header_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/header.proto
+# source: mlagents/envs/communicator_objects/header.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
 
 DESCRIPTOR = _descriptor.FileDescriptor(
-  name='communicator_objects/header.proto',
+  name='mlagents/envs/communicator_objects/header.proto',
-  serialized_pb=_b('\n!communicator_objects/header.proto\x12\x14\x63ommunicator_objects\")\n\x06Header\x12\x0e\n\x06status\x18\x01 \x01(\x05\x12\x0f\n\x07message\x18\x02 \x01(\tB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n/mlagents/envs/communicator_objects/header.proto\x12\x14\x63ommunicator_objects\")\n\x06Header\x12\x0e\n\x06status\x18\x01 \x01(\x05\x12\x0f\n\x07message\x18\x02 \x01(\tB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
 )
 
 
       has_default_value=False, default_value=0,
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='message', full_name='communicator_objects.Header.message', index=1,
       number=2, type=9, cpp_type=9, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=59,
-  serialized_end=100,
+  serialized_start=73,
+  serialized_end=114,
 )
 
 DESCRIPTOR.message_types_by_name['Header'] = _HEADER
   DESCRIPTOR = _HEADER,
-  __module__ = 'communicator_objects.header_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.header_pb2'
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/environment_parameters_proto_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/environment_parameters_proto.proto
+# source: mlagents/envs/communicator_objects/environment_parameters_proto.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
 
 DESCRIPTOR = _descriptor.FileDescriptor(
-  name='communicator_objects/environment_parameters_proto.proto',
+  name='mlagents/envs/communicator_objects/environment_parameters_proto.proto',
-  serialized_pb=_b('\n7communicator_objects/environment_parameters_proto.proto\x12\x14\x63ommunicator_objects\"\xb5\x01\n\x1a\x45nvironmentParametersProto\x12_\n\x10\x66loat_parameters\x18\x01 \x03(\x0b\x32\x45.communicator_objects.EnvironmentParametersProto.FloatParametersEntry\x1a\x36\n\x14\x46loatParametersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x02:\x02\x38\x01\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\nEmlagents/envs/communicator_objects/environment_parameters_proto.proto\x12\x14\x63ommunicator_objects\"\xb5\x01\n\x1a\x45nvironmentParametersProto\x12_\n\x10\x66loat_parameters\x18\x01 \x03(\x0b\x32\x45.communicator_objects.EnvironmentParametersProto.FloatParametersEntry\x1a\x36\n\x14\x46loatParametersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x02:\x02\x38\x01\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
 )
 
 
       has_default_value=False, default_value=_b("").decode('utf-8'),
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='value', full_name='communicator_objects.EnvironmentParametersProto.FloatParametersEntry.value', index=1,
       number=2, type=2, cpp_type=6, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=_descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001')),
+  serialized_options=_b('8\001'),
-  serialized_start=209,
-  serialized_end=263,
+  serialized_start=223,
+  serialized_end=277,
 )
 
 _ENVIRONMENTPARAMETERSPROTO = _descriptor.Descriptor(
       has_default_value=False, default_value=[],
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=82,
-  serialized_end=263,
+  serialized_start=96,
+  serialized_end=277,
 )
 
 _ENVIRONMENTPARAMETERSPROTO_FLOATPARAMETERSENTRY.containing_type = _ENVIRONMENTPARAMETERSPROTO
 
   FloatParametersEntry = _reflection.GeneratedProtocolMessageType('FloatParametersEntry', (_message.Message,), dict(
     DESCRIPTOR = _ENVIRONMENTPARAMETERSPROTO_FLOATPARAMETERSENTRY,
-    __module__ = 'communicator_objects.environment_parameters_proto_pb2'
+    __module__ = 'mlagents.envs.communicator_objects.environment_parameters_proto_pb2'
-  __module__ = 'communicator_objects.environment_parameters_proto_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.environment_parameters_proto_pb2'
   # @@protoc_insertion_point(class_scope:communicator_objects.EnvironmentParametersProto)
   ))
 _sym_db.RegisterMessage(EnvironmentParametersProto)
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
-_ENVIRONMENTPARAMETERSPROTO_FLOATPARAMETERSENTRY.has_options = True
-_ENVIRONMENTPARAMETERSPROTO_FLOATPARAMETERSENTRY._options = _descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001'))
+DESCRIPTOR._options = None
+_ENVIRONMENTPARAMETERSPROTO_FLOATPARAMETERSENTRY._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/engine_configuration_proto_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/engine_configuration_proto.proto
+# source: mlagents/envs/communicator_objects/engine_configuration_proto.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
 
 DESCRIPTOR = _descriptor.FileDescriptor(
-  name='communicator_objects/engine_configuration_proto.proto',
+  name='mlagents/envs/communicator_objects/engine_configuration_proto.proto',
-  serialized_pb=_b('\n5communicator_objects/engine_configuration_proto.proto\x12\x14\x63ommunicator_objects\"\x95\x01\n\x18\x45ngineConfigurationProto\x12\r\n\x05width\x18\x01 \x01(\x05\x12\x0e\n\x06height\x18\x02 \x01(\x05\x12\x15\n\rquality_level\x18\x03 \x01(\x05\x12\x12\n\ntime_scale\x18\x04 \x01(\x02\x12\x19\n\x11target_frame_rate\x18\x05 \x01(\x05\x12\x14\n\x0cshow_monitor\x18\x06 \x01(\x08\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\nCmlagents/envs/communicator_objects/engine_configuration_proto.proto\x12\x14\x63ommunicator_objects\"\x95\x01\n\x18\x45ngineConfigurationProto\x12\r\n\x05width\x18\x01 \x01(\x05\x12\x0e\n\x06height\x18\x02 \x01(\x05\x12\x15\n\rquality_level\x18\x03 \x01(\x05\x12\x12\n\ntime_scale\x18\x04 \x01(\x02\x12\x19\n\x11target_frame_rate\x18\x05 \x01(\x05\x12\x14\n\x0cshow_monitor\x18\x06 \x01(\x08\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
 )
 
 
       has_default_value=False, default_value=0,
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='height', full_name='communicator_objects.EngineConfigurationProto.height', index=1,
       number=2, type=5, cpp_type=1, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='quality_level', full_name='communicator_objects.EngineConfigurationProto.quality_level', index=2,
       number=3, type=5, cpp_type=1, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='time_scale', full_name='communicator_objects.EngineConfigurationProto.time_scale', index=3,
       number=4, type=2, cpp_type=6, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='target_frame_rate', full_name='communicator_objects.EngineConfigurationProto.target_frame_rate', index=4,
       number=5, type=5, cpp_type=1, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='show_monitor', full_name='communicator_objects.EngineConfigurationProto.show_monitor', index=5,
       number=6, type=8, cpp_type=7, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=80,
-  serialized_end=229,
+  serialized_start=94,
+  serialized_end=243,
 )
 
 DESCRIPTOR.message_types_by_name['EngineConfigurationProto'] = _ENGINECONFIGURATIONPROTO
   DESCRIPTOR = _ENGINECONFIGURATIONPROTO,
-  __module__ = 'communicator_objects.engine_configuration_proto_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.engine_configuration_proto_pb2'
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/command_proto_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/command_proto.proto
+# source: mlagents/envs/communicator_objects/command_proto.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import reflection as _reflection
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
 
 DESCRIPTOR = _descriptor.FileDescriptor(
-  name='communicator_objects/command_proto.proto',
+  name='mlagents/envs/communicator_objects/command_proto.proto',
-  serialized_pb=_b('\n(communicator_objects/command_proto.proto\x12\x14\x63ommunicator_objects*-\n\x0c\x43ommandProto\x12\x08\n\x04STEP\x10\x00\x12\t\n\x05RESET\x10\x01\x12\x08\n\x04QUIT\x10\x02\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n6mlagents/envs/communicator_objects/command_proto.proto\x12\x14\x63ommunicator_objects*-\n\x0c\x43ommandProto\x12\x08\n\x04STEP\x10\x00\x12\t\n\x05RESET\x10\x01\x12\x08\n\x04QUIT\x10\x02\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
 )
 
 _COMMANDPROTO = _descriptor.EnumDescriptor(
   values=[
     _descriptor.EnumValueDescriptor(
       name='STEP', index=0, number=0,
-      options=None,
+      serialized_options=None,
-      options=None,
+      serialized_options=None,
-      options=None,
+      serialized_options=None,
-  options=None,
-  serialized_start=66,
-  serialized_end=111,
+  serialized_options=None,
+  serialized_start=80,
+  serialized_end=125,
 )
 _sym_db.RegisterEnumDescriptor(_COMMANDPROTO)
 
 _sym_db.RegisterFileDescriptor(DESCRIPTOR)
 
 
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/brain_type_proto_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/brain_type_proto.proto
+# source: mlagents/envs/communicator_objects/brain_type_proto.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import reflection as _reflection
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
-from communicator_objects import resolution_proto_pb2 as communicator__objects_dot_resolution__proto__pb2
+from mlagents.envs.communicator_objects import resolution_proto_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_resolution__proto__pb2
-  name='communicator_objects/brain_type_proto.proto',
+  name='mlagents/envs/communicator_objects/brain_type_proto.proto',
-  serialized_pb=_b('\n+communicator_objects/brain_type_proto.proto\x12\x14\x63ommunicator_objects\x1a+communicator_objects/resolution_proto.proto*G\n\x0e\x42rainTypeProto\x12\n\n\x06Player\x10\x00\x12\r\n\tHeuristic\x10\x01\x12\x0c\n\x08\x45xternal\x10\x02\x12\x0c\n\x08Internal\x10\x03\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n9mlagents/envs/communicator_objects/brain_type_proto.proto\x12\x14\x63ommunicator_objects\x1a\x39mlagents/envs/communicator_objects/resolution_proto.proto*G\n\x0e\x42rainTypeProto\x12\n\n\x06Player\x10\x00\x12\r\n\tHeuristic\x10\x01\x12\x0c\n\x08\x45xternal\x10\x02\x12\x0c\n\x08Internal\x10\x03\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[communicator__objects_dot_resolution__proto__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_resolution__proto__pb2.DESCRIPTOR,])
 
 _BRAINTYPEPROTO = _descriptor.EnumDescriptor(
   name='BrainTypeProto',
   values=[
     _descriptor.EnumValueDescriptor(
       name='Player', index=0, number=0,
-      options=None,
+      serialized_options=None,
-      options=None,
+      serialized_options=None,
-      options=None,
+      serialized_options=None,
-      options=None,
+      serialized_options=None,
-  options=None,
-  serialized_start=114,
-  serialized_end=185,
+  serialized_options=None,
+  serialized_start=142,
+  serialized_end=213,
 )
 _sym_db.RegisterEnumDescriptor(_BRAINTYPEPROTO)
 
 _sym_db.RegisterFileDescriptor(DESCRIPTOR)
 
 
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/brain_parameters_proto_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/brain_parameters_proto.proto
+# source: mlagents/envs/communicator_objects/brain_parameters_proto.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
-from communicator_objects import resolution_proto_pb2 as communicator__objects_dot_resolution__proto__pb2
-from communicator_objects import brain_type_proto_pb2 as communicator__objects_dot_brain__type__proto__pb2
-from communicator_objects import space_type_proto_pb2 as communicator__objects_dot_space__type__proto__pb2
+from mlagents.envs.communicator_objects import resolution_proto_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_resolution__proto__pb2
+from mlagents.envs.communicator_objects import brain_type_proto_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_brain__type__proto__pb2
+from mlagents.envs.communicator_objects import space_type_proto_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_space__type__proto__pb2
-  name='communicator_objects/brain_parameters_proto.proto',
+  name='mlagents/envs/communicator_objects/brain_parameters_proto.proto',
-  serialized_pb=_b('\n1communicator_objects/brain_parameters_proto.proto\x12\x14\x63ommunicator_objects\x1a+communicator_objects/resolution_proto.proto\x1a+communicator_objects/brain_type_proto.proto\x1a+communicator_objects/space_type_proto.proto\"\xf9\x02\n\x14\x42rainParametersProto\x12\x1f\n\x17vector_observation_size\x18\x01 \x01(\x05\x12\'\n\x1fnum_stacked_vector_observations\x18\x02 \x01(\x05\x12\x1a\n\x12vector_action_size\x18\x03 \x03(\x05\x12\x41\n\x12\x63\x61mera_resolutions\x18\x04 \x03(\x0b\x32%.communicator_objects.ResolutionProto\x12\"\n\x1avector_action_descriptions\x18\x05 \x03(\t\x12\x46\n\x18vector_action_space_type\x18\x06 \x01(\x0e\x32$.communicator_objects.SpaceTypeProto\x12\x12\n\nbrain_name\x18\x07 \x01(\t\x12\x38\n\nbrain_type\x18\x08 \x01(\x0e\x32$.communicator_objects.BrainTypeProtoB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n?mlagents/envs/communicator_objects/brain_parameters_proto.proto\x12\x14\x63ommunicator_objects\x1a\x39mlagents/envs/communicator_objects/resolution_proto.proto\x1a\x39mlagents/envs/communicator_objects/brain_type_proto.proto\x1a\x39mlagents/envs/communicator_objects/space_type_proto.proto\"\xf9\x02\n\x14\x42rainParametersProto\x12\x1f\n\x17vector_observation_size\x18\x01 \x01(\x05\x12\'\n\x1fnum_stacked_vector_observations\x18\x02 \x01(\x05\x12\x1a\n\x12vector_action_size\x18\x03 \x03(\x05\x12\x41\n\x12\x63\x61mera_resolutions\x18\x04 \x03(\x0b\x32%.communicator_objects.ResolutionProto\x12\"\n\x1avector_action_descriptions\x18\x05 \x03(\t\x12\x46\n\x18vector_action_space_type\x18\x06 \x01(\x0e\x32$.communicator_objects.SpaceTypeProto\x12\x12\n\nbrain_name\x18\x07 \x01(\t\x12\x38\n\nbrain_type\x18\x08 \x01(\x0e\x32$.communicator_objects.BrainTypeProtoB\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[communicator__objects_dot_resolution__proto__pb2.DESCRIPTOR,communicator__objects_dot_brain__type__proto__pb2.DESCRIPTOR,communicator__objects_dot_space__type__proto__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_resolution__proto__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_brain__type__proto__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_space__type__proto__pb2.DESCRIPTOR,])
 
 
 
       has_default_value=False, default_value=0,
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='num_stacked_vector_observations', full_name='communicator_objects.BrainParametersProto.num_stacked_vector_observations', index=1,
       number=2, type=5, cpp_type=1, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='vector_action_size', full_name='communicator_objects.BrainParametersProto.vector_action_size', index=2,
       number=3, type=5, cpp_type=1, label=3,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='camera_resolutions', full_name='communicator_objects.BrainParametersProto.camera_resolutions', index=3,
       number=4, type=11, cpp_type=10, label=3,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='vector_action_descriptions', full_name='communicator_objects.BrainParametersProto.vector_action_descriptions', index=4,
       number=5, type=9, cpp_type=9, label=3,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='vector_action_space_type', full_name='communicator_objects.BrainParametersProto.vector_action_space_type', index=5,
       number=6, type=14, cpp_type=8, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='brain_name', full_name='communicator_objects.BrainParametersProto.brain_name', index=6,
       number=7, type=9, cpp_type=9, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='brain_type', full_name='communicator_objects.BrainParametersProto.brain_type', index=7,
       number=8, type=14, cpp_type=8, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=211,
-  serialized_end=588,
+  serialized_start=267,
+  serialized_end=644,
-_BRAINPARAMETERSPROTO.fields_by_name['camera_resolutions'].message_type = communicator__objects_dot_resolution__proto__pb2._RESOLUTIONPROTO
-_BRAINPARAMETERSPROTO.fields_by_name['vector_action_space_type'].enum_type = communicator__objects_dot_space__type__proto__pb2._SPACETYPEPROTO
-_BRAINPARAMETERSPROTO.fields_by_name['brain_type'].enum_type = communicator__objects_dot_brain__type__proto__pb2._BRAINTYPEPROTO
+_BRAINPARAMETERSPROTO.fields_by_name['camera_resolutions'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_resolution__proto__pb2._RESOLUTIONPROTO
+_BRAINPARAMETERSPROTO.fields_by_name['vector_action_space_type'].enum_type = mlagents_dot_envs_dot_communicator__objects_dot_space__type__proto__pb2._SPACETYPEPROTO
+_BRAINPARAMETERSPROTO.fields_by_name['brain_type'].enum_type = mlagents_dot_envs_dot_communicator__objects_dot_brain__type__proto__pb2._BRAINTYPEPROTO
-  __module__ = 'communicator_objects.brain_parameters_proto_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.brain_parameters_proto_pb2'
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/agent_info_proto_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/agent_info_proto.proto
+# source: mlagents/envs/communicator_objects/agent_info_proto.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
 
 DESCRIPTOR = _descriptor.FileDescriptor(
-  name='communicator_objects/agent_info_proto.proto',
+  name='mlagents/envs/communicator_objects/agent_info_proto.proto',
-  serialized_pb=_b('\n+communicator_objects/agent_info_proto.proto\x12\x14\x63ommunicator_objects\"\x92\x02\n\x0e\x41gentInfoProto\x12\"\n\x1astacked_vector_observation\x18\x01 \x03(\x02\x12\x1b\n\x13visual_observations\x18\x02 \x03(\x0c\x12\x18\n\x10text_observation\x18\x03 \x01(\t\x12\x1d\n\x15stored_vector_actions\x18\x04 \x03(\x02\x12\x1b\n\x13stored_text_actions\x18\x05 \x01(\t\x12\x10\n\x08memories\x18\x06 \x03(\x02\x12\x0e\n\x06reward\x18\x07 \x01(\x02\x12\x0c\n\x04\x64one\x18\x08 \x01(\x08\x12\x18\n\x10max_step_reached\x18\t \x01(\x08\x12\n\n\x02id\x18\n \x01(\x05\x12\x13\n\x0b\x61\x63tion_mask\x18\x0b \x03(\x08\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n9mlagents/envs/communicator_objects/agent_info_proto.proto\x12\x14\x63ommunicator_objects\"\x92\x02\n\x0e\x41gentInfoProto\x12\"\n\x1astacked_vector_observation\x18\x01 \x03(\x02\x12\x1b\n\x13visual_observations\x18\x02 \x03(\x0c\x12\x18\n\x10text_observation\x18\x03 \x01(\t\x12\x1d\n\x15stored_vector_actions\x18\x04 \x03(\x02\x12\x1b\n\x13stored_text_actions\x18\x05 \x01(\t\x12\x10\n\x08memories\x18\x06 \x03(\x02\x12\x0e\n\x06reward\x18\x07 \x01(\x02\x12\x0c\n\x04\x64one\x18\x08 \x01(\x08\x12\x18\n\x10max_step_reached\x18\t \x01(\x08\x12\n\n\x02id\x18\n \x01(\x05\x12\x13\n\x0b\x61\x63tion_mask\x18\x0b \x03(\x08\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
 )
 
 
       has_default_value=False, default_value=[],
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='visual_observations', full_name='communicator_objects.AgentInfoProto.visual_observations', index=1,
       number=2, type=12, cpp_type=9, label=3,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='text_observation', full_name='communicator_objects.AgentInfoProto.text_observation', index=2,
       number=3, type=9, cpp_type=9, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='stored_vector_actions', full_name='communicator_objects.AgentInfoProto.stored_vector_actions', index=3,
       number=4, type=2, cpp_type=6, label=3,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='stored_text_actions', full_name='communicator_objects.AgentInfoProto.stored_text_actions', index=4,
       number=5, type=9, cpp_type=9, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='memories', full_name='communicator_objects.AgentInfoProto.memories', index=5,
       number=6, type=2, cpp_type=6, label=3,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='reward', full_name='communicator_objects.AgentInfoProto.reward', index=6,
       number=7, type=2, cpp_type=6, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='done', full_name='communicator_objects.AgentInfoProto.done', index=7,
       number=8, type=8, cpp_type=7, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='max_step_reached', full_name='communicator_objects.AgentInfoProto.max_step_reached', index=8,
       number=9, type=8, cpp_type=7, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='id', full_name='communicator_objects.AgentInfoProto.id', index=9,
       number=10, type=5, cpp_type=1, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='action_mask', full_name='communicator_objects.AgentInfoProto.action_mask', index=10,
       number=11, type=8, cpp_type=7, label=3,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=70,
-  serialized_end=344,
+  serialized_start=84,
+  serialized_end=358,
 )
 
 DESCRIPTOR.message_types_by_name['AgentInfoProto'] = _AGENTINFOPROTO
   DESCRIPTOR = _AGENTINFOPROTO,
-  __module__ = 'communicator_objects.agent_info_proto_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.agent_info_proto_pb2'
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/communicator_objects/agent_action_proto_pb2.py

 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: communicator_objects/agent_action_proto.proto
+# source: mlagents/envs/communicator_objects/agent_action_proto.proto
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf import descriptor_pb2
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
 
 DESCRIPTOR = _descriptor.FileDescriptor(
-  name='communicator_objects/agent_action_proto.proto',
+  name='mlagents/envs/communicator_objects/agent_action_proto.proto',
-  serialized_pb=_b('\n-communicator_objects/agent_action_proto.proto\x12\x14\x63ommunicator_objects\"a\n\x10\x41gentActionProto\x12\x16\n\x0evector_actions\x18\x01 \x03(\x02\x12\x14\n\x0ctext_actions\x18\x02 \x01(\t\x12\x10\n\x08memories\x18\x03 \x03(\x02\x12\r\n\x05value\x18\x04 \x01(\x02\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_options=_b('\252\002\034MLAgents.CommunicatorObjects'),
+  serialized_pb=_b('\n;mlagents/envs/communicator_objects/agent_action_proto.proto\x12\x14\x63ommunicator_objects\"a\n\x10\x41gentActionProto\x12\x16\n\x0evector_actions\x18\x01 \x03(\x02\x12\x14\n\x0ctext_actions\x18\x02 \x01(\t\x12\x10\n\x08memories\x18\x03 \x03(\x02\x12\r\n\x05value\x18\x04 \x01(\x02\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
 )
 
 
       has_default_value=False, default_value=[],
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='text_actions', full_name='communicator_objects.AgentActionProto.text_actions', index=1,
       number=2, type=9, cpp_type=9, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='memories', full_name='communicator_objects.AgentActionProto.memories', index=2,
       number=3, type=2, cpp_type=6, label=3,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
       name='value', full_name='communicator_objects.AgentActionProto.value', index=3,
       number=4, type=2, cpp_type=6, label=1,
-      options=None, file=DESCRIPTOR),
+      serialized_options=None, file=DESCRIPTOR),
   ],
   extensions=[
   ],
-  options=None,
+  serialized_options=None,
-  serialized_start=71,
-  serialized_end=168,
+  serialized_start=85,
+  serialized_end=182,
 )
 
 DESCRIPTOR.message_types_by_name['AgentActionProto'] = _AGENTACTIONPROTO
   DESCRIPTOR = _AGENTACTIONPROTO,
-  __module__ = 'communicator_objects.agent_action_proto_pb2'
+  __module__ = 'mlagents.envs.communicator_objects.agent_action_proto_pb2'
-DESCRIPTOR.has_options = True
-DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\252\002\034MLAgents.CommunicatorObjects'))
+DESCRIPTOR._options = None
 # @@protoc_insertion_point(module_scope)

ml-agents/mlagents/envs/socket_communicator.py

 import struct
 
 from .communicator import Communicator
-from communicator_objects import UnityMessage, UnityOutput, UnityInput
+from .communicator_objects import UnityMessage, UnityOutput, UnityInput
-logger = logging.getLogger("unityagents")
+logger = logging.getLogger("mlagents.envs")
 
 
 class SocketCommunicator(Communicator):

ml-agents/mlagents/envs/rpc_communicator.py

 from concurrent.futures import ThreadPoolExecutor
 
 from .communicator import Communicator
-from communicator_objects import UnityToExternalServicer, add_UnityToExternalServicer_to_server
-from communicator_objects import UnityMessage, UnityInput, UnityOutput
+from .communicator_objects import UnityToExternalServicer, add_UnityToExternalServicer_to_server
+from .communicator_objects import UnityMessage, UnityInput, UnityOutput
-logger = logging.getLogger("unityagents")
+logger = logging.getLogger("mlagents.envs")
 
 
 class UnityToExternalServicerImplementation(UnityToExternalServicer):

ml-agents/mlagents/envs/exception.py

 import logging
-logger = logging.getLogger("unityagents")
+logger = logging.getLogger("mlagents.envs")
 
 class UnityException(Exception):
     """
                         "You can check the logfile for more information at {}".format(log_file_path))
             except:
                 logger.error("An error might have occured in the environment. "
-               "No unity-environment.log file could be found.") 
+               "No MLAgentsSDK.log file could be found.") 
         super(UnityTimeOutException, self).__init__(message)
 

ml-agents/mlagents/envs/environment.py

 from .brain import BrainInfo, BrainParameters, AllBrainInfo
 from .exception import UnityEnvironmentException, UnityActionException, UnityTimeOutException
 
-from communicator_objects import UnityRLInput, UnityRLOutput, AgentActionProto,\
+from .communicator_objects import UnityRLInput, UnityRLOutput, AgentActionProto,\
     EnvironmentParametersProto, UnityRLInitializationInput, UnityRLInitializationOutput,\
     UnityInput, UnityOutput
 
 from PIL import Image
 
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("unityagents")
+logger = logging.getLogger("mlagents.envs")
 
 
 class UnityEnvironment(object):

ml-agents/mlagents/envs/communicator.py

 import logging
 
-from communicator_objects import UnityOutput, UnityInput
+from .communicator_objects import UnityOutput, UnityInput
-logger = logging.getLogger("unityagents")
+logger = logging.getLogger("mlagents.envs")
 
 
 class Communicator(object):

ml-agents/mlagents/envs/__init__.py

+from .environment import *
+from .brain import *
+from .exception import *

notebooks/getting-started.ipynb

    "source": [
     "### 1. Set environment parameters\n",
     "\n",
-    "Be sure to set `env_name` to the name of the Unity environment file you want to launch. Ensure that the environment build is in the `python/` directory."
+    "Be sure to set `env_name` to the name of the Unity environment file you want to launch. Ensure that the environment build is in `../envs`."
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "env_name = \"../envs/3DBall\"  # Name of the Unity environment binary to launch\n",
     "import numpy as np\n",
     "import sys\n",
     "\n",
-    "from unityagents import UnityEnvironment\n",
+    "from mlagents.envs import UnityEnvironment\n",
     "\n",
     "%matplotlib inline\n",
     "\n",
     "    done = False\n",
     "    episode_rewards = 0\n",
     "    while not done:\n",
+    "        action_size = brain.vector_action_space_size\n",
-    "                                                brain.vector_action_space_size))[default_brain]\n",
+    "                                                action_size[0]))[default_brain]\n",
-    "            env_info = env.step(np.random.randint(0, brain.vector_action_space_size, \n",
-    "                                                  size=(len(env_info.agents))))[default_brain]\n",
+    "            action = np.column_stack([np.random.randint(0, action_size[i], size=(len(env_info.agents))) for i in range(len(action_size))])\n",
+    "            env_info = env.step(action)[default_brain]\n",
     "        episode_rewards += env_info.rewards[0]\n",
     "        done = env_info.local_done[0]\n",
     "    print(\"Total reward this episode: {}\".format(episode_rewards))"
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "env.close()"
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.2"
+   "version": "3.6.6"
   }
  },
  "nbformat": 4,

ml-agents/mlagents/trainers/trainer_controller.py

 # # Unity ML-Agents Toolkit
 # ## ML-Agent Learning
-"""Launches unitytrainers for each External Brains in a Unity Environment."""
+"""Launches trainers for each External Brains in a Unity Environment."""
 
 import os
 import logging
 import numpy as np
 import tensorflow as tf
 from tensorflow.python.tools import freeze_graph
-from unityagents.environment import UnityEnvironment
-from unityagents.exception import UnityEnvironmentException
+from mlagents.envs.environment import UnityEnvironment
+from mlagents.envs.exception import UnityEnvironmentException
-from unitytrainers.ppo.trainer import PPOTrainer
-from unitytrainers.bc.trainer import BehavioralCloningTrainer
-from unitytrainers.meta_curriculum import MetaCurriculum
-from unitytrainers.exception import MetaCurriculumError
+from mlagents.trainers.ppo.trainer import PPOTrainer
+from mlagents.trainers.bc.trainer import BehavioralCloningTrainer
+from mlagents.trainers.meta_curriculum import MetaCurriculum
+from mlagents.trainers.exception import MetaCurriculumError
 
 
 class TrainerController(object):
             self.summaries_dir = '/{docker_target_name}/summaries'.format(
                 docker_target_name=docker_target_name)
 
-        self.logger = logging.getLogger("unityagents")
+        self.logger = logging.getLogger("mlagents.envs")
         self.run_id = run_id
         self.save_freq = save_freq
         self.lesson = lesson