Add enum for sensor implementations, send in analytics (#4871)

com.unity.ml-agents.extensions/Runtime/Match3/Match3Sensor.cs

     /// or uncompressed visual observations. Uses AbstractBoard.GetCellType()
     /// and AbstractBoard.GetSpecialType() to determine the observation values.
     /// </summary>
-    public class Match3Sensor : ISparseChannelSensor
+    public class Match3Sensor : ISparseChannelSensor, IBuiltInSensor
     {
         private Match3ObservationType m_ObservationType;
         private AbstractBoard m_Board;
         public int[] GetCompressedChannelMapping()
         {
             return m_SparseChannelMapping;
+        }
+
+        /// <inheritdoc/>
+        public BuiltInSensorType GetBuiltInSensorType()
+        {
+            return BuiltInSensorType.Match3Sensor;
         }
 
         static void DestroyTexture(Texture2D texture)

com.unity.ml-agents.extensions/Runtime/Sensors/GridSensor.cs

     /// <summary>
     /// Grid-based sensor.
     /// </summary>
-    public class GridSensor : SensorComponent, ISensor
+    public class GridSensor : SensorComponent, ISensor, IBuiltInSensor
     {
         /// <summary>
         /// Name of this grid sensor.
         {
             return CompressionType;
         }
+
+        /// <inheritdoc/>
+        public BuiltInSensorType GetBuiltInSensorType()
+        {
+            return BuiltInSensorType.GridSensor;
+        }
+
 
         /// <summary>
         /// GetCompressedObservation - Calls Perceive then puts the data stored on the perception buffer

com.unity.ml-agents.extensions/Runtime/Sensors/PhysicsBodySensor.cs

     /// <summary>
     /// ISensor implementation that generates observations for a group of Rigidbodies or ArticulationBodies.
     /// </summary>
-    public class PhysicsBodySensor : ISensor
+    public class PhysicsBodySensor : ISensor, IBuiltInSensor
     {
         int[] m_Shape;
         string m_SensorName;
         {
             return m_SensorName;
         }
+
+        /// <inheritdoc/>
+        public BuiltInSensorType GetBuiltInSensorType()
+        {
+            return BuiltInSensorType.PhysicsBodySensor;
+        }
+
     }
 }

com.unity.ml-agents/Runtime/Analytics/Events.cs

     {
         public string SensorName;
         public string CompressionType;
+        public int BuiltInSensorType;
         public EventObservationDimensionInfo[] DimensionInfos;
 
         public static EventObservationSpec FromSensor(ISensor sensor)
                 // TODO copy flags when we have them
             }
 
+            var builtInSensorType =
+                (sensor as IBuiltInSensor)?.GetBuiltInSensorType() ?? Sensors.BuiltInSensorType.Unknown;
+
+                BuiltInSensorType = (int)builtInSensorType,
                 DimensionInfos = dimInfos,
             };
         }

com.unity.ml-agents/Runtime/Analytics/InferenceAnalytics.cs

     {
         const string k_VendorKey = "unity.ml-agents";
         const string k_EventName = "ml_agents_inferencemodelset";
+        const int k_EventVersion = 1;
 
         /// <summary>
         /// Whether or not we've registered this particular event yet
         /// </summary>
         const int k_MaxNumberOfElements = 1000;
 
+
         /// <summary>
         /// Models that we've already sent events for.
         /// </summary>
             }
 
 #if UNITY_EDITOR
-            AnalyticsResult result = EditorAnalytics.RegisterEventWithLimit(k_EventName, k_MaxEventsPerHour, k_MaxNumberOfElements, k_VendorKey);
+            AnalyticsResult result = EditorAnalytics.RegisterEventWithLimit(k_EventName, k_MaxEventsPerHour, k_MaxNumberOfElements, k_VendorKey, k_EventVersion);
 #else
             AnalyticsResult result = AnalyticsResult.UnsupportedPlatform;
 #endif
 
             var data = GetEventForModel(nnModel, behaviorName, inferenceDevice, sensors, actionSpec);
             // Note - to debug, use JsonUtility.ToJson on the event.
-            // Debug.Log(JsonUtility.ToJson(data, true));
+            //Debug.Log(JsonUtility.ToJson(data, true));
-            EditorAnalytics.SendEventWithLimit(k_EventName, data);
+            EditorAnalytics.SendEventWithLimit(k_EventName, data, k_EventVersion);
 #else
             return;
 #endif

