Add capabilities checks bewteen C# and Python codebases.

Author: surfnerd

com.unity.ml-agents/CHANGELOG.md

@@ -80,6 +80,7 @@ and this project adheres to
 - `num_updates` and `train_interval` for SAC were replaced with `steps_per_update`. (#3690)
 - `WriteAdapter` was renamed to `ObservationWriter`. If you have a custom `ISensor` implementation,
 you will need to change the signature of its `Write()` method. (#3834)
+- `UnityRLCapabilities` was added to help inform users when RL features are mismatched between C# and Python packages. (#3831)
 
 ### Bug Fixes
 

com.unity.ml-agents/Runtime/Academy.cs

@@ -42,7 +42,7 @@ void FixedUpdate()
     /// Access the Academy singleton through the <see cref="Instance"/>
     /// property. The Academy instance is initialized the first time it is accessed (which will
     /// typically be by the first <see cref="Agent"/> initialized in a scene).
-    /// 
+    ///
     /// At initialization, the Academy attempts to connect to the Python training process through
     /// the external communicator. If successful, the training process can train <see cref="Agent"/>
     /// instances. When you set an agent's <see cref="BehaviorParameters.behaviorType"/> setting
@@ -131,6 +131,8 @@ public bool IsCommunicatorOn
         // Random seed used for inference.
         int m_InferenceSeed;
 
+        // The Capabilities of the RL trainer.
+
         /// <summary>
         /// Set the random seed used for inference. This should be set before any Agents are added
         /// to the scene. The seed is passed to the ModelRunner constructor, and incremented each
@@ -141,6 +143,12 @@ public int InferenceSeed
             set { m_InferenceSeed = value; }
         }
 
+        /// <summary>
+        /// Returns the RLCapabilities of the python client that the unity process is connected to.
+        /// </summary>
+        internal UnityRLCapabilities Capabilities { get; set; }
+
+
         // The Academy uses a series of events to communicate with agents
         // to facilitate synchronization. More specifically, it ensures
         // that all the agents perform their steps in a consistent order (i.e. no
@@ -354,12 +362,16 @@ void InitializeEnvironment()
                     UnityEngine.Random.InitState(unityRlInitParameters.seed);
                     // We might have inference-only Agents, so set the seed for them too.
                     m_InferenceSeed = unityRlInitParameters.seed;
+                    Capabilities = unityRlInitParameters.TrainerCapabilities;
+                    Capabilities.WarnOnPythonMissingBaseRLCapabilities();
                 }
-                catch
+                catch (Exception e)
                 {
                     Debug.Log($"" +
                         $"Couldn't connect to trainer on port {port} using API version {k_ApiVersion}. " +
-                        "Will perform inference instead."
+                        "Will perform inference instead." +
+                        "Original Exception Message:" +
+                        $"{e.Message}"
                     );
                     Communicator = null;
                 }

com.unity.ml-agents/Runtime/Communicator/GrpcExtensions.cs

@@ -280,5 +280,21 @@ public static ObservationProto GetObservationProto(this ISensor sensor, Observat
             return observationProto;
         }
         #endregion
+
+        public static UnityRLCapabilities ToRLCapabilities(this UnityRLCapabilitiesProto proto)
+        {
+            return new UnityRLCapabilities
+            {
+                BaseRLCapabilities = proto.BaseRLCapabilities
+            };
+        }
+
+        public static UnityRLCapabilitiesProto ToProto(this UnityRLCapabilities rlCaps)
+        {
+            return new UnityRLCapabilitiesProto
+            {
+                BaseRLCapabilities = rlCaps.BaseRLCapabilities
+            };
+        }
     }
 }

com.unity.ml-agents/Runtime/Communicator/ICommunicator.cs

@@ -27,6 +27,11 @@ internal struct CommunicatorInitParameters
         /// The version of the communication API.
         /// </summary>
         public string unityCommunicationVersion;
+
+        /// <summary>
+        /// The RL capabilities of the C# codebase.
+        /// </summary>
+        public UnityRLCapabilities CSharpCapabilities;
     }
     internal struct UnityRLInitParameters
     {
@@ -44,6 +49,11 @@ internal struct UnityRLInitParameters
         /// The version of the communication API that python is using.
         /// </summary>
         public string pythonCommunicationVersion;
+
+        /// <summary>
+        /// The RL capabilities of the Trainer codebase.
+        /// </summary>
+        public UnityRLCapabilities TrainerCapabilities;
     }
     internal struct UnityRLInputParameters
     {

com.unity.ml-agents/Runtime/Communicator/UnityRLCapabilities.cs

@@ -0,0 +1,31 @@
+using UnityEngine;
+
+namespace MLAgents
+{
+    /// <summary>
+    /// A struct holding the capabilities flags for Reinforcement Learning across C# and the Trainer codebase.  This
+    /// struct will be used to inform users if and when they are using C# / Trainer features that are mismatched.
+    /// </summary>
+    internal struct UnityRLCapabilities
+    {
+        internal bool BaseRLCapabilities;
+
+        /// <summary>
+        /// Will print a warning to the console if Python does not support base capabilities and will
+        /// return <value>true</value> if the warning was printed.
+        /// </summary>
+        /// <returns></returns>
+        public bool WarnOnPythonMissingBaseRLCapabilities()
+        {
+            if (BaseRLCapabilities)
+            {
+                return false;
+            }
+            Debug.LogWarning("Unity has connected to a Training process that does not support" +
+                             "Base Reinforcement Learning Capabilities.  Please make sure you have the" +
+                             " latest training codebase installed for this version of the ML-Agents package.");
+            return true;
+        }
+
+    }
+}