Merge branch 'master' of github.com:Unity-Technologies/ml-agents into develop-agentprocessor

CONTRIBUTING.md

 issues with the `contributions welcome` label.
 
 ## Git Branches
+The master branch corresponds to the most recent version of the project.
+Note that this may be newer that the [latest release](https://github.com/Unity-Technologies/ml-agents/releases/tag/latest_release).
-Starting with v0.3, we adopted the
-[Gitflow Workflow](http://nvie.com/posts/a-successful-git-branching-model/).
-Consequently, the `master` branch corresponds to the latest release of
-the project, while the `develop` branch corresponds to the most recent, stable,
-version of the project.
-
-Thus, when adding to the project, **please branch off `develop`**
-and make sure that your Pull Request (PR) contains the following:
+When contributing to the project, please make sure that your Pull Request (PR) contains the following:
 
 * Detailed description of the changes performed
 * Corresponding changes to documentation, unit tests and sample environments (if

README.md

 [![docs badge](https://img.shields.io/badge/docs-reference-blue.svg)](docs/Readme.md)
 [![license badge](https://img.shields.io/badge/license-Apache--2.0-green.svg)](LICENSE)
 
+([latest release](https://github.com/Unity-Technologies/ml-agents/releases/tag/latest_release))
+([all releases](https://github.com/Unity-Technologies/ml-agents/releases))
+
 **The Unity Machine Learning Agents Toolkit** (ML-Agents) 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,

UnitySDK/Assets/ML-Agents/Editor/Tests/DemonstrationTests.cs

             var acaGo = new GameObject("TestAcademy");
             acaGo.AddComponent<TestAcademy>();
             var aca = acaGo.GetComponent<TestAcademy>();
-            aca.resetParameters = new ResetParameters();
 
             var academyInitializeMethod = typeof(Academy).GetMethod("InitializeEnvironment",
                 BindingFlags.Instance | BindingFlags.NonPublic);

UnitySDK/Assets/ML-Agents/Editor/Tests/EditModeTestInternalBrainTensorGenerator.cs

             var acaGo = new GameObject("TestAcademy");
             acaGo.AddComponent<TestAcademy>();
             var aca = acaGo.GetComponent<TestAcademy>();
-            aca.resetParameters = new ResetParameters();
 
             var goA = new GameObject("goA");
             var bpA = goA.AddComponent<BehaviorParameters>();

UnitySDK/Assets/ML-Agents/Editor/Tests/MLAgentsEditModeTest.cs

             var acaGo = new GameObject("TestAcademy");
             acaGo.AddComponent<TestAcademy>();
             var aca = acaGo.GetComponent<TestAcademy>();
-            aca.resetParameters = new ResetParameters();
             Assert.AreEqual(0, aca.initializeAcademyCalls);
             Assert.AreEqual(0, aca.GetStepCount());
             Assert.AreEqual(0, aca.GetEpisodeCount());
             var acaGo = new GameObject("TestAcademy");
             acaGo.AddComponent<TestAcademy>();
             var aca = acaGo.GetComponent<TestAcademy>();
-            aca.resetParameters = new ResetParameters();
 
             Assert.AreEqual(false, agent1.IsDone());
             Assert.AreEqual(false, agent2.IsDone());
             var acaGo = new GameObject("TestAcademy");
             acaGo.AddComponent<TestAcademy>();
             var aca = acaGo.GetComponent<TestAcademy>();
-            aca.resetParameters = new ResetParameters();
             var academyInitializeMethod = typeof(Academy).GetMethod("InitializeEnvironment",
                 BindingFlags.Instance | BindingFlags.NonPublic);
             academyInitializeMethod?.Invoke(aca, new object[] { });
             var acaGo = new GameObject("TestAcademy");
             acaGo.AddComponent<TestAcademy>();
             var aca = acaGo.GetComponent<TestAcademy>();
-            aca.resetParameters = new ResetParameters();
 
 
             var agentEnableMethod = typeof(Agent).GetMethod(
             var acaGo = new GameObject("TestAcademy");
             acaGo.AddComponent<TestAcademy>();
             var aca = acaGo.GetComponent<TestAcademy>();
-            aca.resetParameters = new ResetParameters();
             var academyInitializeMethod = typeof(Academy).GetMethod(
                 "InitializeEnvironment", BindingFlags.Instance | BindingFlags.NonPublic);
             academyInitializeMethod?.Invoke(aca, new object[] { });
             var acaGo = new GameObject("TestAcademy");
             acaGo.AddComponent<TestAcademy>();
             var aca = acaGo.GetComponent<TestAcademy>();
-            aca.resetParameters = new ResetParameters();
 
 
             var agentEnableMethod = typeof(Agent).GetMethod(
             var acaGo = new GameObject("TestAcademy");
             acaGo.AddComponent<TestAcademy>();
             var aca = acaGo.GetComponent<TestAcademy>();
-            aca.resetParameters = new ResetParameters();
 
 
             var agentEnableMethod = typeof(Agent).GetMethod(
             var acaGo = new GameObject("TestAcademy");
             acaGo.AddComponent<TestAcademy>();
             var aca = acaGo.GetComponent<TestAcademy>();
-            aca.resetParameters = new ResetParameters();
 
 
             var agentEnableMethod = typeof(Agent).GetMethod(

UnitySDK/Assets/ML-Agents/Examples/3DBall/Scripts/Ball3DAcademy.cs

 
 public class Ball3DAcademy : Academy
 {
-    public override void AcademyReset()
+    public override void InitializeAcademy()
-        Physics.gravity = new Vector3(0, -resetParameters["gravity"], 0);
+        FloatProperties.RegisterCallback("gravity", f => { Physics.gravity = new Vector3(0, -f, 0); });
-    public override void AcademyStep()
-    {
-    }
 }

UnitySDK/Assets/ML-Agents/Examples/3DBall/Scripts/Ball3DAgent.cs

     [Header("Specific to Ball3D")]
     public GameObject ball;
     Rigidbody m_BallRb;
-    ResetParameters m_ResetParams;
+    IFloatProperties m_ResetParams;
-        m_ResetParams = academy.resetParameters;
+        m_ResetParams = academy.FloatProperties;
         SetResetParameters();
     }
 
     public void SetBall()
     {
         //Set the attributes of the ball by fetching the information from the academy
-        m_BallRb.mass = m_ResetParams["mass"];
-        var scale = m_ResetParams["scale"];
+        m_BallRb.mass = m_ResetParams.GetPropertyWithDefault("mass", 1.0f);
+        var scale = m_ResetParams.GetPropertyWithDefault("scale", 1.0f);
         ball.transform.localScale = new Vector3(scale, scale, scale);
     }
 

UnitySDK/Assets/ML-Agents/Examples/3DBall/Scripts/Ball3DHardAgent.cs

     [Header("Specific to Ball3DHard")]
     public GameObject ball;
     Rigidbody m_BallRb;
-    ResetParameters m_ResetParams;
+    IFloatProperties m_ResetParams;
-        m_ResetParams = academy.resetParameters;
+        m_ResetParams = academy.FloatProperties;
         SetResetParameters();
     }
 
     public void SetBall()
     {
         //Set the attributes of the ball by fetching the information from the academy
-        m_BallRb.mass = m_ResetParams["mass"];
-        var scale = m_ResetParams["scale"];
+        m_BallRb.mass = m_ResetParams.GetPropertyWithDefault("mass", 1.0f);
+        var scale = m_ResetParams.GetPropertyWithDefault("scale", 1.0f);
         ball.transform.localScale = new Vector3(scale, scale, scale);
     }
 

UnitySDK/Assets/ML-Agents/Examples/Basic/Scripts/BasicAgent.cs

 
     void WaitTimeInference()
     {
-        if (!m_Academy.GetIsInference())
+        if (!m_Academy.IsCommunicatorOn)
         {
             RequestDecision();
         }

UnitySDK/Assets/ML-Agents/Examples/Bouncer/Scripts/BouncerAgent.cs

     int m_NumberJumps = 20;
     int m_JumpLeft = 20;
 
-    ResetParameters m_ResetParams;
+    IFloatProperties m_ResetParams;
 
     public override void InitializeAgent()
     {
         var academy = FindObjectOfType<Academy>();
-        m_ResetParams = academy.resetParameters;
+        m_ResetParams = academy.FloatProperties;
 
         SetResetParameters();
     }
 
     public void SetTargetScale()
     {
-        var targetScale = m_ResetParams["target_scale"];
+        var targetScale = m_ResetParams.GetPropertyWithDefault("target_scale", 1.0f);
         target.transform.localScale = new Vector3(targetScale, targetScale, targetScale);
     }
 

UnitySDK/Assets/ML-Agents/Examples/FoodCollector/Scripts/FoodCollectorAgent.cs

 
     public void SetLaserLengths()
     {
-        m_LaserLength = m_MyAcademy.resetParameters.TryGetValue("laser_length", out m_LaserLength) ? m_LaserLength : 1.0f;
+        m_LaserLength = m_MyAcademy.FloatProperties.GetPropertyWithDefault("laser_length", 1.0f);
-        float agentScale;
-        agentScale = m_MyAcademy.resetParameters.TryGetValue("agent_scale", out agentScale) ? agentScale : 1.0f;
+        float agentScale = m_MyAcademy.FloatProperties.GetPropertyWithDefault("agent_scale", 1.0f);
         gameObject.transform.localScale = new Vector3(agentScale, agentScale, agentScale);
     }
 

UnitySDK/Assets/ML-Agents/Examples/GridWorld/Scripts/GridAcademy.cs

 {
     public Camera MainCamera;
 
-    public override void AcademyReset()
+    public override void InitializeAcademy()
-        MainCamera.transform.position = new Vector3(-((int)resetParameters["gridSize"] - 1) / 2f,
-            (int)resetParameters["gridSize"] * 1.25f,
-            -((int)resetParameters["gridSize"] - 1) / 2f);
-        MainCamera.orthographicSize = ((int)resetParameters["gridSize"] + 5f) / 2f;
+        FloatProperties.RegisterCallback("gridSize", f =>
+        {
+            MainCamera.transform.position = new Vector3(-(f - 1) / 2f, f * 1.25f, -(f - 1) / 2f);
+            MainCamera.orthographicSize = (f + 5f) / 2f;
+        });
+
     }
 }

UnitySDK/Assets/ML-Agents/Examples/GridWorld/Scripts/GridAgent.cs

         // Prevents the agent from picking an action that would make it collide with a wall
         var positionX = (int)transform.position.x;
         var positionZ = (int)transform.position.z;
-        var maxPosition = (int)m_Academy.resetParameters["gridSize"] - 1;
+        var maxPosition = (int)m_Academy.FloatProperties.GetPropertyWithDefault("gridSize", 5f) - 1;
 
         if (positionX == 0)
         {
             renderCamera.Render();
         }
 
-        if (!m_Academy.GetIsInference())
+        if (!m_Academy.IsCommunicatorOn)
         {
             RequestDecision();
         }

UnitySDK/Assets/ML-Agents/Examples/GridWorld/Scripts/GridArea.cs

 
     public GameObject trueAgent;
 
-    ResetParameters m_ResetParameters;
+    IFloatProperties m_ResetParameters;
 
     Camera m_AgentCam;
 
 
     public void Awake()
     {
-        m_ResetParameters = FindObjectOfType<Academy>().resetParameters;
+        m_ResetParameters = FindObjectOfType<Academy>().FloatProperties;
 
         m_Objects = new[] { goalPref, pitPref };
 
 
     public void SetEnvironment()
     {
-        transform.position = m_InitialPosition * (m_ResetParameters["gridSize"] + 1);
+        transform.position = m_InitialPosition * (m_ResetParameters.GetPropertyWithDefault("gridSize", 5f) + 1);
-        for (var i = 0; i < (int)m_ResetParameters["numObstacles"]; i++)
+        for (var i = 0; i < (int)m_ResetParameters.GetPropertyWithDefault("numObstacles", 1); i++)
-        for (var i = 0; i < (int)m_ResetParameters["numGoals"]; i++)
+        for (var i = 0; i < (int)m_ResetParameters.GetPropertyWithDefault("numGoals", 1f); i++)
-        var gridSize = (int)m_ResetParameters["gridSize"];
+        var gridSize = (int)m_ResetParameters.GetPropertyWithDefault("gridSize", 5f);
         m_Plane.transform.localScale = new Vector3(gridSize / 10.0f, 1f, gridSize / 10.0f);
         m_Plane.transform.localPosition = new Vector3((gridSize - 1) / 2f, -0.5f, (gridSize - 1) / 2f);
         m_Sn.transform.localScale = new Vector3(1, 1, gridSize + 2);
 
     public void AreaReset()
     {
-        var gridSize = (int)m_ResetParameters["gridSize"];
+        var gridSize = (int)m_ResetParameters.GetPropertyWithDefault("gridSize", 5f); ;
         foreach (var actor in actorObjs)
         {
             DestroyImmediate(actor);

UnitySDK/Assets/ML-Agents/Examples/PushBlock/Scripts/PushAgentBasic.cs

 
     public void SetGroundMaterialFriction()
     {
-        var resetParams = m_Academy.resetParameters;
+        var resetParams = m_Academy.FloatProperties;
-        groundCollider.material.dynamicFriction = resetParams["dynamic_friction"];
-        groundCollider.material.staticFriction = resetParams["static_friction"];
+        groundCollider.material.dynamicFriction = resetParams.GetPropertyWithDefault("dynamic_friction", 0);
+        groundCollider.material.staticFriction = resetParams.GetPropertyWithDefault("static_friction", 0);
-        var resetParams = m_Academy.resetParameters;
+        var resetParams = m_Academy.FloatProperties;
+        var scale = resetParams.GetPropertyWithDefault("block_scale", 2);
-        m_BlockRb.transform.localScale = new Vector3(resetParams["block_scale"], 0.75f, resetParams["block_scale"]);
+        m_BlockRb.transform.localScale = new Vector3(scale, 0.75f, scale);
-        m_BlockRb.drag = resetParams["block_drag"];
+        m_BlockRb.drag = resetParams.GetPropertyWithDefault("block_drag", 0.5f);
     }
 
     public void SetResetParameters()

UnitySDK/Assets/ML-Agents/Examples/Reacher/Scripts/ReacherAcademy.cs

 {
     public override void AcademyReset()
     {
-        Physics.gravity = new Vector3(0, -resetParameters["gravity"], 0);
+        FloatProperties.RegisterCallback("gravity", f => { Physics.gravity = new Vector3(0, -f, 0); });
+
     }
 
     public override void AcademyStep()

UnitySDK/Assets/ML-Agents/Examples/Reacher/Scripts/ReacherAgent.cs

 
     public void SetResetParameters()
     {
-        m_GoalSize = m_MyAcademy.resetParameters["goal_size"];
-        m_GoalSpeed = Random.Range(-1f, 1f) * m_MyAcademy.resetParameters["goal_speed"];
-        m_Deviation = m_MyAcademy.resetParameters["deviation"];
-        m_DeviationFreq = m_MyAcademy.resetParameters["deviation_freq"];
+        var fp = m_MyAcademy.FloatProperties;
+        m_GoalSize = fp.GetPropertyWithDefault("goal_size", 5);
+        m_GoalSpeed = Random.Range(-1f, 1f) * fp.GetPropertyWithDefault("goal_speed", 1);
+        m_Deviation = fp.GetPropertyWithDefault("deviation", 0);
+        m_DeviationFreq = fp.GetPropertyWithDefault("deviation_freq", 0);
     }
 }

UnitySDK/Assets/ML-Agents/Examples/Soccer/Scripts/SoccerAcademy.cs

         Physics.gravity *= gravityMultiplier; //for soccer a multiplier of 3 looks good
     }
 
-    public override void AcademyReset()
+    public override void InitializeAcademy()
-        Physics.gravity = new Vector3(0, -resetParameters["gravity"], 0);
+        FloatProperties.RegisterCallback("gravity", f => { Physics.gravity = new Vector3(0, -f, 0); });
     }
 
     public override void AcademyStep()

UnitySDK/Assets/ML-Agents/Examples/Soccer/Scripts/SoccerFieldArea.cs

         ballRb.velocity = Vector3.zero;
         ballRb.angularVelocity = Vector3.zero;
 
-        var ballScale = m_Academy.resetParameters["ball_scale"];
+        var ballScale = m_Academy.FloatProperties.GetPropertyWithDefault("ball_scale", 0.015f);
         ballRb.transform.localScale = new Vector3(ballScale, ballScale, ballScale);
     }
 }

UnitySDK/Assets/ML-Agents/Examples/Tennis/Scripts/TennisAcademy.cs

 
 public class TennisAcademy : Academy
 {
-    public override void AcademyReset()
+    public override void InitializeAcademy()
-        Physics.gravity = new Vector3(0, -resetParameters["gravity"], 0);
+        FloatProperties.RegisterCallback("gravity", f => { Physics.gravity = new Vector3(0, -f, 0); });
+
     }
 
     public override void AcademyStep()

UnitySDK/Assets/ML-Agents/Examples/Tennis/Scripts/TennisAgent.cs

     Rigidbody m_AgentRb;
     Rigidbody m_BallRb;
     float m_InvertMult;
-    ResetParameters m_ResetParams;
+    IFloatProperties m_ResetParams;
 
     // Looks for the scoreboard based on the name of the gameObjects.
     // Do not modify the names of the Score GameObjects
         var canvas = GameObject.Find(k_CanvasName);
         GameObject scoreBoard;
         var academy = FindObjectOfType<Academy>();
-        m_ResetParams = academy.resetParameters;
+        m_ResetParams = academy.FloatProperties;
         if (invertX)
         {
             scoreBoard = canvas.transform.Find(k_ScoreBoardBName).gameObject;
 
     public void SetRacket()
     {
-        angle = m_ResetParams["angle"];
+        angle = m_ResetParams.GetPropertyWithDefault("angle", 55);
         gameObject.transform.eulerAngles = new Vector3(
             gameObject.transform.eulerAngles.x,
             gameObject.transform.eulerAngles.y,
 
     public void SetBall()
     {
-        scale = m_ResetParams["scale"];
+        scale = m_ResetParams.GetPropertyWithDefault("scale", 1);
         ball.transform.localScale = new Vector3(scale, scale, scale);
     }
 

UnitySDK/Assets/ML-Agents/Examples/Walker/Scripts/WalkerAcademy.cs

         Physics.defaultSolverVelocityIterations = 12;
         Time.fixedDeltaTime = 0.01333f; //(75fps). default is .2 (60fps)
         Time.maximumDeltaTime = .15f; // Default is .33
-    }
-    public override void AcademyReset()
-    {
-        Physics.gravity = new Vector3(0, -resetParameters["gravity"], 0);
+        FloatProperties.RegisterCallback("gravity", f => { Physics.gravity = new Vector3(0, -f, 0); });
+
     }
 
     public override void AcademyStep()

UnitySDK/Assets/ML-Agents/Examples/Walker/Scripts/WalkerAgent.cs

 
 public class WalkerAgent : Agent
 {
-    [Header("Specific to Walker")][Header("Target To Walk Towards")][Space(10)]
+    [Header("Specific to Walker")]
+    [Header("Target To Walk Towards")]
+    [Space(10)]
     public Transform target;
 
     Vector3 m_DirToTarget;
     Rigidbody m_ChestRb;
     Rigidbody m_SpineRb;
 
-    ResetParameters m_ResetParams;
+    IFloatProperties m_ResetParams;
 
     public override void InitializeAgent()
     {
         m_SpineRb = spine.GetComponent<Rigidbody>();
 
         var academy = FindObjectOfType<WalkerAcademy>();
-        m_ResetParams = academy.resetParameters;
+        m_ResetParams = academy.FloatProperties;
 
         SetResetParameters();
     }
 
     public void SetTorsoMass()
     {
-        m_ChestRb.mass = m_ResetParams["chest_mass"];
-        m_SpineRb.mass = m_ResetParams["spine_mass"];
-        m_HipsRb.mass = m_ResetParams["hip_mass"];
+        m_ChestRb.mass = m_ResetParams.GetPropertyWithDefault("chest_mass", 8);
+        m_SpineRb.mass = m_ResetParams.GetPropertyWithDefault("spine_mass", 10);
+        m_HipsRb.mass = m_ResetParams.GetPropertyWithDefault("hip_mass", 15);
     }
 
     public void SetResetParameters()

UnitySDK/Assets/ML-Agents/Examples/WallJump/Scripts/WallJumpAgent.cs

         {
             localScale = new Vector3(
                 localScale.x,
-                m_Academy.resetParameters["no_wall_height"],
+                m_Academy.FloatProperties.GetPropertyWithDefault("no_wall_height", 0),
                 localScale.z);
             wall.transform.localScale = localScale;
             GiveModel("SmallWallJump", noWallBrain);
             localScale = new Vector3(
                 localScale.x,
-                m_Academy.resetParameters["small_wall_height"],
+                m_Academy.FloatProperties.GetPropertyWithDefault("small_wall_height", 4),
                 localScale.z);
             wall.transform.localScale = localScale;
             GiveModel("SmallWallJump", smallWallBrain);
-            var height =
-                m_Academy.resetParameters["big_wall_min_height"] +
-                Random.value * (m_Academy.resetParameters["big_wall_max_height"] -
-                    m_Academy.resetParameters["big_wall_min_height"]);
+            var min = m_Academy.FloatProperties.GetPropertyWithDefault("big_wall_min_height", 8);
+            var max = m_Academy.FloatProperties.GetPropertyWithDefault("big_wall_max_height", 8);
+            var height = min + Random.value * (max - min);
             localScale = new Vector3(
                 localScale.x,
                 height,

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

 
 namespace MLAgents
 {
-    /// <summary>
-    /// Wraps the environment-level parameters that are provided within the
-    /// Editor. These parameters can be provided for training and inference
-    /// modes separately and represent screen resolution, rendering quality and
-    /// frame rate.
-    /// </summary>
-    [System.Serializable]
-    public class EnvironmentConfiguration
-    {
-        [Tooltip("Width of the environment window in pixels.")]
-        public int width;
-
-        [Tooltip("Height of the environment window in pixels.")]
-        public int height;
-
-        [Tooltip("Rendering quality of environment. (Higher is better quality.)")]
-        [Range(0, 5)]
-        public int qualityLevel;
-
-        [Tooltip("Speed at which environment is run. (Higher is faster.)")]
-        [Range(1f, 100f)]
-        public float timeScale;
-
-        [Tooltip("Frames per second (FPS) engine attempts to maintain.")]
-        public int targetFrameRate;
-
-        /// Initializes a new instance of the
-        /// <see cref="EnvironmentConfiguration"/> class.
-        /// <param name="width">Width of environment window (pixels).</param>
-        /// <param name="height">Height of environment window (pixels).</param>
-        /// <param name="qualityLevel">
-        /// Rendering quality of environment. Ranges from 0 to 5, with higher.
-        /// </param>
-        /// <param name="timeScale">
-        /// Speed at which environment is run. Ranges from 1 to 100, with higher
-        /// values representing faster speed.
-        /// </param>
-        /// <param name="targetFrameRate">
-        /// Target frame rate (per second) that the engine tries to maintain.
-        /// </param>
-        public EnvironmentConfiguration(
-            int width, int height, int qualityLevel,
-            float timeScale, int targetFrameRate)
-        {
-            this.width = width;
-            this.height = height;
-            this.qualityLevel = qualityLevel;
-            this.timeScale = timeScale;
-            this.targetFrameRate = targetFrameRate;
-        }
-    }
 
     /// <summary>
     /// An Academy is where Agent objects go to train their behaviors.
         /// Used to restore original value when deriving Academy modifies it
         float m_OriginalMaximumDeltaTime;
 
-        // Fields provided in the Inspector
-
-        [FormerlySerializedAs("trainingConfiguration")]
-        [SerializeField]
-        [Tooltip("The engine-level settings which correspond to rendering " +
-            "quality and engine speed during Training.")]
-        EnvironmentConfiguration m_TrainingConfiguration =
-            new EnvironmentConfiguration(80, 80, 1, 100.0f, -1);
-
-        [FormerlySerializedAs("inferenceConfiguration")]
-        [SerializeField]
-        [Tooltip("The engine-level settings which correspond to rendering " +
-            "quality and engine speed during Inference.")]
-        EnvironmentConfiguration m_InferenceConfiguration =
-            new EnvironmentConfiguration(1280, 720, 5, 1.0f, 60);
-
-        /// <summary>
-        /// Contains a mapping from parameter names to float values. They are
-        /// used in <see cref="AcademyReset"/> and <see cref="AcademyStep"/>
-        /// to modify elements in the environment at reset time.
-        /// </summary>
-        /// <remarks>
-        /// Default reset parameters are specified in the academy Editor, and can
-        /// be modified when training by passing a config
-        /// dictionary at reset.
-        /// </remarks>
-        [SerializeField]
-        [Tooltip("List of custom parameters that can be changed in the " +
-            "environment when it resets.")]
-        public ResetParameters resetParameters;
-
-        public CommunicatorObjects.CustomResetParametersProto customResetParameters;
 
         // Fields not provided in the Inspector.
 
             get { return Communicator != null; }
         }
 
-        /// If true, the Academy will use inference settings. This field is
-        /// initialized in <see cref="Awake"/> depending on the presence
-        /// or absence of a communicator. Furthermore, it can be modified during
-        /// training via <see cref="SetIsInference"/>.
-        bool m_IsInference = true;
-
         /// The number of episodes completed by the environment. Incremented
         /// each time the environment is reset.
         int m_EpisodeCount;
         /// The number of total number of steps completed during the whole simulation. Incremented
         /// each time a step is taken in the environment.
         int m_TotalStepCount;
-
-        /// Flag that indicates whether the inference/training mode of the
-        /// environment was switched by the training process. This impacts the
-        /// engine settings at the next environment step.
-        bool m_ModeSwitched;
 
         /// Pointer to the communicator currently in use by the Academy.
         public ICommunicator Communicator;
             m_OriginalFixedDeltaTime = Time.fixedDeltaTime;
             m_OriginalMaximumDeltaTime = Time.maximumDeltaTime;
 
-            InitializeAcademy();
+            InitializeAcademy();
+
 
             // Try to launch the communicator by using the arguments passed at launch
             try
 
             if (Communicator != null)
             {
+                Communicator.RegisterSideChannel(new EngineConfigurationChannel());
+                Communicator.RegisterSideChannel(floatProperties);
                 // We try to exchange the first message with Python. If this fails, it means
                 // no Python Process is ready to train the environment. In this case, the
                 //environment must use Inference.
                         {
                             version = k_ApiVersion,
                             name = gameObject.name,
-                            environmentResetParameters = new EnvironmentResetParameters
-                            {
-                                resetParameters = resetParameters,
-                                customResetParameters = customResetParameters
-                            }
                         });
                     Random.InitState(unityRLInitParameters.seed);
                 }
                 {
                     Communicator.QuitCommandReceived += OnQuitCommandReceived;
                     Communicator.ResetCommandReceived += OnResetCommand;
-                    Communicator.RLInputReceived += OnRLInputReceived;
-                    Communicator.RegisterSideChannel(new EngineConfigurationChannel());
-                    Communicator.RegisterSideChannel(floatProperties);
                 }
             }
 
 
-            SetIsInference(!IsCommunicatorOn);
-
             DecideAction += () => { };
             DestroyAction += () => { };
             AgentSetStatus += i => { };
             AgentForceReset += () => { };
 
-            ConfigureEnvironment();
         }
 
         static void OnQuitCommandReceived()
             Application.Quit();
         }
 
-        void OnResetCommand(EnvironmentResetParameters newResetParameters)
+        void OnResetCommand()
-            UpdateResetParameters(newResetParameters);
-        void OnRLInputReceived(UnityRLInputParameters inputParams)
-        {
-            m_IsInference = !inputParams.isTraining;
-        }
-
-        void UpdateResetParameters(EnvironmentResetParameters newResetParameters)
-        {
-            if (newResetParameters.resetParameters != null)
-            {
-                foreach (var kv in newResetParameters.resetParameters)
-                {
-                    resetParameters[kv.Key] = kv.Value;
-                }
-            }
-            customResetParameters = newResetParameters.customResetParameters;
-        }
-
-        /// <summary>
-        /// Configures the environment settings depending on the training/inference
-        /// mode and the corresponding parameters passed in the Editor.
-        /// </summary>
-        void ConfigureEnvironment()
-        {
-            if (m_IsInference)
-            {
-                ConfigureEnvironmentHelper(m_InferenceConfiguration);
-                Monitor.SetActive(true);
-            }
-            else
-            {
-                ConfigureEnvironmentHelper(m_TrainingConfiguration);
-                Monitor.SetActive(false);
-            }
-        }
-
-        /// <summary>
-        /// Helper method for initializing the environment based on the provided
-        /// configuration.
-        /// </summary>
-        /// <param name="config">
-        /// Environment configuration (specified in the Editor).
-        /// </param>
-        static void ConfigureEnvironmentHelper(EnvironmentConfiguration config)
-        {
-            Screen.SetResolution(config.width, config.height, false);
-            QualitySettings.SetQualityLevel(config.qualityLevel, true);
-            Time.timeScale = config.timeScale;
-            Time.captureFramerate = 60;
-            Application.targetFrameRate = config.targetFrameRate;
-        }
-
         /// <summary>
         /// Initializes the academy and environment. Called during the waking-up
         /// phase of the environment before any of the scene objects/agents have
         {
         }
 
-        /// <summary>
-        /// Returns the <see cref="m_IsInference"/> flag.
-        /// </summary>
-        /// <returns>
-        /// <c>true</c>, if current mode is inference, <c>false</c> if training.
-        /// </returns>
-        public bool GetIsInference()
-        {
-            return m_IsInference;
-        }
-
-        /// <summary>
-        /// Sets the <see cref="m_IsInference"/> flag to the provided value. If
-        /// the new flag differs from the current flag value, this signals that
-        /// the environment configuration needs to be updated.
-        /// </summary>
-        /// <param name="isInference">
-        /// Environment mode, if true then inference, otherwise training.
-        /// </param>
-        public void SetIsInference(bool isInference)
-        {
-            if (m_IsInference != isInference)
-            {
-                m_IsInference = isInference;
-
-                // This signals to the academy that at the next environment step
-                // the engine configurations need updating to the respective mode
-                // (i.e. training vs inference) configuration.
-                m_ModeSwitched = true;
-            }
-        }
 
         /// <summary>
         /// Returns the current episode counter.
         /// </summary>
         void EnvironmentStep()
         {
-            if (m_ModeSwitched)
-            {
-                ConfigureEnvironment();
-                m_ModeSwitched = false;
-            }
             if (!m_FirstAcademyReset)
             {
                 ForcedFullReset();

UnitySDK/Assets/ML-Agents/Scripts/Grpc/CommunicatorObjects/UnityRlInitializationOutput.cs

             "CkdtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X3Js",
             "X2luaXRpYWxpemF0aW9uX291dHB1dC5wcm90bxIUY29tbXVuaWNhdG9yX29i",
             "amVjdHMaOW1sYWdlbnRzL2VudnMvY29tbXVuaWNhdG9yX29iamVjdHMvYnJh",
-            "aW5fcGFyYW1ldGVycy5wcm90bxo/bWxhZ2VudHMvZW52cy9jb21tdW5pY2F0",
-            "b3Jfb2JqZWN0cy9lbnZpcm9ubWVudF9wYXJhbWV0ZXJzLnByb3RvIusBCiBV",
-            "bml0eVJMSW5pdGlhbGl6YXRpb25PdXRwdXRQcm90bxIMCgRuYW1lGAEgASgJ",
-            "Eg8KB3ZlcnNpb24YAiABKAkSEAoIbG9nX3BhdGgYAyABKAkSRAoQYnJhaW5f",
-            "cGFyYW1ldGVycxgFIAMoCzIqLmNvbW11bmljYXRvcl9vYmplY3RzLkJyYWlu",
-            "UGFyYW1ldGVyc1Byb3RvElAKFmVudmlyb25tZW50X3BhcmFtZXRlcnMYBiAB",
-            "KAsyMC5jb21tdW5pY2F0b3Jfb2JqZWN0cy5FbnZpcm9ubWVudFBhcmFtZXRl",
-            "cnNQcm90b0IfqgIcTUxBZ2VudHMuQ29tbXVuaWNhdG9yT2JqZWN0c2IGcHJv",
-            "dG8z"));
+            "aW5fcGFyYW1ldGVycy5wcm90byKfAQogVW5pdHlSTEluaXRpYWxpemF0aW9u",
+            "T3V0cHV0UHJvdG8SDAoEbmFtZRgBIAEoCRIPCgd2ZXJzaW9uGAIgASgJEhAK",
+            "CGxvZ19wYXRoGAMgASgJEkQKEGJyYWluX3BhcmFtZXRlcnMYBSADKAsyKi5j",
+            "b21tdW5pY2F0b3Jfb2JqZWN0cy5CcmFpblBhcmFtZXRlcnNQcm90b0oECAYQ",
+            "B0IfqgIcTUxBZ2VudHMuQ29tbXVuaWNhdG9yT2JqZWN0c2IGcHJvdG8z"));
-          new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.BrainParametersReflection.Descriptor, global::MLAgents.CommunicatorObjects.EnvironmentParametersReflection.Descriptor, },
+          new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.BrainParametersReflection.Descriptor, },
-            new pbr::GeneratedClrTypeInfo(typeof(global::MLAgents.CommunicatorObjects.UnityRLInitializationOutputProto), global::MLAgents.CommunicatorObjects.UnityRLInitializationOutputProto.Parser, new[]{ "Name", "Version", "LogPath", "BrainParameters", "EnvironmentParameters" }, null, null, null)
+            new pbr::GeneratedClrTypeInfo(typeof(global::MLAgents.CommunicatorObjects.UnityRLInitializationOutputProto), global::MLAgents.CommunicatorObjects.UnityRLInitializationOutputProto.Parser, new[]{ "Name", "Version", "LogPath", "BrainParameters" }, null, null, null)
           }));
     }
     #endregion
       version_ = other.version_;
       logPath_ = other.logPath_;
       brainParameters_ = other.brainParameters_.Clone();
-      EnvironmentParameters = other.environmentParameters_ != null ? other.EnvironmentParameters.Clone() : null;
       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
     }
 
       get { return brainParameters_; }
     }
 
-    /// <summary>Field number for the "environment_parameters" field.</summary>
-    public const int EnvironmentParametersFieldNumber = 6;
-    private global::MLAgents.CommunicatorObjects.EnvironmentParametersProto environmentParameters_;
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public global::MLAgents.CommunicatorObjects.EnvironmentParametersProto EnvironmentParameters {
-      get { return environmentParameters_; }
-      set {
-        environmentParameters_ = value;
-      }
-    }
-
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override bool Equals(object other) {
       return Equals(other as UnityRLInitializationOutputProto);
       if (Version != other.Version) return false;
       if (LogPath != other.LogPath) return false;
       if(!brainParameters_.Equals(other.brainParameters_)) return false;
-      if (!object.Equals(EnvironmentParameters, other.EnvironmentParameters)) return false;
       return Equals(_unknownFields, other._unknownFields);
     }
 
       if (Version.Length != 0) hash ^= Version.GetHashCode();
       if (LogPath.Length != 0) hash ^= LogPath.GetHashCode();
       hash ^= brainParameters_.GetHashCode();
-      if (environmentParameters_ != null) hash ^= EnvironmentParameters.GetHashCode();
       if (_unknownFields != null) {
         hash ^= _unknownFields.GetHashCode();
       }
         output.WriteString(LogPath);
       }
       brainParameters_.WriteTo(output, _repeated_brainParameters_codec);
-      if (environmentParameters_ != null) {
-        output.WriteRawTag(50);
-        output.WriteMessage(EnvironmentParameters);
-      }
       if (_unknownFields != null) {
         _unknownFields.WriteTo(output);
       }
         size += 1 + pb::CodedOutputStream.ComputeStringSize(LogPath);
       }
       size += brainParameters_.CalculateSize(_repeated_brainParameters_codec);
-      if (environmentParameters_ != null) {
-        size += 1 + pb::CodedOutputStream.ComputeMessageSize(EnvironmentParameters);
-      }
       if (_unknownFields != null) {
         size += _unknownFields.CalculateSize();
       }
         LogPath = other.LogPath;
       }
       brainParameters_.Add(other.brainParameters_);
-      if (other.environmentParameters_ != null) {
-        if (environmentParameters_ == null) {
-          environmentParameters_ = new global::MLAgents.CommunicatorObjects.EnvironmentParametersProto();
-        }
-        EnvironmentParameters.MergeFrom(other.EnvironmentParameters);
-      }
       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
     }
 
           }
           case 42: {
             brainParameters_.AddEntriesFrom(input, _repeated_brainParameters_codec);
-            break;
-          }
-          case 50: {
-            if (environmentParameters_ == null) {
-              environmentParameters_ = new global::MLAgents.CommunicatorObjects.EnvironmentParametersProto();
-            }
-            input.ReadMessage(environmentParameters_);
             break;
           }
         }