com.unity.ml-agents/Runtime/Sensors/BufferSensor.cs

 
 namespace Unity.MLAgents.Sensors
 {
-    internal class BufferSensor : ISensor, IDimensionPropertiesSensor
+    internal class BufferSensor : ISensor, IDimensionPropertiesSensor, IBuiltInSensor
     {
         private int m_MaxNumObs;
         private int m_ObsSize;
         public string GetName()
         {
             return "BufferSensor";
+        }
+
+        /// <inheritdoc/>
+        public BuiltInSensorType GetBuiltInSensorType()
+        {
+            return BuiltInSensorType.BufferSensor;
         }
 
     }

com.unity.ml-agents/Runtime/Sensors/CameraSensor.cs

     /// <summary>
     /// A sensor that wraps a Camera object to generate visual observations for an agent.
     /// </summary>
-    public class CameraSensor : ISensor
+    public class CameraSensor : ISensor, IBuiltInSensor
     {
         Camera m_Camera;
         int m_Width;
                 Object.Destroy(texture);
             }
         }
+
+        /// <inheritdoc/>
+        public BuiltInSensorType GetBuiltInSensorType()
+        {
+            return BuiltInSensorType.CameraSensor;
+        }
+
     }
 }

com.unity.ml-agents/Runtime/Sensors/RayPerceptionSensor.cs

     /// <summary>
     /// A sensor implementation that supports ray cast-based observations.
     /// </summary>
-    public class RayPerceptionSensor : ISensor
+    public class RayPerceptionSensor : ISensor, IBuiltInSensor
     {
         float[] m_Observations;
         int[] m_Shape;
         public virtual SensorCompressionType GetCompressionType()
         {
             return SensorCompressionType.None;
+        }
+
+        /// <inheritdoc/>
+        public BuiltInSensorType GetBuiltInSensorType()
+        {
+            return BuiltInSensorType.RayPerceptionSensor;
         }
 
         /// <summary>

com.unity.ml-agents/Runtime/Sensors/Reflection/ReflectionSensorBase.cs

     /// <summary>
     /// Abstract base class for reflection-based sensors.
     /// </summary>
-    internal abstract class ReflectionSensorBase : ISensor
+    internal abstract class ReflectionSensorBase : ISensor, IBuiltInSensor
     {
         protected object m_Object;
 
         {
             return m_SensorName;
         }
+
+        /// <inheritdoc/>
+        public BuiltInSensorType GetBuiltInSensorType()
+        {
+            return BuiltInSensorType.ReflectionSensor;
+        }
+
     }
 }

com.unity.ml-agents/Runtime/Sensors/RenderTextureSensor.cs

     /// <summary>
     /// Sensor class that wraps a [RenderTexture](https://docs.unity3d.com/ScriptReference/RenderTexture.html) instance.
     /// </summary>
-    public class RenderTextureSensor : ISensor
+    public class RenderTextureSensor : ISensor, IBuiltInSensor
     {
         RenderTexture m_RenderTexture;
         bool m_Grayscale;
         {
             return m_CompressionType;
         }
+
+        /// <inheritdoc/>
+        public BuiltInSensorType GetBuiltInSensorType()
+        {
+            return BuiltInSensorType.RenderTextureSensor;
+        }
+
 
         /// <summary>
         /// Converts a RenderTexture to a 2D texture.

com.unity.ml-agents/Runtime/Sensors/StackingSensor.cs

     /// Internally, a circular buffer of arrays is used. The m_CurrentIndex represents the most recent observation.
     /// Currently, observations are stacked on the last dimension.
     /// </summary>
-    public class StackingSensor : ISparseChannelSensor
+    public class StackingSensor : ISparseChannelSensor, IBuiltInSensor
     {
         /// <summary>
         /// The wrapped sensor.
                 }
             }
             return compressionMapping;
+        }
+
+        /// <inheritdoc/>
+        public BuiltInSensorType GetBuiltInSensorType()
+        {
+            IBuiltInSensor wrappedBuiltInSensor = m_WrappedSensor as IBuiltInSensor;
+            return wrappedBuiltInSensor?.GetBuiltInSensorType() ?? BuiltInSensorType.Unknown;
         }
     }
 }

com.unity.ml-agents/Runtime/Sensors/VectorSensor.cs

     /// <summary>
     /// A sensor implementation for vector observations.
     /// </summary>
-    public class VectorSensor : ISensor
+    public class VectorSensor : ISensor, IBuiltInSensor
     {
         // TODO use float[] instead
         // TODO allow setting float[]
         public virtual SensorCompressionType GetCompressionType()
         {
             return SensorCompressionType.None;
+        }
+
+        /// <inheritdoc/>
+        public BuiltInSensorType GetBuiltInSensorType()
+        {
+            return BuiltInSensorType.VectorSensor;
         }
 
         void Clear()

com.unity.ml-agents/Tests/Editor/Analytics/InferenceAnalyticsTests.cs

             Assert.AreEqual(3, continuousEvent.ObservationSpecs[0].DimensionInfos.Length);
             Assert.AreEqual(20, continuousEvent.ObservationSpecs[0].DimensionInfos[0].Size);
             Assert.AreEqual("None", continuousEvent.ObservationSpecs[0].CompressionType);
+            Assert.AreEqual(Test3DSensor.k_BuiltInSensorType, continuousEvent.ObservationSpecs[0].BuiltInSensorType);
             Assert.AreNotEqual(null, continuousEvent.ModelHash);
 
             // Make sure nested fields get serialized

com.unity.ml-agents/Tests/Editor/ParameterLoaderTest.cs

             return Sensor.GetObservationShape();
         }
     }
-    public class Test3DSensor : ISensor
+    public class Test3DSensor : ISensor, IBuiltInSensor
+        // Dummy value for the IBuiltInSensor interface
+        public const int k_BuiltInSensorType = -42;
 
         public Test3DSensor(string name, int width, int height, int channels)
         {
         public string GetName()
         {
             return m_Name;
+        }
+
+        public BuiltInSensorType GetBuiltInSensorType()
+        {
+            return (BuiltInSensorType)k_BuiltInSensorType;
         }
     }
 

com.unity.ml-agents/Tests/Editor/Sensor/StackingSensorTests.cs

             {
                 return Mapping;
             }
+
         }
 
         [Test]
             var expected4 = sensor.CreateEmptyPNG();
             expected4 = expected4.Concat(Array.ConvertAll(new[] { 10f, 11f, 12f }, (z) => (byte)z)).ToArray();
             Assert.AreEqual(sensor.GetCompressedObservation(), expected4);
+        }
+
+        [Test]
+        public void TestStackingSensorBuiltInSensorType()
+        {
+            var dummySensor = new Dummy3DSensor();
+            dummySensor.Shape = new[] { 2, 2, 4 };
+            dummySensor.Mapping = new[] { 0, 1, 2, 3 };
+            var stackedDummySensor = new StackingSensor(dummySensor, 2);
+            Assert.AreEqual(stackedDummySensor.GetBuiltInSensorType(), BuiltInSensorType.Unknown);
+
+            var vectorSensor = new VectorSensor(4);
+            var stackedVectorSensor = new StackingSensor(vectorSensor, 4);
+            Assert.AreEqual(stackedVectorSensor.GetBuiltInSensorType(), BuiltInSensorType.VectorSensor);
         }
     }
 }

com.unity.ml-agents/Runtime/Sensors/IBuiltInSensor.cs

+namespace Unity.MLAgents.Sensors
+{
+    /// <summary>
+    /// Identifiers for "built in" sensor types.
+    /// These are only used for analytics, and should not be used for any runtime decisions.
+    ///
+    /// NOTE: Do not renumber these, since the values are used for analytics. Renaming is allowed though.
+    /// </summary>
+    public enum BuiltInSensorType
+    {
+        Unknown = 0,
+        VectorSensor = 1,
+        // Note that StackingSensor actually returns the wrapped sensor's type
+        StackingSensor = 2,
+        RayPerceptionSensor = 3,
+        ReflectionSensor = 4,
+        CameraSensor = 5,
+        RenderTextureSensor = 6,
+        BufferSensor = 7,
+        PhysicsBodySensor = 8,
+        Match3Sensor = 9,
+        GridSensor = 10
+    }
+
+    /// <summary>
+    /// Interface for sensors that are provided as part of ML-Agents.
+    /// User-implemented sensors don't need to use this interface.
+    /// </summary>
+    public interface IBuiltInSensor
+    {
+        /// <summary>
+        /// Return the corresponding BuiltInSensorType for the sensor.
+        /// </summary>
+        /// <returns>A BuiltInSensorType corresponding to the sensor.</returns>
+        BuiltInSensorType GetBuiltInSensorType();
+    }
+
+
+}

com.unity.ml-agents/Runtime/Sensors/IBuiltInSensor.cs.meta

+fileFormatVersion: 2
+guid: c0c4a98bf1c941b381917cb65209beee
+timeCreated: 1611096525