UnitySDK/Assets/ML-Agents/Scripts/Grpc/CommunicatorObjects/UnityRlInput.cs

             "CjdtbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL3VuaXR5X3Js",
             "X2lucHV0LnByb3RvEhRjb21tdW5pY2F0b3Jfb2JqZWN0cxo1bWxhZ2VudHMv",
             "ZW52cy9jb21tdW5pY2F0b3Jfb2JqZWN0cy9hZ2VudF9hY3Rpb24ucHJvdG8a",
-            "P21sYWdlbnRzL2VudnMvY29tbXVuaWNhdG9yX29iamVjdHMvZW52aXJvbm1l",
-            "bnRfcGFyYW1ldGVycy5wcm90bxowbWxhZ2VudHMvZW52cy9jb21tdW5pY2F0",
-            "b3Jfb2JqZWN0cy9jb21tYW5kLnByb3RvItkDChFVbml0eVJMSW5wdXRQcm90",
-            "bxJQCg1hZ2VudF9hY3Rpb25zGAEgAygLMjkuY29tbXVuaWNhdG9yX29iamVj",
-            "dHMuVW5pdHlSTElucHV0UHJvdG8uQWdlbnRBY3Rpb25zRW50cnkSUAoWZW52",
-            "aXJvbm1lbnRfcGFyYW1ldGVycxgCIAEoCzIwLmNvbW11bmljYXRvcl9vYmpl",
-            "Y3RzLkVudmlyb25tZW50UGFyYW1ldGVyc1Byb3RvEhMKC2lzX3RyYWluaW5n",
-            "GAMgASgIEjMKB2NvbW1hbmQYBCABKA4yIi5jb21tdW5pY2F0b3Jfb2JqZWN0",
-            "cy5Db21tYW5kUHJvdG8SFAoMc2lkZV9jaGFubmVsGAUgASgMGk0KFExpc3RB",
-            "Z2VudEFjdGlvblByb3RvEjUKBXZhbHVlGAEgAygLMiYuY29tbXVuaWNhdG9y",
-            "X29iamVjdHMuQWdlbnRBY3Rpb25Qcm90bxpxChFBZ2VudEFjdGlvbnNFbnRy",
-            "eRILCgNrZXkYASABKAkSSwoFdmFsdWUYAiABKAsyPC5jb21tdW5pY2F0b3Jf",
-            "b2JqZWN0cy5Vbml0eVJMSW5wdXRQcm90by5MaXN0QWdlbnRBY3Rpb25Qcm90",
-            "bzoCOAFCH6oCHE1MQWdlbnRzLkNvbW11bmljYXRvck9iamVjdHNiBnByb3Rv",
-            "Mw=="));
+            "MG1sYWdlbnRzL2VudnMvY29tbXVuaWNhdG9yX29iamVjdHMvY29tbWFuZC5w",
+            "cm90byL+AgoRVW5pdHlSTElucHV0UHJvdG8SUAoNYWdlbnRfYWN0aW9ucxgB",
+            "IAMoCzI5LmNvbW11bmljYXRvcl9vYmplY3RzLlVuaXR5UkxJbnB1dFByb3Rv",
+            "LkFnZW50QWN0aW9uc0VudHJ5EjMKB2NvbW1hbmQYBCABKA4yIi5jb21tdW5p",
+            "Y2F0b3Jfb2JqZWN0cy5Db21tYW5kUHJvdG8SFAoMc2lkZV9jaGFubmVsGAUg",
+            "ASgMGk0KFExpc3RBZ2VudEFjdGlvblByb3RvEjUKBXZhbHVlGAEgAygLMiYu",
+            "Y29tbXVuaWNhdG9yX29iamVjdHMuQWdlbnRBY3Rpb25Qcm90bxpxChFBZ2Vu",
+            "dEFjdGlvbnNFbnRyeRILCgNrZXkYASABKAkSSwoFdmFsdWUYAiABKAsyPC5j",
+            "b21tdW5pY2F0b3Jfb2JqZWN0cy5Vbml0eVJMSW5wdXRQcm90by5MaXN0QWdl",
+            "bnRBY3Rpb25Qcm90bzoCOAFKBAgCEANKBAgDEARCH6oCHE1MQWdlbnRzLkNv",
+            "bW11bmljYXRvck9iamVjdHNiBnByb3RvMw=="));
-          new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.AgentActionReflection.Descriptor, global::MLAgents.CommunicatorObjects.EnvironmentParametersReflection.Descriptor, global::MLAgents.CommunicatorObjects.CommandReflection.Descriptor, },
+          new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.AgentActionReflection.Descriptor, global::MLAgents.CommunicatorObjects.CommandReflection.Descriptor, },
-            new pbr::GeneratedClrTypeInfo(typeof(global::MLAgents.CommunicatorObjects.UnityRLInputProto), global::MLAgents.CommunicatorObjects.UnityRLInputProto.Parser, new[]{ "AgentActions", "EnvironmentParameters", "IsTraining", "Command", "SideChannel" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::MLAgents.CommunicatorObjects.UnityRLInputProto.Types.ListAgentActionProto), global::MLAgents.CommunicatorObjects.UnityRLInputProto.Types.ListAgentActionProto.Parser, new[]{ "Value" }, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::MLAgents.CommunicatorObjects.UnityRLInputProto), global::MLAgents.CommunicatorObjects.UnityRLInputProto.Parser, new[]{ "AgentActions", "Command", "SideChannel" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::MLAgents.CommunicatorObjects.UnityRLInputProto.Types.ListAgentActionProto), global::MLAgents.CommunicatorObjects.UnityRLInputProto.Types.ListAgentActionProto.Parser, new[]{ "Value" }, null, null, null),
             null, })
           }));
     }
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public UnityRLInputProto(UnityRLInputProto other) : this() {
       agentActions_ = other.agentActions_.Clone();
-      EnvironmentParameters = other.environmentParameters_ != null ? other.EnvironmentParameters.Clone() : null;
-      isTraining_ = other.isTraining_;
       command_ = other.command_;
       sideChannel_ = other.sideChannel_;
       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
       get { return agentActions_; }
     }
 
-    /// <summary>Field number for the "environment_parameters" field.</summary>
-    public const int EnvironmentParametersFieldNumber = 2;
-    private global::MLAgents.CommunicatorObjects.EnvironmentParametersProto environmentParameters_;
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public global::MLAgents.CommunicatorObjects.EnvironmentParametersProto EnvironmentParameters {
-      get { return environmentParameters_; }
-      set {
-        environmentParameters_ = value;
-      }
-    }
-
-    /// <summary>Field number for the "is_training" field.</summary>
-    public const int IsTrainingFieldNumber = 3;
-    private bool isTraining_;
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public bool IsTraining {
-      get { return isTraining_; }
-      set {
-        isTraining_ = value;
-      }
-    }
-
     /// <summary>Field number for the "command" field.</summary>
     public const int CommandFieldNumber = 4;
     private global::MLAgents.CommunicatorObjects.CommandProto command_ = 0;
         return true;
       }
       if (!AgentActions.Equals(other.AgentActions)) return false;
-      if (!object.Equals(EnvironmentParameters, other.EnvironmentParameters)) return false;
-      if (IsTraining != other.IsTraining) return false;
       if (Command != other.Command) return false;
       if (SideChannel != other.SideChannel) return false;
       return Equals(_unknownFields, other._unknownFields);
     public override int GetHashCode() {
       int hash = 1;
       hash ^= AgentActions.GetHashCode();
-      if (environmentParameters_ != null) hash ^= EnvironmentParameters.GetHashCode();
-      if (IsTraining != false) hash ^= IsTraining.GetHashCode();
       if (Command != 0) hash ^= Command.GetHashCode();
       if (SideChannel.Length != 0) hash ^= SideChannel.GetHashCode();
       if (_unknownFields != null) {
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void WriteTo(pb::CodedOutputStream output) {
       agentActions_.WriteTo(output, _map_agentActions_codec);
-      if (environmentParameters_ != null) {
-        output.WriteRawTag(18);
-        output.WriteMessage(EnvironmentParameters);
-      }
-      if (IsTraining != false) {
-        output.WriteRawTag(24);
-        output.WriteBool(IsTraining);
-      }
       if (Command != 0) {
         output.WriteRawTag(32);
         output.WriteEnum((int) Command);
     public int CalculateSize() {
       int size = 0;
       size += agentActions_.CalculateSize(_map_agentActions_codec);
-      if (environmentParameters_ != null) {
-        size += 1 + pb::CodedOutputStream.ComputeMessageSize(EnvironmentParameters);
-      }
-      if (IsTraining != false) {
-        size += 1 + 1;
-      }
       if (Command != 0) {
         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Command);
       }
         return;
       }
       agentActions_.Add(other.agentActions_);
-      if (other.environmentParameters_ != null) {
-        if (environmentParameters_ == null) {
-          environmentParameters_ = new global::MLAgents.CommunicatorObjects.EnvironmentParametersProto();
-        }
-        EnvironmentParameters.MergeFrom(other.EnvironmentParameters);
-      }
-      if (other.IsTraining != false) {
-        IsTraining = other.IsTraining;
-      }
       if (other.Command != 0) {
         Command = other.Command;
       }
             break;
           case 10: {
             agentActions_.AddEntriesFrom(input, _map_agentActions_codec);
-            break;
-          }
-          case 18: {
-            if (environmentParameters_ == null) {
-              environmentParameters_ = new global::MLAgents.CommunicatorObjects.EnvironmentParametersProto();
-            }
-            input.ReadMessage(environmentParameters_);
-            break;
-          }
-          case 24: {
-            IsTraining = input.ReadBool();
             break;
           }
           case 32: {

UnitySDK/Assets/ML-Agents/Scripts/Grpc/GrpcExtensions.cs

             return bp;
         }
 
-        /// <summary>
-        /// Convert a MapField to ResetParameters.
-        /// </summary>
-        /// <param name="floatParams">The mapping of strings to floats from a protobuf MapField.</param>
-        /// <returns></returns>
-        public static ResetParameters ToResetParameters(this MapField<string, float> floatParams)
-        {
-            return new ResetParameters(floatParams);
-        }
-
-        /// <summary>
-        /// Convert an EnvironmnetParametersProto protobuf object to an EnvironmentResetParameters struct.
-        /// </summary>
-        /// <param name="epp">The instance of the EnvironmentParametersProto object.</param>
-        /// <returns>A new EnvironmentResetParameters struct.</returns>
-        public static EnvironmentResetParameters ToEnvironmentResetParameters(this EnvironmentParametersProto epp)
-        {
-            return new EnvironmentResetParameters
-            {
-                resetParameters = epp.FloatParameters?.ToResetParameters(),
-                customResetParameters = epp.CustomResetParameters
-            };
-        }
 
         public static UnityRLInitParameters ToUnityRLInitParameters(this UnityRLInitializationInputProto inputProto)
         {

UnitySDK/Assets/ML-Agents/Scripts/Grpc/RpcCommunicator.cs

     {
         public event QuitCommandHandler QuitCommandReceived;
         public event ResetCommandHandler ResetCommandReceived;
-        public event RLInputReceivedHandler RLInputReceived;
 
         /// If true, the communication is active.
         bool m_IsOpen;
                 Version = initParameters.version
             };
 
-            academyParameters.EnvironmentParameters = new EnvironmentParametersProto();
-
-            var resetParameters = initParameters.environmentResetParameters.resetParameters;
-            foreach (var key in resetParameters.Keys)
-            {
-                academyParameters.EnvironmentParameters.FloatParameters.Add(key, resetParameters[key]);
-            }
-
             UnityInputProto input;
             UnityInputProto initializationInput;
             try
 
         void UpdateEnvironmentWithInput(UnityRLInputProto rlInput)
         {
-            SendRLInputReceivedEvent(rlInput.IsTraining);
-            SendCommandEvent(rlInput.Command, rlInput.EnvironmentParameters);
+            SendCommandEvent(rlInput.Command);
+
         }
 
         UnityInputProto Initialize(UnityOutputProto unityOutput,
 
         #region Sending Events
 
-        void SendCommandEvent(CommandProto command, EnvironmentParametersProto environmentParametersProto)
+        void SendCommandEvent(CommandProto command)
         {
             switch (command)
             {
                     }
                 case CommandProto.Reset:
                     {
-                        ResetCommandReceived?.Invoke(environmentParametersProto.ToEnvironmentResetParameters());
+                        ResetCommandReceived?.Invoke();
                         return;
                     }
                 default:
             }
-        }
-
-        void SendRLInputReceivedEvent(bool isTraining)
-        {
-            RLInputReceived?.Invoke(new UnityRLInputParameters { isTraining = isTraining });
         }
 
         #endregion

UnitySDK/Assets/ML-Agents/Scripts/ICommunicator.cs

 
 namespace MLAgents
 {
-    public struct EnvironmentResetParameters
-    {
-        /// <summary>
-        /// Mapping of string : float which defines which parameters can be
-        /// reset from python.
-        /// </summary>
-        public ResetParameters resetParameters;
-
-        /// <summary>
-        /// The protobuf for custom reset parameters.
-        /// NOTE: This is the last remaining relic of gRPC protocol
-        /// that is left in our code.  We need to decide how to handle this
-        /// moving forward.
-        /// </summary>
-        public CustomResetParametersProto customResetParameters;
-    }
     public struct CommunicatorInitParameters
     {
         /// <summary>
         /// The version of the Unity SDK.
         /// </summary>
         public string version;
-        /// <summary>
-        /// The set of environment parameters defined by the user that will be sent to the communicator.
-        /// </summary>
-        public EnvironmentResetParameters environmentResetParameters;
     }
     public struct UnityRLInitParameters
     {
     /// Delegate for handling reset parameter updates sent from the communicator.
     /// </summary>
     /// <param name="resetParams"></param>
-    public delegate void ResetCommandHandler(EnvironmentResetParameters resetParams);
+    public delegate void ResetCommandHandler();
 
     /// <summary>
     /// Delegate to handle UnityRLInputParameters updates from the communicator.
         /// Reset command sent back from the communicator.
         /// </summary>
         event ResetCommandHandler ResetCommandReceived;
-
-        /// <summary>
-        /// Unity RL Input was received by the communicator.
-        /// </summary>
-        event RLInputReceivedHandler RLInputReceived;
 
         /// <summary>
         /// Sends the academy parameters through the Communicator.

UnitySDK/Assets/ML-Agents/Scripts/SideChannel/EngineConfigurationChannel.cs

                     var timeScale = binaryReader.ReadSingle();
                     var targetFrameRate = binaryReader.ReadInt32();
 
+                    timeScale = Mathf.Clamp(timeScale, 1, 100);
+
                     Screen.SetResolution(width, height, false);
                     QualitySettings.SetQualityLevel(qualityLevel, true);
                     Time.timeScale = timeScale;

docs/Basic-Guide.md

 page](Learning-Environment-Executable.md) for instructions on how to build and
 use an executable.
 
-```console
-ml-agents$ mlagents-learn config/trainer_config.yaml --run-id=first-run --train
-
-
-                        ▄▄▄▓▓▓▓
-                   ╓▓▓▓▓▓▓█▓▓▓▓▓
-              ,▄▄▄m▀▀▀'  ,▓▓▓▀▓▓▄                           ▓▓▓  ▓▓▌
-            ▄▓▓▓▀'      ▄▓▓▀  ▓▓▓      ▄▄     ▄▄ ,▄▄ ▄▄▄▄   ,▄▄ ▄▓▓▌▄ ▄▄▄    ,▄▄
-          ▄▓▓▓▀        ▄▓▓▀   ▐▓▓▌     ▓▓▌   ▐▓▓ ▐▓▓▓▀▀▀▓▓▌ ▓▓▓ ▀▓▓▌▀ ^▓▓▌  ╒▓▓▌
-        ▄▓▓▓▓▓▄▄▄▄▄▄▄▄▓▓▓      ▓▀      ▓▓▌   ▐▓▓ ▐▓▓    ▓▓▓ ▓▓▓  ▓▓▌   ▐▓▓▄ ▓▓▌
-        ▀▓▓▓▓▀▀▀▀▀▀▀▀▀▀▓▓▄     ▓▓      ▓▓▌   ▐▓▓ ▐▓▓    ▓▓▓ ▓▓▓  ▓▓▌    ▐▓▓▐▓▓
-          ^█▓▓▓        ▀▓▓▄   ▐▓▓▌     ▓▓▓▓▄▓▓▓▓ ▐▓▓    ▓▓▓ ▓▓▓  ▓▓▓▄    ▓▓▓▓`
-            '▀▓▓▓▄      ^▓▓▓  ▓▓▓       └▀▀▀▀ ▀▀ ^▀▀    `▀▀ `▀▀   '▀▀    ▐▓▓▌
-               ▀▀▀▀▓▄▄▄   ▓▓▓▓▓▓,                                      ▓▓▓▓▀
-                   `▀█▓▓▓▓▓▓▓▓▓▌
-                        ¬`▀▀▀█▓
-
-
-INFO:mlagents.learn:{'--curriculum': 'None',
- '--docker-target-name': 'Empty',
- '--env': 'None',
- '--help': False,
- '--keep-checkpoints': '5',
- '--lesson': '0',
- '--load': False,
- '--no-graphics': False,
- '--num-runs': '1',
- '--run-id': 'first-run',
- '--save-freq': '50000',
- '--seed': '-1',
- '--slow': False,
- '--train': True,
- '--worker-id': '0',
- '<trainer-config-path>': 'config/trainer_config.yaml'}
-INFO:mlagents.envs:Start training by pressing the Play button in the Unity Editor.
- ```
-
 **Note**: If you're using Anaconda, don't forget to activate the ml-agents
 environment first.
 
 INFO:mlagents.envs:
 'Ball3DAcademy' started successfully!
 Unity Academy name: Ball3DAcademy
-        Reset Parameters : {}
 
 INFO:mlagents.envs:Connected new brain:
 Unity brain name: 3DBallLearning

docs/FAQ.md

 # Frequently Asked Questions
 
+## Installation problems
+
+### Tensorflow dependency
+ML Agents requires TensorFlow; if you don't already have it installed, `pip` will try to install it when you install
+the ml-agents package.
+
+If you see a message like this
+```console
+ERROR: Could not find a version that satisfies the requirement tensorflow<2.0,>=1.7 (from mlagents) (from versions: none)
+ERROR: No matching distribution found for tensorflow<2.0,>=1.7 (from mlagents)
+```
+it means that there is no version of TensorFlow for your python environment. Some known potential causes are:
+ * You're using 32-bit python instead of 64-bit. See the answer [here](https://stackoverflow.com/a/1405971/224264)
+  for how to tell which you have installed.
+ * You're using python 3.8. Tensorflow plans to release packages for this as soon as possible; see
+  [this issue](https://github.com/tensorflow/tensorflow/issues/33374) for more details.
+ * You have the `tensorflow-gpu` package installed. This is equivalent to `tensorflow`, however `pip` doesn't recognize
+  this. The best way to resolve this is to update to `tensorflow==1.15.0` which provides GPU support in the same package
+  (see the [release notes](https://github.com/tensorflow/tensorflow/issues/33374) for more details.)
+ * You're on another architecture (e.g. ARM) which requires vendor provided packages.
+
+In all of these cases, the issue is a pip/python environment setup issue.  Please search the tensorflow github issues
+for similar problems and solutions before creating a new issue.
+
 ## Scripting Runtime Environment not setup correctly
 
 If you haven't switched your scripting runtime version from .NET 3.5 to .NET 4.6
 ## Problems with training on AWS
 
 Please refer to [Training on Amazon Web Service FAQ](Training-on-Amazon-Web-Service.md#faq)
+
+# Known Issues
+
+## Release 0.10.0
+* ml-agents 0.10.0 and earlier were incompatible with TensorFlow 1.15.0; the graph could contain
+ an operator that `tensorflow_to_barracuda` didn't handle. This was fixed in the 0.11.0 release.

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

 
 ### Academy
 
-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.
-The **Training Configuration** 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 would set a low graphics quality and timescale to greater `1.0` for the **Training
-Configuration** and a high graphics quality and timescale to `1.0` for the
-**Inference Configuration** .
-
-**Note:** if you want to observe the environment during training, you can adjust
-the **Training 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 is the Academy implementation. Since
+The Academy object for the scene is placed on the Ball3DAcademy GameObject. 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:
 
 To summarize, go to your command line, enter the `ml-agents` directory and type:
 
 ```sh
-mlagents-learn config/trainer_config.yaml --run-id=<run-identifier> --train
+mlagents-learn config/trainer_config.yaml --run-id=<run-identifier> --train --time-scale=100
 ```
 
 When the message _"Start training by pressing the Play button in the Unity
 environment first.
 
 The `--train` flag tells the ML-Agents toolkit to run in training mode.
+The `--time-scale=100` sets the `Time.TimeScale` value in Unity.
 
 **Note**: You can train using an executable rather than the Editor. To do so,
 follow the instructions in

docs/Installation-Windows.md

 Conda environment by typing `activate ml-agents`)_:
 
 ```sh
-git clone https://github.com/Unity-Technologies/ml-agents.git
+git clone --branch latest_release https://github.com/Unity-Technologies/ml-agents.git
+The `--branch latest_release` option will switch to the tag of the latest stable release.
+Omitting that will get the `master` branch which is potentially unstable.
-[here](https://github.com/Unity-Technologies/ml-agents/archive/master.zip).
+[here](https://github.com/Unity-Technologies/ml-agents/archive/latest_release.zip).
 
 The `UnitySDK` subdirectory contains the Unity Assets to add to your projects.
 It also contains many [example environments](Learning-Environment-Examples.md)

docs/Installation.md

 Once installed, you will want to clone the ML-Agents Toolkit GitHub repository.
 
 ```sh
-git clone https://github.com/Unity-Technologies/ml-agents.git
+git clone --branch latest_release https://github.com/Unity-Technologies/ml-agents.git
+The `--branch latest_release` option will switch to the tag of the latest stable release.
+Omitting that will get the `master` branch which is potentially unstable.
+
+### Package Installation
+
+If you intend to copy the `UnitySDK` folder in to your project, ensure that
+you have the [Barracuda preview package](https://docs.unity3d.com/Packages/com.unity.barracuda@0.3/manual/index.html) installed.
+
+To install the Barracuda package in Unity **2017.4.x**, you will have to copy the
+`UnityPackageManager` folder under the `UnitySDK` folder to the root directory of your
+project.
+
+To install the Barrcuda package in later versions of Unity, navigate to the Package
+Manager window by navigating to the menu `Window` -> `Package Manager`.  Click on the
+`Adavanced` dropdown menu to the left of the search bar and make sure "Show Preview Packages"
+is checked.  Search for or select the `Barracuda` package and install the latest version.
+
+<p align="center">
+  <img src="images/barracuda-package.png"
+       alt="Barracuda Package Manager"
+       width="710" border="10"
+       height="569" />
+</p>
 
 The `ml-agents` subdirectory contains a Python package which provides deep reinforcement
 learning trainers to use with Unity environments.

docs/Learning-Environment-Create-New.md

     calculate the rewards used for reinforcement training. You can also implement
     optional methods to reset the Agent when it has finished or failed its task.
 4. Add your Agent subclasses to appropriate GameObjects, typically, the object
-    in the scene that represents the Agent in the simulation. Each Agent object
-    must be assigned a Brain object.
+    in the scene that represents the Agent in the simulation.
 
 **Note:** If you are unfamiliar with Unity, refer to
 [Learning the interface](https://docs.unity3d.com/Manual/LearningtheInterface.html)

docs/Learning-Environment-Design-Academy.md

 you want to add elements to the environment at random intervals, you can put the
 logic for creating them in the `AcademyStep()` function.
 
-## Academy Properties
-
-![Academy Inspector](images/academy.png)
-* `Configuration` - The engine-level settings which correspond to rendering
-  quality and engine speed.
-  * `Width` - Width of the environment window in pixels.
-  * `Height` - Height of the environment window in pixels.
-  * `Quality Level` - Rendering quality of environment. (Higher is better)
-  * `Time Scale` - Speed at which environment is run. (Higher is faster)
-  * `Target Frame Rate` - FPS engine attempts to maintain.
-* `Reset Parameters` - List of custom parameters that can be changed in the
-  environment on reset.

docs/Learning-Environment-Design.md

 efficient and practical to create a purpose-built training scene.
 
 Both training and testing (or normal game) scenes must contain an Academy object
-to control the agent decision making process. The Academy defines several
-properties that can be set differently for a training scene versus a regular
-scene. The Academy's **Configuration** properties control rendering and time
-scale. You can set the **Training Configuration** to minimize the time Unity
-spends rendering graphics in order to speed up training.
+to control the agent decision making process.
 When you create a training environment in Unity, you must set up the scene so
 that it can be controlled by the external training process. Considerations
 include:

docs/Learning-Environment-Examples.md

   * Vector Action space: (Discrete) Two possible actions (Move left, move
     right).
   * Visual Observations: None
-* Reset Parameters: None
+* Float Properties: None
 * Benchmark Mean Reward: 0.94
 
 ## [3DBall: 3D Balance Ball](https://youtu.be/dheeCO29-EI)
   * Vector Action space: (Continuous) Size of 2, with one value corresponding to
     X-rotation, and the other to Z-rotation.
   * Visual Observations: None.
-* Reset Parameters: Three
+* Float Properties: Three
     * scale: Specifies the scale of the ball in the 3 dimensions (equal across the three dimensions)
       * Default: 1
       * Recommended Minimum: 0.2
     using the `Mask Actions` checkbox within the `trueAgent` GameObject).
     The trained model file provided was generated with action masking turned on.
   * Visual Observations: One corresponding to top-down view of GridWorld.
-* Reset Parameters: Three, corresponding to grid size, number of obstacles, and
+* Float Properties: Three, corresponding to grid size, number of obstacles, and
   number of goals.
 * Benchmark Mean Reward: 0.8
 
   * Vector Action space: (Continuous) Size of 2, corresponding to movement
     toward net or away from net, and jumping.
   * Visual Observations: None
-* Reset Parameters: Three
+* Float Properties: Three
     * angle: Angle of the racket from the vertical (Y) axis.
       * Default: 55
       * Recommended Minimum: 35
     `VisualPushBlock` scene. __The visual observation version of
      this environment does not train with the provided default
      training parameters.__
-* Reset Parameters: Four
+* Float Properties: Four
     * block_scale: Scale of the block along the x and z dimensions
         * Default: 2
         * Recommended Minimum: 0.5
     * Side Motion (3 possible actions: Left, Right, No Action)
     * Jump (2 possible actions: Jump, No Action)
   * Visual Observations: None
-* Reset Parameters: Four
+* Float Properties: Four
 * Benchmark Mean Reward (Big & Small Wall): 0.8
 
 ## [Reacher](https://youtu.be/2N9EoF6pQyE)
   * Vector Action space: (Continuous) Size of 4, corresponding to torque
     applicable to two joints.
   * Visual Observations: None.
-* Reset Parameters: Five
+* Float Properties: Five
   * goal_size: radius of the goal zone
     * Default: 5
     * Recommended Minimum: 1
   * Vector Action space: (Continuous) Size of 20, corresponding to target
     rotations for joints.
   * Visual Observations: None
-* Reset Parameters: None
+* Float Properties: None
 * Benchmark Mean Reward for `CrawlerStaticTarget`: 2000
 * Benchmark Mean Reward for `CrawlerDynamicTarget`: 400
 
     `VisualFoodCollector` scene. __The visual observation version of
      this environment does not train with the provided default
      training parameters.__
-* Reset Parameters: Two
+* Float Properties: Two
   * laser_length: Length of the laser used by the agent
     * Default: 1
     * Recommended Minimum: 0.2
     `VisualHallway` scene. __The visual observation version of
      this environment does not train with the provided default
      training parameters.__
-* Reset Parameters: None
+* Float Properties: None
 * Benchmark Mean Reward: 0.7
   * To speed up training, you can enable curiosity by adding `use_curiosity: true` in `config/trainer_config.yaml`
 
   * Vector Action space: (Continuous) 3 corresponding to agent force applied for
     the jump.
   * Visual Observations: None
-* Reset Parameters: Two
+* Float Properties: Two
     * target_scale: The scale of the green cube in the 3 dimensions
         * Default: 150
         * Recommended Minimum: 50
       as well as rotation.
     * Goalie: 4 actions corresponding to forward, backward, sideways movement.
   * Visual Observations: None
-* Reset Parameters: Two
+* Float Properties: Two
   * ball_scale: Specifies the scale of the ball in the 3 dimensions (equal across the three dimensions)
     * Default: 7.5
     * Recommended minimum: 4
   * Vector Action space: (Continuous) Size of 39, corresponding to target
     rotations applicable to the joints.
   * Visual Observations: None
-* Reset Parameters: Four
+* Float Properties: Four
     * gravity: Magnitude of gravity
         * Default: 9.81
         * Recommended Minimum:
     `VisualPyramids` scene. __The visual observation version of
      this environment does not train with the provided default
      training parameters.__
-* Reset Parameters: None
+* Float Properties: None
 * Benchmark Mean Reward: 1.75

docs/Learning-Environment-Executable.md

                    `▀█▓▓▓▓▓▓▓▓▓▌
                         ¬`▀▀▀█▓
 
-
-INFO:mlagents.learn:{'--curriculum': 'None',
- '--docker-target-name': 'Empty',
- '--env': '3DBall',
- '--help': False,
- '--keep-checkpoints': '5',
- '--lesson': '0',
- '--load': False,
- '--no-graphics': False,
- '--num-runs': '1',
- '--run-id': 'firstRun',
- '--save-freq': '50000',
- '--seed': '-1',
- '--slow': False,
- '--train': True,
- '--worker-id': '0',
- '<trainer-config-path>': 'config/trainer_config.yaml'}
 ```
 
 **Note**: If you're using Anaconda, don't forget to activate the ml-agents
 INFO:mlagents.envs:
 'Ball3DAcademy' started successfully!
 Unity Academy name: Ball3DAcademy
-        Reset Parameters : {}
 
 INFO:mlagents.envs:Connected new brain:
 Unity brain name: Ball3DLearning

docs/Migrating.md

+# Upgrading
+## :warning: Warning :warning:
+The C# editor code and python trainer code are not compatible between releases. This means that if you upgrade one, you *must* upgrade the other as well. If you experience new errors or unable to connect to training after updating, please double-check that the versions are in the same.
+The versions can be found in
+* `Academy.k_ApiVersion` in Academy.cs ([example](https://github.com/Unity-Technologies/ml-agents/blob/b255661084cb8f701c716b040693069a3fb9a257/UnitySDK/Assets/ML-Agents/Scripts/Academy.cs#L95))
+* `UnityEnvironment.API_VERSION` in environment.py ([example](https://github.com/Unity-Technologies/ml-agents/blob/b255661084cb8f701c716b040693069a3fb9a257/ml-agents-envs/mlagents/envs/environment.py#L45))
+
+## Migrating from master to develop
+
+### Important changes
+* `CustomResetParameters` are now removed.
+* `reset()` on the Low-Level Python API no longer takes a `train_mode` argument. To modify the performance/speed of the engine, you must use an `EngineConfigurationChannel`
+* `reset()` on the Low-Level Python API no longer takes a `config` argument. `UnityEnvironment` no longer has a `reset_parameters` field. To modify float properties in the environment, you must use a `FloatPropertiesChannel`. For more information, refer to the [Low Level Python API documentation](Python-API.md)
+* The Academy no longer has a `Training Configuration` nor `Inference Configuration` field in the inspector. To modify the configuration from the Low-Level Python API, use an `EngineConfigurationChannel`. To modify it during training, use the new command line arguments `--width`, `--height`, `--quality-level`, `--time-scale` and `--target-frame-rate` in `mlagents-learn`.
+* The Academy no longer has a `Default Reset Parameters` field in the inspector. The Academy class no longer has a `ResetParameters`. To access shared float properties with Python, use the new `FloatProperties` field on the Academy.
+
+### Steps to Migrate
+ * If you had a custom `Training Configuration` in the Academy inspector, you will need to pass your custom configuration at every training run using the new command line arguments `--width`, `--height`, `--quality-level`, `--time-scale` and `--target-frame-rate`.
+ * If you were using `--slow` in `mlagents-learn`, you will need to pass your old `Inference Configuration` of the Academy inspector with the new command line arguments `--width`, `--height`, `--quality-level`, `--time-scale` and `--target-frame-rate` instead.
+
 ## Migrating from ML-Agents toolkit v0.11.0 to v0.12.0
 
 ### Important Changes
   * `Default` corresponds to the previous unchecked behavior, meaning that Agents will train if they connect to a python trainer, otherwise they will performance inference.
   * `Heuristic Only` means the Agent will always use the `Heuristic()` method. This corresponds to having "Use Heuristic" selected in 0.11.0.
   * `Inference Only` means the Agent will always perform inference.
+* Barracuda was upgraded to 0.3.2, and it is now installed via the Unity Package Manager.
 
 ### Steps to Migrate
 * We [fixed a bug](https://github.com/Unity-Technologies/ml-agents/pull/2823) in `RayPerception3d.Perceive()` that was causing the `endOffset` to be used incorrectly. However this may produce different behavior from previous versions if you use a non-zero `startOffset`. To reproduce the old behavior, you should increase the the value of `endOffset` by `startOffset`. You can verify your raycasts are performing as expected in scene view using the debug rays.
+* If you see messages such as `The type or namespace 'Barracuda' could not be found` or `The type or namespace 'Google' could not be found`, you will need to [install the Barracuda preview package](Installation.md#package-installation).
 
 ## Migrating from ML-Agents toolkit v0.10 to v0.11.0
 

docs/Python-API.md

 - **Print : `print(str(env))`**
   Prints all parameters relevant to the loaded environment and the
   Brains.
-- **Reset : `env.reset(train_mode=True, config=None)`**
+- **Reset : `env.reset()`**
-  - `train_mode` 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 window in the Unity
-    Editor.
 - **Step : `env.step(action)`**
   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
 - **Close : `env.close()`**
   Sends a shutdown signal to the environment and closes the communication
   socket.
+
+### Modifying the environment from Python
+The Environment can be modified by using side channels to send data to the
+environment. When creating the environment, pass a list of side channels as
+`side_channels` argument to the constructor.
+
+__Note__ : A side channel will only send/receive messages when `env.step` is
+called.
+
+#### EngineConfigurationChannel
+An `EngineConfiguration` will allow you to modify the time scale and graphics quality of the Unity engine.
+`EngineConfigurationChannel` has two methods :
+
+ * `set_configuration_parameters` with arguments
+   * width: Defines the width of the display. Default 80.
+   * height: Defines the height of the display. Default 80.
+   * quality_level: Defines the quality level of the simulation. Default 1.
+   * time_scale: Defines the multiplier for the deltatime in the simulation. If set to a higher value, time will pass faster in the simulation but the physics might break. Default 20.
+   *  target_frame_rate: Instructs simulation to try to render at a specified frame rate. Default -1.
+ * `set_configuration` with argument config which is an `EngineConfig`
+ NamedTuple object.
+
+For example :
+```python
+from mlagents.envs.environment import UnityEnvironment
+from mlagents.envs.side_channel.engine_configuration_channel import EngineConfigurationChannel
+
+channel = EngineConfigurationChannel()
+
+env = UnityEnvironment(base_port = 5004, side_channels = [channel])
+
+channel.set_configuration_parameters(time_scale = 2.0)
+
+i = env.reset()
+...
+```
+
+#### FloatPropertiesChannel
+A `FloatPropertiesChannel` will allow you to get and set float properties
+in the environment. You can call get_property and set_property on the
+side channel to read and write properties.
+`FloatPropertiesChannel` has three methods:
+
+ * `set_property` Sets a property in the Unity Environment.
+  * key: The string identifier of the property.
+  * value: The float value of the property.
+ * `get_property` Gets a property in the Unity Environment. If the property was not found, will return None.
+  * key: The string identifier of the property.
+ * `list_properties` Returns a list of all the string identifiers of the properties
+
+```python
+from mlagents.envs.environment import UnityEnvironment
+from mlagents.envs.side_channel.float_properties_channel import FloatPropertiesChannel
+
+channel = FloatPropertiesChannel()
+
+env = UnityEnvironment(base_port = 5004, side_channels = [channel])
+
+channel.set_property("parameter_1", 2.0)
+
+i = env.reset()
+...
+```
+
+Once a property has been modified in Python, you can access it in C# after the next call to `step` as follows:
+
+```csharp
+var academy = FindObjectOfType<Academy>();
+var sharedProperties = academy.FloatProperties;
+float property1 = sharedProperties.GetPropertyWithDefault("parameter_1", 0.0f);
+```
 
 ## mlagents-learn
 

docs/Training-Curriculum-Learning.md

 
 In order to define a curriculum, the first step is to decide which parameters of
 the environment will vary. In the case of the Wall Jump environment, what varies
-is the height of the wall. We define this as a `Reset Parameter` in the Academy
-object of our scene, and by doing so it becomes adjustable via the Python API.
+is the height of the wall. We define this as a `Shared Float Property` that
+can be accessed in `Academy.FloatProperties`, and by doing so it becomes
+adjustable via the Python API.
 Rather than adjusting it by hand, we will create a JSON file which
 describes the structure of the curriculum. Within it, we can specify which
 points in the training process our wall height will change, either based on the

docs/Training-Generalized-Reinforcement-Learning-Agents.md

 
 ## Introducing Generalization Using Reset Parameters
 
-To enable variations in the environments, we implemented `Reset Parameters`. We
+To enable variations in the environments, we implemented `Reset Parameters`.
+`Reset Parameters` are `Academy.FloatProperties` that are used only when
+resetting the environment. We
 also included different sampling methods and the ability to create new kinds of
 sampling methods for each `Reset Parameter`. In the 3D ball environment example displayed
 in the figure above, the reset parameters are `gravity`, `ball_mass` and `ball_scale`.

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 Learning Brain type in your Unity
-project to decide the best course of action for an agent.
+can set the generated model file in the Behaviors Parameters under your
+Agent in your Unity project to decide the best course of action for an agent.
 
 Use the command `mlagents-learn` to train your agents. This command is installed
 with the `mlagents` package and its implementation can be found at
-each Brain.
+each Behavior.
 
 For a broader overview of reinforcement learning, imitation learning and the
 ML-Agents training process, see [ML-Agents Toolkit
   will use the port `(base_port + worker_id)`, where the `worker_id` is sequential IDs
   given to each instance from 0 to `num_envs - 1`. Default is 5005. __Note:__ When
   training using the Editor rather than an executable, the base port will be ignored.
-* `--slow`: Specify this option to run the Unity environment at normal, game
-  speed. The `--slow` mode uses the **Time Scale** and **Target Frame Rate**
-  specified in the Academy's **Inference Configuration**. By default, training
-  runs using the speeds specified in your Academy's **Training Configuration**.
-  See
-  [Academy Properties](Learning-Environment-Design-Academy.md#academy-properties).
 * `--train`: Specifies whether to train model or only run in inference mode.
   When training, **always** use the `--train` option.
 * `--load`: If set, the training code loads an already trained model to
 * `--debug`: Specify this option to enable debug-level logging for some parts of the code.
 * `--multi-gpu`: Setting this flag enables the use of multiple GPU's (if available) during training.
 * `--cpu`: Forces training using CPU only.
+* Engine Configuration :
+  * `--width' : The width of the executable window of the environment(s) in pixels
+  (ignored for editor training) (Default 84)
+  * `--height` : The height of the executable window of the environment(s) in pixels
+  (ignored for editor training). (Default 84)
+  * `--quality-level` : The quality level of the environment(s). Equivalent to
+  calling `QualitySettings.SetQualityLevel` in Unity. (Default 5)
+  * `--time-scale` : The time scale of the Unity environment(s). Equivalent to setting
+  `Time.timeScale` in Unity. (Default 20.0, maximum 100.0)
+  * `--target-frame-rate` : The target frame rate of the Unity environment(s).
+  Equivalent to setting `Application.targetFrameRate` in Unity. (Default: -1)
 
 ### Training Config File
 

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

 2. Clone the ML-Agents repo and install the required Python packages
 
     ```sh
-    git clone https://github.com/Unity-Technologies/ml-agents.git
+    git clone --branch latest_release https://github.com/Unity-Technologies/ml-agents.git
     cd ml-agents/ml-agents/
     pip3 install -e .
     ```

ml-agents-envs/mlagents/envs/base_unity_environment.py

 from abc import ABC, abstractmethod
-from typing import Dict, Optional, Any
+from typing import Dict, Optional
 
 from mlagents.envs.brain import AllBrainInfo, BrainParameters
 
         pass
 
     @abstractmethod
-    def reset(
-        self,
-        config: Optional[Dict] = None,
-        train_mode: bool = True,
-        custom_reset_parameters: Any = None,
-    ) -> AllBrainInfo:
+    def reset(self) -> AllBrainInfo:
-        pass
-
-    @property
-    @abstractmethod
-    def reset_parameters(self) -> Dict[str, float]:
         pass
 
     @abstractmethod

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

 
 
 from mlagents.envs.communicator_objects import brain_parameters_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_brain__parameters__pb2
-from mlagents.envs.communicator_objects import environment_parameters_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__pb2
 
 
 DESCRIPTOR = _descriptor.FileDescriptor(
-  serialized_pb=_b('\nGmlagents/envs/communicator_objects/unity_rl_initialization_output.proto\x12\x14\x63ommunicator_objects\x1a\x39mlagents/envs/communicator_objects/brain_parameters.proto\x1a?mlagents/envs/communicator_objects/environment_parameters.proto\"\xeb\x01\n UnityRLInitializationOutputProto\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_pb=_b('\nGmlagents/envs/communicator_objects/unity_rl_initialization_output.proto\x12\x14\x63ommunicator_objects\x1a\x39mlagents/envs/communicator_objects/brain_parameters.proto\"\x9f\x01\n UnityRLInitializationOutputProto\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.BrainParametersProtoJ\x04\x08\x06\x10\x07\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_brain__parameters__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_brain__parameters__pb2.DESCRIPTOR,])
 
 
 
       message_type=None, enum_type=None, containing_type=None,
       is_extension=False, extension_scope=None,
       options=None, file=DESCRIPTOR),
-    _descriptor.FieldDescriptor(
-      name='environment_parameters', full_name='communicator_objects.UnityRLInitializationOutputProto.environment_parameters', index=4,
-      number=6, type=11, cpp_type=10, label=1,
-      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),
   ],
   extensions=[
   ],
   extension_ranges=[],
   oneofs=[
   ],
-  serialized_start=222,
-  serialized_end=457,
+  serialized_start=157,
+  serialized_end=316,
-_UNITYRLINITIALIZATIONOUTPUTPROTO.fields_by_name['environment_parameters'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__pb2._ENVIRONMENTPARAMETERSPROTO
 DESCRIPTOR.message_types_by_name['UnityRLInitializationOutputProto'] = _UNITYRLINITIALIZATIONOUTPUTPROTO
 _sym_db.RegisterFileDescriptor(DESCRIPTOR)
 

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

     BrainParametersProto as mlagents___envs___communicator_objects___brain_parameters_pb2___BrainParametersProto,
 )
 
-from mlagents.envs.communicator_objects.environment_parameters_pb2 import (
-    EnvironmentParametersProto as mlagents___envs___communicator_objects___environment_parameters_pb2___EnvironmentParametersProto,
-)
-
 from typing import (
     Iterable as typing___Iterable,
     Optional as typing___Optional,
     @property
     def brain_parameters(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[mlagents___envs___communicator_objects___brain_parameters_pb2___BrainParametersProto]: ...
 
-    @property
-    def environment_parameters(self) -> mlagents___envs___communicator_objects___environment_parameters_pb2___EnvironmentParametersProto: ...
-
     def __init__(self,
         *,
         name : typing___Optional[typing___Text] = None,
-        environment_parameters : typing___Optional[mlagents___envs___communicator_objects___environment_parameters_pb2___EnvironmentParametersProto] = None,
         ) -> None: ...
     @classmethod
     def FromString(cls, s: builtin___bytes) -> UnityRLInitializationOutputProto: ...
-        def HasField(self, field_name: typing_extensions___Literal[u"environment_parameters"]) -> builtin___bool: ...
-        def ClearField(self, field_name: typing_extensions___Literal[u"brain_parameters",u"environment_parameters",u"log_path",u"name",u"version"]) -> None: ...
+        def ClearField(self, field_name: typing_extensions___Literal[u"brain_parameters",u"log_path",u"name",u"version"]) -> None: ...
-        def HasField(self, field_name: typing_extensions___Literal[u"environment_parameters",b"environment_parameters"]) -> builtin___bool: ...
-        def ClearField(self, field_name: typing_extensions___Literal[u"brain_parameters",b"brain_parameters",u"environment_parameters",b"environment_parameters",u"log_path",b"log_path",u"name",b"name",u"version",b"version"]) -> None: ...
+        def ClearField(self, field_name: typing_extensions___Literal[u"brain_parameters",b"brain_parameters",u"log_path",b"log_path",u"name",b"name",u"version",b"version"]) -> None: ...

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

 
 
 from mlagents.envs.communicator_objects import agent_action_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_agent__action__pb2
-from mlagents.envs.communicator_objects import environment_parameters_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__pb2
 from mlagents.envs.communicator_objects import command_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_command__pb2
 
 
   syntax='proto3',
-  serialized_pb=_b('\n7mlagents/envs/communicator_objects/unity_rl_input.proto\x12\x14\x63ommunicator_objects\x1a\x35mlagents/envs/communicator_objects/agent_action.proto\x1a?mlagents/envs/communicator_objects/environment_parameters.proto\x1a\x30mlagents/envs/communicator_objects/command.proto\"\xd9\x03\n\x11UnityRLInputProto\x12P\n\ragent_actions\x18\x01 \x03(\x0b\x32\x39.communicator_objects.UnityRLInputProto.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\x12\x14\n\x0cside_channel\x18\x05 \x01(\x0c\x1aM\n\x14ListAgentActionProto\x12\x35\n\x05value\x18\x01 \x03(\x0b\x32&.communicator_objects.AgentActionProto\x1aq\n\x11\x41gentActionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12K\n\x05value\x18\x02 \x01(\x0b\x32<.communicator_objects.UnityRLInputProto.ListAgentActionProto:\x02\x38\x01\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
+  serialized_pb=_b('\n7mlagents/envs/communicator_objects/unity_rl_input.proto\x12\x14\x63ommunicator_objects\x1a\x35mlagents/envs/communicator_objects/agent_action.proto\x1a\x30mlagents/envs/communicator_objects/command.proto\"\xfe\x02\n\x11UnityRLInputProto\x12P\n\ragent_actions\x18\x01 \x03(\x0b\x32\x39.communicator_objects.UnityRLInputProto.AgentActionsEntry\x12\x33\n\x07\x63ommand\x18\x04 \x01(\x0e\x32\".communicator_objects.CommandProto\x12\x14\n\x0cside_channel\x18\x05 \x01(\x0c\x1aM\n\x14ListAgentActionProto\x12\x35\n\x05value\x18\x01 \x03(\x0b\x32&.communicator_objects.AgentActionProto\x1aq\n\x11\x41gentActionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12K\n\x05value\x18\x02 \x01(\x0b\x32<.communicator_objects.UnityRLInputProto.ListAgentActionProto:\x02\x38\x01J\x04\x08\x02\x10\x03J\x04\x08\x03\x10\x04\x42\x1f\xaa\x02\x1cMLAgents.CommunicatorObjectsb\x06proto3')
-  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_agent__action__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_command__pb2.DESCRIPTOR,])
+  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_agent__action__pb2.DESCRIPTOR,mlagents_dot_envs_dot_communicator__objects_dot_command__pb2.DESCRIPTOR,])
 
 
 
   extension_ranges=[],
   oneofs=[
   ],
-  serialized_start=533,
-  serialized_end=610,
+  serialized_start=365,
+  serialized_end=442,
 )
 
 _UNITYRLINPUTPROTO_AGENTACTIONSENTRY = _descriptor.Descriptor(
   extension_ranges=[],
   oneofs=[
   ],
-  serialized_start=612,
-  serialized_end=725,
+  serialized_start=444,
+  serialized_end=557,
 )
 
 _UNITYRLINPUTPROTO = _descriptor.Descriptor(
       is_extension=False, extension_scope=None,
       options=None, file=DESCRIPTOR),
     _descriptor.FieldDescriptor(
-      name='environment_parameters', full_name='communicator_objects.UnityRLInputProto.environment_parameters', index=1,
-      number=2, type=11, cpp_type=10, label=1,
-      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),
-    _descriptor.FieldDescriptor(
-      name='is_training', full_name='communicator_objects.UnityRLInputProto.is_training', index=2,
-      number=3, type=8, cpp_type=7, label=1,
-      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),
-    _descriptor.FieldDescriptor(
-      name='command', full_name='communicator_objects.UnityRLInputProto.command', index=3,
+      name='command', full_name='communicator_objects.UnityRLInputProto.command', index=1,
       number=4, type=14, cpp_type=8, label=1,
       has_default_value=False, default_value=0,
       message_type=None, enum_type=None, containing_type=None,
-      name='side_channel', full_name='communicator_objects.UnityRLInputProto.side_channel', index=4,
+      name='side_channel', full_name='communicator_objects.UnityRLInputProto.side_channel', index=2,
       number=5, type=12, cpp_type=9, label=1,
       has_default_value=False, default_value=_b(""),
       message_type=None, enum_type=None, containing_type=None,
   extension_ranges=[],
   oneofs=[
   ],
-  serialized_start=252,
-  serialized_end=725,
+  serialized_start=187,
+  serialized_end=569,
 )
 
 _UNITYRLINPUTPROTO_LISTAGENTACTIONPROTO.fields_by_name['value'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_agent__action__pb2._AGENTACTIONPROTO
 _UNITYRLINPUTPROTO.fields_by_name['agent_actions'].message_type = _UNITYRLINPUTPROTO_AGENTACTIONSENTRY
-_UNITYRLINPUTPROTO.fields_by_name['environment_parameters'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_environment__parameters__pb2._ENVIRONMENTPARAMETERSPROTO
 _UNITYRLINPUTPROTO.fields_by_name['command'].enum_type = mlagents_dot_envs_dot_communicator__objects_dot_command__pb2._COMMANDPROTO
 DESCRIPTOR.message_types_by_name['UnityRLInputProto'] = _UNITYRLINPUTPROTO
 _sym_db.RegisterFileDescriptor(DESCRIPTOR)

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

     CommandProto as mlagents___envs___communicator_objects___command_pb2___CommandProto,
 )
 
-from mlagents.envs.communicator_objects.environment_parameters_pb2 import (
-    EnvironmentParametersProto as mlagents___envs___communicator_objects___environment_parameters_pb2___EnvironmentParametersProto,
-)
-
 from typing import (
     Iterable as typing___Iterable,
     Mapping as typing___Mapping,
             def HasField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> builtin___bool: ...
             def ClearField(self, field_name: typing_extensions___Literal[u"key",b"key",u"value",b"value"]) -> None: ...
 
-    is_training = ... # type: builtin___bool
     command = ... # type: mlagents___envs___communicator_objects___command_pb2___CommandProto
     side_channel = ... # type: builtin___bytes
 
-    @property
-    def environment_parameters(self) -> mlagents___envs___communicator_objects___environment_parameters_pb2___EnvironmentParametersProto: ...
-
-        environment_parameters : typing___Optional[mlagents___envs___communicator_objects___environment_parameters_pb2___EnvironmentParametersProto] = None,
-        is_training : typing___Optional[builtin___bool] = None,
         command : typing___Optional[mlagents___envs___communicator_objects___command_pb2___CommandProto] = None,
         side_channel : typing___Optional[builtin___bytes] = None,
         ) -> None: ...
     def CopyFrom(self, other_msg: google___protobuf___message___Message) -> None: ...
     if sys.version_info >= (3,):
-        def HasField(self, field_name: typing_extensions___Literal[u"environment_parameters"]) -> builtin___bool: ...
-        def ClearField(self, field_name: typing_extensions___Literal[u"agent_actions",u"command",u"environment_parameters",u"is_training",u"side_channel"]) -> None: ...
+        def ClearField(self, field_name: typing_extensions___Literal[u"agent_actions",u"command",u"side_channel"]) -> None: ...
-        def HasField(self, field_name: typing_extensions___Literal[u"environment_parameters",b"environment_parameters"]) -> builtin___bool: ...
-        def ClearField(self, field_name: typing_extensions___Literal[u"agent_actions",b"agent_actions",u"command",b"command",u"environment_parameters",b"environment_parameters",u"is_training",b"is_training",u"side_channel",b"side_channel"]) -> None: ...
+        def ClearField(self, field_name: typing_extensions___Literal[u"agent_actions",b"agent_actions",u"command",b"command",u"side_channel",b"side_channel"]) -> None: ...

ml-agents-envs/mlagents/envs/env_manager.py

 from abc import ABC, abstractmethod
-from typing import Any, List, Dict, NamedTuple, Optional
+from typing import List, Dict, NamedTuple, Optional
 from mlagents.envs.brain import AllBrainInfo, BrainParameters
 from mlagents.envs.policy import Policy
 from mlagents.envs.action_info import ActionInfo
         pass
 
     @abstractmethod
-    def reset(
-        self,
-        config: Dict = None,
-        train_mode: bool = True,
-        custom_reset_parameters: Any = None,
-    ) -> List[EnvironmentStep]:
+    def reset(self, config: Dict = None) -> List[EnvironmentStep]:
         pass
 
     @property
 
     @property
     @abstractmethod
-    def reset_parameters(self) -> Dict[str, float]:
+    def get_properties(self) -> Dict[str, float]:
         pass
 
     @abstractmethod

ml-agents-envs/mlagents/envs/environment.py

 from mlagents.envs.communicator_objects.unity_rl_input_pb2 import UnityRLInputProto
 from mlagents.envs.communicator_objects.unity_rl_output_pb2 import UnityRLOutputProto
 from mlagents.envs.communicator_objects.agent_action_pb2 import AgentActionProto
-from mlagents.envs.communicator_objects.environment_parameters_pb2 import (
-    EnvironmentParametersProto,
-)
 from mlagents.envs.communicator_objects.unity_output_pb2 import UnityOutputProto
 from mlagents.envs.communicator_objects.unity_rl_initialization_input_pb2 import (
     UnityRLInitializationInputProto,
         self._external_brain_names: List[str] = []
         self._num_external_brains = 0
         self._update_brain_parameters(aca_output)
-        self._resetParameters = dict(aca_params.environment_parameters.float_parameters)
         logger.info(
             "\n'{0}' started successfully!\n{1}".format(self._academy_name, str(self))
         )
             external_brains[brain_name] = self.brains[brain_name]
         return external_brains
 
-    @property
-    def reset_parameters(self):
-        return self._resetParameters
-
     def executable_launcher(self, file_name, docker_training, no_graphics, args):
         cwd = os.getcwd()
         file_name = (
                 )
 
     def __str__(self):
-        reset_params_str = (
-            "\n\t\t".join(
-                [
-                    str(k) + " -> " + str(self._resetParameters[k])
-                    for k in self._resetParameters
-                ]
-            )
-            if self._resetParameters
-            else "{}"
-        )
-        return f"""Unity Academy name: {self._academy_name}
-        Reset Parameters : {reset_params_str}"""
+        return """Unity Academy name: {0}""".format(self._academy_name)
-    def reset(
-        self,
-        config: Dict = None,
-        train_mode: bool = True,
-        custom_reset_parameters: Any = None,
-    ) -> AllBrainInfo:
+    def reset(self) -> AllBrainInfo:
-        if config is None:
-            config = self._resetParameters
-        elif config:
-            logger.info(
-                "Academy reset with parameters: {0}".format(
-                    ", ".join([str(x) + " -> " + str(config[x]) for x in config])
-                )
-            )
-        for k in config:
-            if (k in self._resetParameters) and (isinstance(config[k], (int, float))):
-                self._resetParameters[k] = config[k]
-            elif not isinstance(config[k], (int, float)):
-                raise UnityEnvironmentException(
-                    "The value for parameter '{0}'' must be an Integer or a Float.".format(
-                        k
-                    )
-                )
-            else:
-                raise UnityEnvironmentException(
-                    "The parameter '{0}' is not a valid parameter.".format(k)
-                )
-
-            outputs = self.communicator.exchange(
-                self._generate_reset_input(train_mode, config, custom_reset_parameters)
-            )
+            outputs = self.communicator.exchange(self._generate_reset_input())
             if outputs is None:
                 raise UnityCommunicationException("Communicator has stopped.")
             self._update_brain_parameters(outputs)
         rl_in.side_channel = bytes(self._generate_side_channel_data(self.side_channels))
         return self.wrap_unity_input(rl_in)
 
-    def _generate_reset_input(
-        self, training: bool, config: Dict, custom_reset_parameters: Any
-    ) -> UnityInputProto:
+    def _generate_reset_input(self) -> UnityInputProto:
-        rl_in.is_training = training
-        rl_in.environment_parameters.CopyFrom(EnvironmentParametersProto())
-        for key in config:
-            rl_in.environment_parameters.float_parameters[key] = config[key]
-        if custom_reset_parameters is not None:
-            rl_in.environment_parameters.custom_reset_parameters.CopyFrom(
-                custom_reset_parameters
-            )
         rl_in.command = 1
         rl_in.side_channel = bytes(self._generate_side_channel_data(self.side_channels))
         return self.wrap_unity_input(rl_in)

ml-agents-envs/mlagents/envs/side_channel/engine_configuration_channel.py

 from mlagents.envs.side_channel.side_channel import SideChannel, SideChannelType
 from mlagents.envs.exception import UnityCommunicationException
 import struct
+from typing import NamedTuple
+
+
+class EngineConfig(NamedTuple):
+    width: int
+    height: int
+    quality_level: int
+    time_scale: float
+    target_frame_rate: int
+
+    @staticmethod
+    def default_config():
+        return EngineConfig(80, 80, 1, 20.0, -1)
 
 
 class EngineConfigurationChannel(SideChannel):
             + "this should not have happend."
         )
 
-    def set_configuration(
+    def set_configuration_parameters(
         self,
         width: int = 80,
         height: int = 80,
         :param quality_level: Defines the quality level of the simulation.
         Default 1.
         :param time_scale: Defines the multiplier for the deltatime in the
-        simulation. If set to a higher value, time will pass faaster in the
+        simulation. If set to a higher value, time will pass faster in the
         simulation but the physics might break. Default 20.
         :param target_frame_rate: Instructs simulation to try to render at a
         specified frame rate. Default -1.
         data += struct.pack("<f", time_scale)
         data += struct.pack("<i", target_frame_rate)
         super().queue_message_to_send(data)
+
+    def set_configuration(self, config: EngineConfig) -> None:
+        """
+        Sets the engine configuration. Takes as input an EngineConfig.
+        """
+        data = bytearray()
+        data += struct.pack("<iiifi", *config)
+        super().queue_message_to_send(data)

ml-agents-envs/mlagents/envs/simple_env_manager.py

-from typing import Any, Dict, List
+from typing import Dict, List
 
 from mlagents.envs.base_unity_environment import BaseUnityEnvironment
 from mlagents.envs.env_manager import EnvManager, EnvironmentStep
+from mlagents.envs.side_channel.float_properties_channel import FloatPropertiesChannel
 
 
 class SimpleEnvManager(EnvManager):
     """
 
-    def __init__(self, env: BaseUnityEnvironment):
+    def __init__(
+        self, env: BaseUnityEnvironment, float_prop_channel: FloatPropertiesChannel
+    ):
+        self.shared_float_properties = float_prop_channel
         self.env = env
         self.previous_step: EnvironmentStep = EnvironmentStep(None, {}, None)
         self.previous_all_action_info: Dict[str, ActionInfo] = {}
         return [step_info]
 
     def reset(
-        self,
-        config: Dict[str, float] = None,
-        train_mode: bool = True,
-        custom_reset_parameters: Any = None,
+        self, config: Dict[str, float] = None
-        all_brain_info = self.env.reset(
-            config=config,
-            train_mode=train_mode,
-            custom_reset_parameters=custom_reset_parameters,
-        )
+        if config is not None:
+            for k, v in config.items():
+                self.shared_float_properties.set_property(k, v)
+        all_brain_info = self.env.reset()
         self.previous_step = EnvironmentStep(None, all_brain_info, None)
         return [self.previous_step]
 
 
     @property
-    def reset_parameters(self) -> Dict[str, float]:
-        return self.env.reset_parameters
+    def get_properties(self) -> Dict[str, float]:
+        reset_params = {}
+        for k in self.shared_float_properties.list_properties():
+            reset_params[k] = self.shared_float_properties.get_property(k)
+        return reset_params
 
     def close(self):
         self.env.close()

ml-agents-envs/mlagents/envs/subprocess_env_manager.py

 )
 from mlagents.envs.brain import AllBrainInfo, BrainParameters
 from mlagents.envs.action_info import ActionInfo
+from mlagents.envs.side_channel.float_properties_channel import FloatPropertiesChannel
+from mlagents.envs.side_channel.engine_configuration_channel import (
+    EngineConfigurationChannel,
+    EngineConfig,
+)
+from mlagents.envs.side_channel.side_channel import SideChannel
 
 logger = logging.getLogger("mlagents.envs")
 
 
 
 def worker(
-    parent_conn: Connection, step_queue: Queue, pickled_env_factory: str, worker_id: int
+    parent_conn: Connection,
+    step_queue: Queue,
+    pickled_env_factory: str,
+    worker_id: int,
+    engine_configuration: EngineConfig,
-    env_factory: Callable[[int], UnityEnvironment] = cloudpickle.loads(
-        pickled_env_factory
+    env_factory: Callable[
+        [int, List[SideChannel]], UnityEnvironment
+    ] = cloudpickle.loads(pickled_env_factory)
+    shared_float_properties = FloatPropertiesChannel()
+    engine_configuration_channel = EngineConfigurationChannel()
+    engine_configuration_channel.set_configuration(engine_configuration)
+    env: BaseUnityEnvironment = env_factory(
+        worker_id, [shared_float_properties, engine_configuration_channel]
-    env: BaseUnityEnvironment = env_factory(worker_id)
 
     def _send_response(cmd_name, payload):
         parent_conn.send(EnvironmentResponse(cmd_name, worker_id, payload))
                 reset_timers()
             elif cmd.name == "external_brains":
                 _send_response("external_brains", env.external_brains)
-            elif cmd.name == "reset_parameters":
-                _send_response("reset_parameters", env.reset_parameters)
+            elif cmd.name == "get_properties":
+                reset_params = {}
+                for k in shared_float_properties.list_properties():
+                    reset_params[k] = shared_float_properties.get_property(k)
+
+                _send_response("get_properties", reset_params)
-                all_brain_info = env.reset(
-                    cmd.payload[0], cmd.payload[1], cmd.payload[2]
-                )
+                for k, v in cmd.payload.items():
+                    shared_float_properties.set_property(k, v)
+                all_brain_info = env.reset()
                 _send_response("reset", all_brain_info)
             elif cmd.name == "close":
                 break
 
 class SubprocessEnvManager(EnvManager):
     def __init__(
-        self, env_factory: Callable[[int], BaseUnityEnvironment], n_env: int = 1
+        self,
+        env_factory: Callable[[int, List[SideChannel]], BaseUnityEnvironment],
+        engine_configuration: EngineConfig,
+        n_env: int = 1,
     ):
         super().__init__()
         self.env_workers: List[UnityEnvWorker] = []
-                self.create_worker(worker_idx, self.step_queue, env_factory)
+                self.create_worker(
+                    worker_idx, self.step_queue, env_factory, engine_configuration
+                )
             )
 
     @staticmethod
-        env_factory: Callable[[int], BaseUnityEnvironment],
+        env_factory: Callable[[int, List[SideChannel]], BaseUnityEnvironment],
+        engine_configuration: EngineConfig,
     ) -> UnityEnvWorker:
         parent_conn, child_conn = Pipe()
 
         child_process = Process(
-            target=worker, args=(child_conn, step_queue, pickled_env_factory, worker_id)
+            target=worker,
+            args=(
+                child_conn,
+                step_queue,
+                pickled_env_factory,
+                worker_id,
+                engine_configuration,
+            ),
         )
         child_process.start()
         return UnityEnvWorker(child_process, worker_id, parent_conn)
         step_infos = self._postprocess_steps(worker_steps)
         return step_infos
 
-    def reset(
-        self,
-        config: Optional[Dict] = None,
-        train_mode: bool = True,
-        custom_reset_parameters: Any = None,
-    ) -> List[EnvironmentStep]:
+    def reset(self, config: Optional[Dict] = None) -> List[EnvironmentStep]:
         while any(ew.waiting for ew in self.env_workers):
             if not self.step_queue.empty():
                 step = self.step_queue.get_nowait()
-            ew.send("reset", (config, train_mode, custom_reset_parameters))
+            ew.send("reset", config)
         # Next (synchronously) collect the reset observations from each worker in sequence
         for ew in self.env_workers:
             ew.previous_step = EnvironmentStep(None, ew.recv().payload, None)
         return self.env_workers[0].recv().payload
 
     @property
-    def reset_parameters(self) -> Dict[str, float]:
-        self.env_workers[0].send("reset_parameters")
+    def get_properties(self) -> Dict[str, float]:
+        self.env_workers[0].send("get_properties")
         return self.env_workers[0].recv().payload
 
     def close(self) -> None:

ml-agents-envs/mlagents/envs/tests/test_subprocess_env_manager.py

     StepResponse,
 )
 from mlagents.envs.base_unity_environment import BaseUnityEnvironment
+from mlagents.envs.side_channel.engine_configuration_channel import EngineConfig
 
 
 def mock_env_factory(worker_id):
 class SubprocessEnvManagerTest(unittest.TestCase):
     def test_environments_are_created(self):
         SubprocessEnvManager.create_worker = MagicMock()
-        env = SubprocessEnvManager(mock_env_factory, 2)
+        env = SubprocessEnvManager(mock_env_factory, EngineConfig.default_config(), 2)
-                mock.call(0, env.step_queue, mock_env_factory),
-                mock.call(1, env.step_queue, mock_env_factory),
+                mock.call(
+                    0, env.step_queue, mock_env_factory, EngineConfig.default_config()
+                ),
+                mock.call(
+                    1, env.step_queue, mock_env_factory, EngineConfig.default_config()
+                ),
-        SubprocessEnvManager.create_worker = lambda em, worker_id, step_queue, env_factory: MockEnvWorker(
+        SubprocessEnvManager.create_worker = lambda em, worker_id, step_queue, env_factory, engine_c: MockEnvWorker(
-        manager = SubprocessEnvManager(mock_env_factory, 1)
+        manager = SubprocessEnvManager(
+            mock_env_factory, EngineConfig.default_config(), 1
+        )
-        manager.reset(params, False)
-        manager.env_workers[0].send.assert_called_with("reset", (params, False, None))
+        manager.reset(params)
+        manager.env_workers[0].send.assert_called_with("reset", (params))
-        SubprocessEnvManager.create_worker = lambda em, worker_id, step_queue, env_factory: MockEnvWorker(
+        SubprocessEnvManager.create_worker = lambda em, worker_id, step_queue, env_factory, engine_c: MockEnvWorker(
-        manager = SubprocessEnvManager(mock_env_factory, 4)
+        manager = SubprocessEnvManager(
+            mock_env_factory, EngineConfig.default_config(), 4
+        )
-            env.send.assert_called_with("reset", (params, True, None))
+            env.send.assert_called_with("reset", (params))
             env.recv.assert_called()
             # Check that the "last steps" are set to the value returned for each step
             self.assertEqual(
 
     def test_step_takes_steps_for_all_non_waiting_envs(self):
-        SubprocessEnvManager.create_worker = lambda em, worker_id, step_queue, env_factory: MockEnvWorker(
+        SubprocessEnvManager.create_worker = lambda em, worker_id, step_queue, env_factory, engine_c: MockEnvWorker(
-        manager = SubprocessEnvManager(mock_env_factory, 3)
+        manager = SubprocessEnvManager(
+            mock_env_factory, EngineConfig.default_config(), 3
+        )
         manager.step_queue = Mock()
         manager.step_queue.get_nowait.side_effect = [
             EnvironmentResponse("step", 0, StepResponse(0, None)),

ml-agents/mlagents/trainers/curriculum.py

 
 
 class Curriculum(object):
-    def __init__(self, location, default_reset_parameters):
+    def __init__(self, location):
-        :param default_reset_parameters: Set of reset parameters for
-               environment.
         """
         self.max_lesson_num = 0
         self.measure = None
 
         parameters = self.data["parameters"]
         for key in parameters:
-            if key not in default_reset_parameters:
-                raise CurriculumConfigError(
-                    "The parameter {0} in Curriculum {1} is not present in "
-                    "the Environment".format(key, location)
-                )
             if len(parameters[key]) != self.max_lesson_num + 1:
                 raise CurriculumConfigError(
                     "The parameter {0} in Curriculum {1} must have {2} values "

ml-agents/mlagents/trainers/learn.py

 from mlagents.envs.exception import SamplerException
 from mlagents.envs.base_unity_environment import BaseUnityEnvironment
 from mlagents.envs.subprocess_env_manager import SubprocessEnvManager
+from mlagents.envs.side_channel.side_channel import SideChannel
+from mlagents.envs.side_channel.engine_configuration_channel import EngineConfig
 
 
 class CommandLineOptions(NamedTuple):
     num_envs: int
     curriculum_folder: Optional[str]
     lesson: int
-    slow: bool
     no_graphics: bool
     multi_gpu: bool  # ?
     trainer_config_path: str
     cpu: bool
-
-    @property
-    def fast_simulation(self) -> bool:
-        return not self.slow
+    width: int
+    height: int
+    quality_level: int
+    time_scale: float
+    target_frame_rate: int
 
     @staticmethod
     def from_argparse(args: Any) -> "CommandLineOptions":
         "--seed", default=-1, type=int, help="Random seed used for training"
     )
     parser.add_argument(
-        "--slow", action="store_true", help="Whether to run the game at training speed"
-    )
-    parser.add_argument(
         "--train",
         default=False,
         dest="train_model",
 
     parser.add_argument("--version", action="version", version=get_version_string())
 
+    eng_conf = parser.add_argument_group(title="Engine Configuration")
+    eng_conf.add_argument(
+        "--width",
+        default=84,
+        type=int,
+        help="The width of the executable window of the environment(s)",
+    )
+    eng_conf.add_argument(
+        "--height",
+        default=84,
+        type=int,
+        help="The height of the executable window of the environment(s)",
+    )
+    eng_conf.add_argument(
+        "--quality-level",
+        default=5,
+        type=int,
+        help="The quality level of the environment(s)",
+    )
+    eng_conf.add_argument(
+        "--time-scale",
+        default=20,
+        type=float,
+        help="The time scale of the Unity environment(s)",
+    )
+    eng_conf.add_argument(
+        "--target-frame-rate",
+        default=-1,
+        type=int,
+        help="The target frame rate of the Unity environment(s)",
+    )
+
     args = parser.parse_args(argv)
     return CommandLineOptions.from_argparse(args)
 
         port,
         options.env_args,
     )
-    env = SubprocessEnvManager(env_factory, options.num_envs)
+    engine_config = EngineConfig(
+        options.width,
+        options.height,
+        options.quality_level,
+        options.time_scale,
+        options.target_frame_rate,
+    )
+    env = SubprocessEnvManager(env_factory, engine_config, options.num_envs)
-        options.sampler_file_path, env.reset_parameters, run_seed
+        options.sampler_file_path, run_seed
     )
     trainer_factory = TrainerFactory(
         trainer_config,
         maybe_meta_curriculum,
         options.train_model,
         run_seed,
-        options.fast_simulation,
         sampler_manager,
         resampling_interval,
     )
     tc.start_learning(env)
 
 
-def create_sampler_manager(sampler_file_path, env_reset_params, run_seed=None):
+def create_sampler_manager(sampler_file_path, run_seed=None):
     sampler_config = None
     resample_interval = None
     if sampler_file_path is not None:
         return None
 
     else:
-        meta_curriculum = MetaCurriculum(curriculum_folder, env.reset_parameters)
+        meta_curriculum = MetaCurriculum(curriculum_folder)
         # TODO: Should be able to start learning at different lesson numbers
         # for each curriculum.
         meta_curriculum.set_all_curriculums_to_lesson_num(lesson)
     seed: Optional[int],
     start_port: int,
     env_args: Optional[List[str]],
-) -> Callable[[int], BaseUnityEnvironment]:
+) -> Callable[[int, List[SideChannel]], BaseUnityEnvironment]:
     if env_path is not None:
         # Strip out executable extensions if passed
         env_path = (
     seed_count = 10000
     seed_pool = [np.random.randint(0, seed_count) for _ in range(seed_count)]
 
-    def create_unity_environment(worker_id: int) -> UnityEnvironment:
+    def create_unity_environment(
+        worker_id: int, side_channels: List[SideChannel]
+    ) -> UnityEnvironment:
         env_seed = seed
         if not env_seed:
             env_seed = seed_pool[worker_id % len(seed_pool)]
             no_graphics=no_graphics,
             base_port=start_port,
             args=env_args,
+            side_channels=side_channels,
         )
 
     return create_unity_environment

ml-agents/mlagents/trainers/meta_curriculum.py

 """Contains the MetaCurriculum class."""
 
 import os
-from typing import Any, Dict, Set
+from typing import Dict, Set
 from mlagents.trainers.curriculum import Curriculum
 from mlagents.trainers.exception import MetaCurriculumError
 
     particular brain in the environment.
     """
 
-    def __init__(
-        self, curriculum_folder: str, default_reset_parameters: Dict[str, Any]
-    ):
+    def __init__(self, curriculum_folder: str):
         """Initializes a MetaCurriculum object.
 
         Args:
                 curriculum_filepath = os.path.join(
                     curriculum_folder, curriculum_filename
                 )
-                curriculum = Curriculum(curriculum_filepath, default_reset_parameters)
+                curriculum = Curriculum(curriculum_filepath)
                 config_keys: Set[str] = set(curriculum.get_config().keys())
 
                 # Check if any two curriculums use the same reset params.

ml-agents/mlagents/trainers/ppo/policy.py

             feed_dict[self.model.epsilon] = epsilon
         feed_dict = self.fill_eval_dict(feed_dict, brain_info)
         run_out = self._execute_model(feed_dict, self.inference_dict)
-        if self.use_continuous_act:
-            run_out["random_normal_epsilon"] = epsilon
         return run_out
 
     @timed
 
         if self.use_continuous_act:
             feed_dict[model.output_pre] = mini_batch["actions_pre"]
-            feed_dict[model.epsilon] = mini_batch["random_normal_epsilon"]
         else:
             feed_dict[model.action_holder] = mini_batch["actions"]
             if self.use_recurrent:
         if self.use_recurrent:
             feed_dict[self.model.memory_in] = self.retrieve_memories([agent_id])
         if not self.use_continuous_act and self.use_recurrent:
-            feed_dict[self.model.prev_action] = self.retrieve_memories([agent_id])
+            feed_dict[self.model.prev_action] = self.retrieve_previous_action(
+                [agent_id]
+            )
         value_estimates = self.sess.run(self.model.value_heads, feed_dict)
 
         value_estimates = {k: float(v) for k, v in value_estimates.items()}

ml-agents/mlagents/trainers/tests/mock_brain.py

         buffer[0]["actions_pre"].append(
             np.ones(buffer[0]["actions"][0].shape, dtype=np.float32)
         )
-        buffer[0]["random_normal_epsilon"].append(
-            np.ones(buffer[0]["actions"][0].shape, dtype=np.float32)
-        )
         buffer[0]["action_mask"].append(
             np.ones(np.sum(brain_params.vector_action_space_size), dtype=np.float32)
         )

ml-agents/mlagents/trainers/tests/test_curriculum.py

 
 @patch("builtins.open", new_callable=mock_open, read_data=dummy_curriculum_json_str)
 def test_init_curriculum_happy_path(mock_file, location, default_reset_parameters):
-    curriculum = Curriculum(location, default_reset_parameters)
+    curriculum = Curriculum(location)
 
     assert curriculum._brain_name == "TestBrain"
     assert curriculum.lesson_num == 0
     mock_file, location, default_reset_parameters
 ):
     with pytest.raises(CurriculumConfigError):
-        Curriculum(location, default_reset_parameters)
+        Curriculum(location)
-    curriculum = Curriculum(location, default_reset_parameters)
+    curriculum = Curriculum(location)
     assert curriculum.lesson_num == 0
 
     curriculum.lesson_num = 1
 
 @patch("builtins.open", new_callable=mock_open, read_data=dummy_curriculum_json_str)
 def test_get_config(mock_file):
-    curriculum = Curriculum("TestBrain.json", {"param1": 1, "param2": 1, "param3": 1})
+    curriculum = Curriculum("TestBrain.json")
     assert curriculum.get_config() == {"param1": 0.7, "param2": 100, "param3": 0.2}
 
     curriculum.lesson_num = 2

ml-agents/mlagents/trainers/tests/test_learn.py

                 None,
                 False,
                 0,
-                True,
                 sampler_manager_mock.return_value,
                 None,
             )
     assert opt.run_id == "ppo"
     assert opt.save_freq == 50000
     assert opt.seed == -1
-    assert opt.fast_simulation is True
     assert opt.train_model is False
     assert opt.base_port == 5005
     assert opt.num_envs == 1
         "--num-runs=3",
         "--save-freq=123456",
         "--seed=7890",
-        "--slow",
         "--train",
         "--base-port=4004",
         "--num-envs=2",
     assert opt.run_id == "myawesomerun"
     assert opt.save_freq == 123456
     assert opt.seed == 7890
-    assert opt.fast_simulation is False
     assert opt.train_model is True
     assert opt.base_port == 4004
     assert opt.num_envs == 2

ml-agents/mlagents/trainers/tests/test_meta_curriculum.py

 def test_init_meta_curriculum_happy_path(
     listdir, mock_curriculum_init, mock_curriculum_get_config, default_reset_parameters
 ):
-    meta_curriculum = MetaCurriculum("test/", default_reset_parameters)
+    meta_curriculum = MetaCurriculum("test/")
 
     assert len(meta_curriculum.brains_to_curriculums) == 2
 
-    calls = [
-        call("test/Brain1.json", default_reset_parameters),
-        call("test/Brain2.json", default_reset_parameters),
-    ]
+    calls = [call("test/Brain1.json"), call("test/Brain2.json")]
 
     mock_curriculum_init.assert_has_calls(calls)
 
     with pytest.raises(MetaCurriculumError):
-        MetaCurriculum("test/", default_reset_parameters)
+        MetaCurriculum("test/")
 
 
 @patch("mlagents.trainers.curriculum.Curriculum")

ml-agents/mlagents/trainers/tests/test_sac.py

 
     # Test update, while removing PPO-specific buffer elements.
     update_buffer = mb.simulate_rollout(
-        env,
-        policy,
-        BUFFER_INIT_SAMPLES,
-        exclude_key_list=["advantages", "actions_pre", "random_normal_epsilon"],
+        env, policy, BUFFER_INIT_SAMPLES, exclude_key_list=["advantages", "actions_pre"]
     )
 
     # Mock out reward signal eval

ml-agents/mlagents/trainers/tests/test_simple_rl.py

 )
 from mlagents.envs.simple_env_manager import SimpleEnvManager
 from mlagents.envs.sampler_class import SamplerManager
+from mlagents.envs.side_channel.float_properties_channel import FloatPropertiesChannel
 
 
 BRAIN_NAME = __name__
         seed = 1337
 
         trainer_config = yaml.safe_load(config)
-        env_manager = SimpleEnvManager(env)
+        env_manager = SimpleEnvManager(env, FloatPropertiesChannel())
         trainer_factory = TrainerFactory(
             trainer_config=trainer_config,
             summaries_dir=dir,
             meta_curriculum=None,
             train=True,
             training_seed=seed,
-            fast_simulation=True,
             sampler_manager=SamplerManager(None),
             resampling_interval=None,
             save_freq=save_freq,

ml-agents/mlagents/trainers/tests/test_trainer_controller.py

         meta_curriculum=None,
         train=True,
         training_seed=99,
-        fast_simulation=True,
         sampler_manager=SamplerManager({}),
         resampling_interval=None,
     )
         meta_curriculum=None,
         train=True,
         training_seed=seed,
-        fast_simulation=True,
         sampler_manager=SamplerManager({}),
         resampling_interval=None,
     )

ml-agents/mlagents/trainers/tf_policy.py

         self.seed = seed
         self.brain = brain
         self.use_recurrent = trainer_parameters["use_recurrent"]
-        self.memory_dict: Dict[int, np.ndarray] = {}
+        self.memory_dict: Dict[str, np.ndarray] = {}
-        self.previous_action_dict: Dict[int, np.array] = {}
+        self.previous_action_dict: Dict[str, np.array] = {}
         self.normalize = trainer_parameters.get("normalize", False)
         self.use_continuous_act = brain.vector_action_space_type == "continuous"
         if self.use_continuous_act:
         return np.zeros((num_agents, self.m_size), dtype=np.float32)
 
     def save_memories(
-        self, agent_ids: List[int], memory_matrix: Optional[np.ndarray]
+        self, agent_ids: List[str], memory_matrix: Optional[np.ndarray]
     ) -> None:
         if memory_matrix is None:
             return
-    def retrieve_memories(self, agent_ids: List[int]) -> np.ndarray:
+    def retrieve_memories(self, agent_ids: List[str]) -> np.ndarray:
         memory_matrix = np.zeros((len(agent_ids), self.m_size), dtype=np.float32)
         for index, agent_id in enumerate(agent_ids):
             if agent_id in self.memory_dict:
         return np.zeros((num_agents, self.num_branches), dtype=np.int)
 
     def save_previous_action(
-        self, agent_ids: List[int], action_matrix: Optional[np.ndarray]
+        self, agent_ids: List[str], action_matrix: Optional[np.ndarray]
     ) -> None:
         if action_matrix is None:
             return
-    def retrieve_previous_action(self, agent_ids: List[int]) -> np.ndarray:
+    def retrieve_previous_action(self, agent_ids: List[str]) -> np.ndarray:
         action_matrix = np.zeros((len(agent_ids), self.num_branches), dtype=np.int)
         for index, agent_id in enumerate(agent_ids):
             if agent_id in self.previous_action_dict:

ml-agents/mlagents/trainers/trainer_controller.py

         meta_curriculum: Optional[MetaCurriculum],
         train: bool,
         training_seed: int,
-        fast_simulation: bool,
         sampler_manager: SamplerManager,
         resampling_interval: Optional[int],
     ):
         self.trainer_metrics: Dict[str, TrainerMetrics] = {}
         self.meta_curriculum = meta_curriculum
         self.training_start_time = time()
-        self.fast_simulation = fast_simulation
         self.sampler_manager = sampler_manager
         self.resampling_interval = resampling_interval
         np.random.seed(training_seed)
             self.meta_curriculum.get_config() if self.meta_curriculum else {}
         )
         sampled_reset_param.update(new_meta_curriculum_config)
-        return env.reset(train_mode=self.fast_simulation, config=sampled_reset_param)
+        return env.reset(config=sampled_reset_param)
 
     def _should_save_model(self, global_step: int) -> bool:
         return (

protobuf-definitions/proto/mlagents/envs/communicator_objects/unity_rl_initialization_output.proto

 syntax = "proto3";
 
 import "mlagents/envs/communicator_objects/brain_parameters.proto";
-import "mlagents/envs/communicator_objects/environment_parameters.proto";
 
 option csharp_namespace = "MLAgents.CommunicatorObjects";
 package communicator_objects;
     string version = 2;
     string log_path = 3;
     repeated BrainParametersProto brain_parameters = 5;
-    EnvironmentParametersProto environment_parameters = 6;
+    reserved 6; //environment parameters
 }

protobuf-definitions/proto/mlagents/envs/communicator_objects/unity_rl_input.proto

 syntax = "proto3";
 
 import "mlagents/envs/communicator_objects/agent_action.proto";
-import "mlagents/envs/communicator_objects/environment_parameters.proto";
 import "mlagents/envs/communicator_objects/command.proto";
 
 option csharp_namespace = "MLAgents.CommunicatorObjects";
             repeated AgentActionProto value = 1;
         }
     map<string, ListAgentActionProto> agent_actions = 1;
-    EnvironmentParametersProto environment_parameters = 2;
-    bool is_training = 3;
+    reserved 2; //deprecated environment proto
+    reserved 3; //deprecated is_trainig
     CommandProto command = 4;
     bytes side_channel = 5;
 }

UnitySDK/Assets/ML-Agents/Editor/ResetParameterDrawer.cs

-using UnityEngine;
-using UnityEditor;
-using System;
-using System.Linq;
-using UnityEditor.SceneManagement;
-using UnityEngine.SceneManagement;
-
-namespace MLAgents
-{
-    /// <summary>
-    /// PropertyDrawer for ResetParameters. Defines how ResetParameters are displayed in the
-    /// Inspector.
-    /// </summary>
-    [CustomPropertyDrawer(typeof(ResetParameters))]
-    public class ResetParameterDrawer : PropertyDrawer
-    {
-        ResetParameters m_Parameters;
-        // The height of a line in the Unity Inspectors
-        const float k_LineHeight = 17f;
-        // This is the prefix for the key when you add a reset parameter
-        const string k_NewKeyPrefix = "Param-";
-
-        /// <summary>
-        /// Computes the height of the Drawer depending on the property it is showing
-        /// </summary>
-        /// <param name="property">The property that is being drawn.</param>
-        /// <param name="label">The label of the property being drawn.</param>
-        /// <returns>The vertical space needed to draw the property.</returns>
-        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
-        {
-            LazyInitializeParameters(property);
-            return (m_Parameters.Count + 2) * k_LineHeight;
-        }
-
-        /// <inheritdoc />
-        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
-        {
-            LazyInitializeParameters(property);
-            position.height = k_LineHeight;
-            EditorGUI.LabelField(position, label);
-            position.y += k_LineHeight;
-            var width = position.width / 2 - 24;
-            var keyRect = new Rect(position.x + 20, position.y, width, position.height);
-            var valueRect = new Rect(position.x + width + 30, position.y, width, position.height);
-            DrawAddRemoveButtons(keyRect, valueRect);
-            EditorGUI.BeginProperty(position, label, property);
-            foreach (var parameter in m_Parameters)
-            {
-                var key = parameter.Key;
-                var value = parameter.Value;
-                keyRect.y += k_LineHeight;
-                valueRect.y += k_LineHeight;
-                EditorGUI.BeginChangeCheck();
-                var newKey = EditorGUI.TextField(keyRect, key);
-                if (EditorGUI.EndChangeCheck())
-                {
-                    MarkSceneAsDirty();
-                    try
-                    {
-                        m_Parameters.Remove(key);
-                        m_Parameters.Add(newKey, value);
-                    }
-                    catch (Exception e)
-                    {
-                        Debug.Log(e.Message);
-                    }
-                    break;
-                }
-
-                EditorGUI.BeginChangeCheck();
-                value = EditorGUI.FloatField(valueRect, value);
-                if (EditorGUI.EndChangeCheck())
-                {
-                    MarkSceneAsDirty();
-                    m_Parameters[key] = value;
-                    break;
-                }
-            }
-            EditorGUI.EndProperty();
-        }
-
-        /// <summary>
-        /// Draws the Add and Remove buttons.
-        /// </summary>
-        /// <param name="addRect">The rectangle for the Add New button.</param>
-        /// <param name="removeRect">The rectangle for the Remove Last button.</param>
-        void DrawAddRemoveButtons(Rect addRect, Rect removeRect)
-        {
-            // This is the Add button
-            if (m_Parameters.Count == 0)
-            {
-                addRect.width *= 2;
-            }
-            if (GUI.Button(addRect,
-                new GUIContent("Add New", "Add a new item to the default reset parameters"),
-                EditorStyles.miniButton))
-            {
-                MarkSceneAsDirty();
-                AddParameter();
-            }
-
-            // If there are no items in the ResetParameters, Hide the Remove button
-            if (m_Parameters.Count == 0)
-            {
-                return;
-            }
-            // This is the Remove button
-            if (GUI.Button(removeRect,
-                new GUIContent(
-                    "Remove Last", "Remove the last item from the default reset parameters"),
-                EditorStyles.miniButton))
-            {
-                MarkSceneAsDirty();
-                RemoveLastParameter();
-            }
-        }
-
-        /// <summary>
-        /// Signals that the property has been modified and requires the scene to be saved for
-        /// the changes to persist. Only works when the Editor is not playing.
-        /// </summary>
-        static void MarkSceneAsDirty()
-        {
-            if (!EditorApplication.isPlaying)
-            {
-                EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
-            }
-        }
-
-        /// <summary>
-        /// Ensures that the state of the Drawer is synchronized with the property.
-        /// </summary>
-        /// <param name="property">The SerializedProperty of the ResetParameters
-        /// to make the custom GUI for.</param>
-        void LazyInitializeParameters(SerializedProperty property)
-        {
-            if (m_Parameters != null)
-            {
-                return;
-            }
-            var target = property.serializedObject.targetObject;
-            m_Parameters = fieldInfo.GetValue(target) as ResetParameters;
-            if (m_Parameters == null)
-            {
-                m_Parameters = new ResetParameters();
-                fieldInfo.SetValue(target, m_Parameters);
-            }
-        }
-
-        /// <summary>
-        /// Removes the last ResetParameter from the ResetParameters
-        /// </summary>
-        void RemoveLastParameter()
-        {
-            if (m_Parameters.Count > 0)
-            {
-                var key = m_Parameters.Keys.ToList()[m_Parameters.Count - 1];
-                m_Parameters.Remove(key);
-            }
-        }
-
-        /// <summary>
-        /// Adds a new ResetParameter to the ResetParameters with a default name.
-        /// </summary>
-        void AddParameter()
-        {
-            var key = k_NewKeyPrefix + m_Parameters.Count;
-            var value = default(float);
-            try
-            {
-                m_Parameters.Add(key, value);
-            }
-            catch (Exception e)
-            {
-                Debug.Log(e.Message);
-            }
-        }
-    }
-}

UnitySDK/Assets/ML-Agents/Editor/ResetParameterDrawer.cs.meta

-fileFormatVersion: 2
-guid: 740b9a60fe38f476ab020dcf91f3f94a
-timeCreated: 1517291065
-licenseType: Free
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnitySDK/Assets/ML-Agents/Scripts/Grpc/CommunicatorObjects/EnvironmentParameters.cs

-// <auto-generated>
-//     Generated by the protocol buffer compiler.  DO NOT EDIT!
-//     source: mlagents/envs/communicator_objects/environment_parameters.proto
-// </auto-generated>
-#pragma warning disable 1591, 0612, 3021
-#region Designer generated code
-
-using pb = global::Google.Protobuf;
-using pbc = global::Google.Protobuf.Collections;
-using pbr = global::Google.Protobuf.Reflection;
-using scg = global::System.Collections.Generic;
-namespace MLAgents.CommunicatorObjects {
-
-  /// <summary>Holder for reflection information generated from mlagents/envs/communicator_objects/environment_parameters.proto</summary>
-  public static partial class EnvironmentParametersReflection {
-
-    #region Descriptor
-    /// <summary>File descriptor for mlagents/envs/communicator_objects/environment_parameters.proto</summary>
-    public static pbr::FileDescriptor Descriptor {
-      get { return descriptor; }
-    }
-    private static pbr::FileDescriptor descriptor;
-
-    static EnvironmentParametersReflection() {
-      byte[] descriptorData = global::System.Convert.FromBase64String(
-          string.Concat(
-            "Cj9tbGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL2Vudmlyb25t",
-            "ZW50X3BhcmFtZXRlcnMucHJvdG8SFGNvbW11bmljYXRvcl9vYmplY3RzGkBt",
-            "bGFnZW50cy9lbnZzL2NvbW11bmljYXRvcl9vYmplY3RzL2N1c3RvbV9yZXNl",
-            "dF9wYXJhbWV0ZXJzLnByb3RvIogCChpFbnZpcm9ubWVudFBhcmFtZXRlcnNQ",
-            "cm90bxJfChBmbG9hdF9wYXJhbWV0ZXJzGAEgAygLMkUuY29tbXVuaWNhdG9y",
-            "X29iamVjdHMuRW52aXJvbm1lbnRQYXJhbWV0ZXJzUHJvdG8uRmxvYXRQYXJh",
-            "bWV0ZXJzRW50cnkSUQoXY3VzdG9tX3Jlc2V0X3BhcmFtZXRlcnMYAiABKAsy",
-            "MC5jb21tdW5pY2F0b3Jfb2JqZWN0cy5DdXN0b21SZXNldFBhcmFtZXRlcnNQ",
-            "cm90bxo2ChRGbG9hdFBhcmFtZXRlcnNFbnRyeRILCgNrZXkYASABKAkSDQoF",
-            "dmFsdWUYAiABKAI6AjgBQh+qAhxNTEFnZW50cy5Db21tdW5pY2F0b3JPYmpl",
-            "Y3RzYgZwcm90bzM="));
-      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
-          new pbr::FileDescriptor[] { global::MLAgents.CommunicatorObjects.CustomResetParametersReflection.Descriptor, },
-          new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
-            new pbr::GeneratedClrTypeInfo(typeof(global::MLAgents.CommunicatorObjects.EnvironmentParametersProto), global::MLAgents.CommunicatorObjects.EnvironmentParametersProto.Parser, new[]{ "FloatParameters", "CustomResetParameters" }, null, null, new pbr::GeneratedClrTypeInfo[] { null, })
-          }));
-    }
-    #endregion
-
-  }
-  #region Messages
-  public sealed partial class EnvironmentParametersProto : pb::IMessage<EnvironmentParametersProto> {
-    private static readonly pb::MessageParser<EnvironmentParametersProto> _parser = new pb::MessageParser<EnvironmentParametersProto>(() => new EnvironmentParametersProto());
-    private pb::UnknownFieldSet _unknownFields;
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public static pb::MessageParser<EnvironmentParametersProto> Parser { get { return _parser; } }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public static pbr::MessageDescriptor Descriptor {
-      get { return global::MLAgents.CommunicatorObjects.EnvironmentParametersReflection.Descriptor.MessageTypes[0]; }
-    }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    pbr::MessageDescriptor pb::IMessage.Descriptor {
-      get { return Descriptor; }
-    }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public EnvironmentParametersProto() {
-      OnConstruction();
-    }
-
-    partial void OnConstruction();
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public EnvironmentParametersProto(EnvironmentParametersProto other) : this() {
-      floatParameters_ = other.floatParameters_.Clone();
-      CustomResetParameters = other.customResetParameters_ != null ? other.CustomResetParameters.Clone() : null;
-      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
-    }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public EnvironmentParametersProto Clone() {
-      return new EnvironmentParametersProto(this);
-    }
-
-    /// <summary>Field number for the "float_parameters" field.</summary>
-    public const int FloatParametersFieldNumber = 1;
-    private static readonly pbc::MapField<string, float>.Codec _map_floatParameters_codec
-        = new pbc::MapField<string, float>.Codec(pb::FieldCodec.ForString(10), pb::FieldCodec.ForFloat(21), 10);
-    private readonly pbc::MapField<string, float> floatParameters_ = new pbc::MapField<string, float>();
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public pbc::MapField<string, float> FloatParameters {
-      get { return floatParameters_; }
-    }
-
-    /// <summary>Field number for the "custom_reset_parameters" field.</summary>
-    public const int CustomResetParametersFieldNumber = 2;
-    private global::MLAgents.CommunicatorObjects.CustomResetParametersProto customResetParameters_;
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public global::MLAgents.CommunicatorObjects.CustomResetParametersProto CustomResetParameters {
-      get { return customResetParameters_; }
-      set {
-        customResetParameters_ = value;
-      }
-    }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public override bool Equals(object other) {
-      return Equals(other as EnvironmentParametersProto);
-    }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public bool Equals(EnvironmentParametersProto other) {
-      if (ReferenceEquals(other, null)) {
-        return false;
-      }
-      if (ReferenceEquals(other, this)) {
-        return true;
-      }
-      if (!FloatParameters.Equals(other.FloatParameters)) return false;
-      if (!object.Equals(CustomResetParameters, other.CustomResetParameters)) return false;
-      return Equals(_unknownFields, other._unknownFields);
-    }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public override int GetHashCode() {
-      int hash = 1;
-      hash ^= FloatParameters.GetHashCode();
-      if (customResetParameters_ != null) hash ^= CustomResetParameters.GetHashCode();
-      if (_unknownFields != null) {
-        hash ^= _unknownFields.GetHashCode();
-      }
-      return hash;
-    }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public override string ToString() {
-      return pb::JsonFormatter.ToDiagnosticString(this);
-    }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public void WriteTo(pb::CodedOutputStream output) {
-      floatParameters_.WriteTo(output, _map_floatParameters_codec);
-      if (customResetParameters_ != null) {
-        output.WriteRawTag(18);
-        output.WriteMessage(CustomResetParameters);
-      }
-      if (_unknownFields != null) {
-        _unknownFields.WriteTo(output);
-      }
-    }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public int CalculateSize() {
-      int size = 0;
-      size += floatParameters_.CalculateSize(_map_floatParameters_codec);
-      if (customResetParameters_ != null) {
-        size += 1 + pb::CodedOutputStream.ComputeMessageSize(CustomResetParameters);
-      }
-      if (_unknownFields != null) {
-        size += _unknownFields.CalculateSize();
-      }
-      return size;
-    }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public void MergeFrom(EnvironmentParametersProto other) {
-      if (other == null) {
-        return;
-      }
-      floatParameters_.Add(other.floatParameters_);
-      if (other.customResetParameters_ != null) {
-        if (customResetParameters_ == null) {
-          customResetParameters_ = new global::MLAgents.CommunicatorObjects.CustomResetParametersProto();
-        }
-        CustomResetParameters.MergeFrom(other.CustomResetParameters);
-      }
-      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
-    }
-
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
-    public void MergeFrom(pb::CodedInputStream input) {
-      uint tag;
-      while ((tag = input.ReadTag()) != 0) {
-        switch(tag) {
-          default:
-            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
-            break;
-          case 10: {
-            floatParameters_.AddEntriesFrom(input, _map_floatParameters_codec);
-            break;
-          }
-          case 18: {
-            if (customResetParameters_ == null) {
-              customResetParameters_ = new global::MLAgents.CommunicatorObjects.CustomResetParametersProto();
-            }
-            input.ReadMessage(customResetParameters_);
-            break;
-          }
-        }
-      }
-    }
-
-  }
-
-  #endregion
-
-}
-
-#endregion Designer generated code

UnitySDK/Assets/ML-Agents/Scripts/Grpc/CommunicatorObjects/EnvironmentParameters.cs.meta

-fileFormatVersion: 2
-guid: 8b4c58a64d6a94f579774322ef683b17
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnitySDK/Assets/ML-Agents/Scripts/ResetParameters.cs

-using System;
-using System.Collections.Generic;
-using UnityEngine;
-using UnityEngine.Serialization;
-
-namespace MLAgents
-{
-    [Serializable]
-    public class ResetParameters : Dictionary<string, float>, ISerializationCallbackReceiver
-    {
-        [Serializable]
-        public struct ResetParameter
-        {
-            public string key;
-            public float value;
-        }
-
-        public ResetParameters() {}
-
-        public ResetParameters(IDictionary<string, float> dict) : base(dict)
-        {
-            UpdateResetParameters();
-        }
-
-        void UpdateResetParameters()
-        {
-            m_ResetParameters.Clear();
-            foreach (var pair in this)
-            {
-                m_ResetParameters.Add(new ResetParameter { key = pair.Key, value = pair.Value });
-            }
-        }
-
-        [FormerlySerializedAs("resetParameters")]
-        [SerializeField]
-        List<ResetParameter> m_ResetParameters = new List<ResetParameter>();
-
-        public void OnBeforeSerialize()
-        {
-            UpdateResetParameters();
-        }
-
-        public void OnAfterDeserialize()
-        {
-            Clear();
-
-
-            for (var i = 0; i < m_ResetParameters.Count; i++)
-            {
-                if (ContainsKey(m_ResetParameters[i].key))
-                {
-                    Debug.LogError("The ResetParameters contains the same key twice");
-                }
-                else
-                {
-                    Add(m_ResetParameters[i].key, m_ResetParameters[i].value);
-                }
-            }
-        }
-    }
-}

UnitySDK/Assets/ML-Agents/Scripts/ResetParameters.cs.meta

-fileFormatVersion: 2
-guid: af19281a4c1dd47518ac7501c45eca9f
-timeCreated: 1517261137
-licenseType: Free
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

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

-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: mlagents/envs/communicator_objects/environment_parameters.proto
-
-import sys
-_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import message as _message
-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()
-
-
-from mlagents.envs.communicator_objects import custom_reset_parameters_pb2 as mlagents_dot_envs_dot_communicator__objects_dot_custom__reset__parameters__pb2
-
-
-DESCRIPTOR = _descriptor.FileDescriptor(
-  name='mlagents/envs/communicator_objects/environment_parameters.proto',
-  package='communicator_objects',
-  syntax='proto3',
-  serialized_pb=_b('\n?mlagents/envs/communicator_objects/environment_parameters.proto\x12\x14\x63ommunicator_objects\x1a@mlagents/envs/communicator_objects/custom_reset_parameters.proto\"\x88\x02\n\x1a\x45nvironmentParametersProto\x12_\n\x10\x66loat_parameters\x18\x01 \x03(\x0b\x32\x45.communicator_objects.EnvironmentParametersProto.FloatParametersEntry\x12Q\n\x17\x63ustom_reset_parameters\x18\x02 \x01(\x0b\x32\x30.communicator_objects.CustomResetParametersProto\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')
-  ,
-  dependencies=[mlagents_dot_envs_dot_communicator__objects_dot_custom__reset__parameters__pb2.DESCRIPTOR,])
-
-
-
-
-_ENVIRONMENTPARAMETERSPROTO_FLOATPARAMETERSENTRY = _descriptor.Descriptor(
-  name='FloatParametersEntry',
-  full_name='communicator_objects.EnvironmentParametersProto.FloatParametersEntry',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='key', full_name='communicator_objects.EnvironmentParametersProto.FloatParametersEntry.key', index=0,
-      number=1, type=9, cpp_type=9, label=1,
-      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),
-    _descriptor.FieldDescriptor(
-      name='value', full_name='communicator_objects.EnvironmentParametersProto.FloatParametersEntry.value', index=1,
-      number=2, type=2, cpp_type=6, label=1,
-      has_default_value=False, default_value=float(0),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      options=None, file=DESCRIPTOR),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  options=_descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001')),
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=366,
-  serialized_end=420,
-)
-
-_ENVIRONMENTPARAMETERSPROTO = _descriptor.Descriptor(
-  name='EnvironmentParametersProto',
-  full_name='communicator_objects.EnvironmentParametersProto',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='float_parameters', full_name='communicator_objects.EnvironmentParametersProto.float_parameters', index=0,
-      number=1, type=11, cpp_type=10, label=3,
-      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),
-    _descriptor.FieldDescriptor(
-      name='custom_reset_parameters', full_name='communicator_objects.EnvironmentParametersProto.custom_reset_parameters', index=1,
-      number=2, type=11, cpp_type=10, label=1,
-      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),
-  ],
-  extensions=[
-  ],
-  nested_types=[_ENVIRONMENTPARAMETERSPROTO_FLOATPARAMETERSENTRY, ],
-  enum_types=[
-  ],
-  options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=156,
-  serialized_end=420,
-)
-
-_ENVIRONMENTPARAMETERSPROTO_FLOATPARAMETERSENTRY.containing_type = _ENVIRONMENTPARAMETERSPROTO
-_ENVIRONMENTPARAMETERSPROTO.fields_by_name['float_parameters'].message_type = _ENVIRONMENTPARAMETERSPROTO_FLOATPARAMETERSENTRY
-_ENVIRONMENTPARAMETERSPROTO.fields_by_name['custom_reset_parameters'].message_type = mlagents_dot_envs_dot_communicator__objects_dot_custom__reset__parameters__pb2._CUSTOMRESETPARAMETERSPROTO
-DESCRIPTOR.message_types_by_name['EnvironmentParametersProto'] = _ENVIRONMENTPARAMETERSPROTO
-_sym_db.RegisterFileDescriptor(DESCRIPTOR)
-
-EnvironmentParametersProto = _reflection.GeneratedProtocolMessageType('EnvironmentParametersProto', (_message.Message,), dict(
-
-  FloatParametersEntry = _reflection.GeneratedProtocolMessageType('FloatParametersEntry', (_message.Message,), dict(
-    DESCRIPTOR = _ENVIRONMENTPARAMETERSPROTO_FLOATPARAMETERSENTRY,
-    __module__ = 'mlagents.envs.communicator_objects.environment_parameters_pb2'
-    # @@protoc_insertion_point(class_scope:communicator_objects.EnvironmentParametersProto.FloatParametersEntry)
-    ))
-  ,
-  DESCRIPTOR = _ENVIRONMENTPARAMETERSPROTO,
-  __module__ = 'mlagents.envs.communicator_objects.environment_parameters_pb2'
-  # @@protoc_insertion_point(class_scope:communicator_objects.EnvironmentParametersProto)
-  ))
-_sym_db.RegisterMessage(EnvironmentParametersProto)
-_sym_db.RegisterMessage(EnvironmentParametersProto.FloatParametersEntry)
-
-
-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'))
-# @@protoc_insertion_point(module_scope)

ml-agents-envs/mlagents/envs/communicator_objects/environment_parameters_pb2.pyi

-# @generated by generate_proto_mypy_stubs.py.  Do not edit!
-import sys
-from google.protobuf.descriptor import (
-    Descriptor as google___protobuf___descriptor___Descriptor,
-)
-
-from google.protobuf.message import (
-    Message as google___protobuf___message___Message,
-)
-
-from mlagents.envs.communicator_objects.custom_reset_parameters_pb2 import (
-    CustomResetParametersProto as mlagents___envs___communicator_objects___custom_reset_parameters_pb2___CustomResetParametersProto,
-)
-
-from typing import (
-    Mapping as typing___Mapping,
-    MutableMapping as typing___MutableMapping,
-    Optional as typing___Optional,
-    Text as typing___Text,
-)
-
-from typing_extensions import (
-    Literal as typing_extensions___Literal,
-)
-
-
-builtin___bool = bool
-builtin___bytes = bytes
-builtin___float = float
-builtin___int = int
-
-
-class EnvironmentParametersProto(google___protobuf___message___Message):
-    DESCRIPTOR: google___protobuf___descriptor___Descriptor = ...
-    class FloatParametersEntry(google___protobuf___message___Message):
-        DESCRIPTOR: google___protobuf___descriptor___Descriptor = ...
-        key = ... # type: typing___Text
-        value = ... # type: builtin___float
-
-        def __init__(self,
-            *,
-            key : typing___Optional[typing___Text] = None,
-            value : typing___Optional[builtin___float] = None,
-            ) -> None: ...
-        @classmethod
-        def FromString(cls, s: builtin___bytes) -> EnvironmentParametersProto.FloatParametersEntry: ...
-        def MergeFrom(self, other_msg: google___protobuf___message___Message) -> None: ...
-        def CopyFrom(self, other_msg: google___protobuf___message___Message) -> None: ...
-        if sys.version_info >= (3,):
-            def ClearField(self, field_name: typing_extensions___Literal[u"key",u"value"]) -> None: ...
-        else:
-            def ClearField(self, field_name: typing_extensions___Literal[u"key",b"key",u"value",b"value"]) -> None: ...
-
-
-    @property
-    def float_parameters(self) -> typing___MutableMapping[typing___Text, builtin___float]: ...
-
-    @property
-    def custom_reset_parameters(self) -> mlagents___envs___communicator_objects___custom_reset_parameters_pb2___CustomResetParametersProto: ...
-
-    def __init__(self,
-        *,
-        float_parameters : typing___Optional[typing___Mapping[typing___Text, builtin___float]] = None,
-        custom_reset_parameters : typing___Optional[mlagents___envs___communicator_objects___custom_reset_parameters_pb2___CustomResetParametersProto] = None,
-        ) -> None: ...
-    @classmethod
-    def FromString(cls, s: builtin___bytes) -> EnvironmentParametersProto: ...
-    def MergeFrom(self, other_msg: google___protobuf___message___Message) -> None: ...
-    def CopyFrom(self, other_msg: google___protobuf___message___Message) -> None: ...
-    if sys.version_info >= (3,):
-        def HasField(self, field_name: typing_extensions___Literal[u"custom_reset_parameters"]) -> builtin___bool: ...
-        def ClearField(self, field_name: typing_extensions___Literal[u"custom_reset_parameters",u"float_parameters"]) -> None: ...
-    else:
-        def HasField(self, field_name: typing_extensions___Literal[u"custom_reset_parameters",b"custom_reset_parameters"]) -> builtin___bool: ...
-        def ClearField(self, field_name: typing_extensions___Literal[u"custom_reset_parameters",b"custom_reset_parameters",u"float_parameters",b"float_parameters"]) -> None: ...

protobuf-definitions/proto/mlagents/envs/communicator_objects/environment_parameters.proto

-syntax = "proto3";
-
-import "mlagents/envs/communicator_objects/custom_reset_parameters.proto";
-
-option csharp_namespace = "MLAgents.CommunicatorObjects";
-package communicator_objects;
-
-message EnvironmentParametersProto {
-    map<string, float> float_parameters = 1; 
-    CustomResetParametersProto custom_reset_parameters = 2;
-}