[MLA-345] float visual observations (#3148)

* pass shape to WriteAdapter

* handle floats on python side

* cleanup

* whitespace

* rename GetFloatObservationShape, support uncompressed in RenderTexture sensor

* numpy float32

* remove unused using

* Float sensor and unit test

* replace asserts with exceptions, docstrings

Author: Chris Elion

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

@@ -80,7 +80,7 @@ public TestSensor(string n)
             sensorName = n;
         }
 
-        public int[] GetFloatObservationShape()
+        public int[] GetObservationShape()
         {
             return new[] { 0 };
         }

UnitySDK/Assets/ML-Agents/Editor/Tests/Sensor/FloatVisualSensorTests.cs

@@ -0,0 +1,105 @@
+using NUnit.Framework;
+using UnityEngine;
+using MLAgents.Sensor;
+
+namespace MLAgents.Tests
+{
+    public class Float2DSensor : ISensor
+    {
+        public int Width { get; }
+        public int Height { get; }
+        string m_Name;
+        int[] m_Shape;
+        public float[,] floatData;
+
+        public Float2DSensor(int width, int height, string name)
+        {
+            Width = width;
+            Height = height;
+            m_Name = name;
+            m_Shape = new[] { height, width, 1 };
+            floatData = new float[Height, Width];
+        }
+
+        public Float2DSensor(float[,] floatData, string name)
+        {
+            this.floatData = floatData;
+            Height = floatData.GetLength(0);
+            Width = floatData.GetLength(1);
+            m_Name = name;
+            m_Shape = new[] { Height, Width, 1 };
+        }
+
+        public string GetName()
+        {
+            return m_Name;
+        }
+
+        public int[] GetObservationShape()
+        {
+            return m_Shape;
+        }
+
+        public byte[] GetCompressedObservation()
+        {
+            return null;
+        }
+
+        public int Write(WriteAdapter adapter)
+        {
+            using (TimerStack.Instance.Scoped("Float2DSensor.Write"))
+            {
+                for (var h = 0; h < Height; h++)
+                {
+                    for (var w = 0; w < Width; w++)
+                    {
+                        adapter[h, w, 0] = floatData[h, w];
+                    }
+                }
+                var numWritten = Height * Width;
+                return numWritten;
+            }
+        }
+
+        public void Update() { }
+
+        public SensorCompressionType GetCompressionType()
+        {
+            return SensorCompressionType.None;
+        }
+    }
+
+    public class FloatVisualSensorTests
+    {
+        [Test]
+        public void TestFloat2DSensorWrite()
+        {
+            var sensor = new Float2DSensor(3, 4, "floatsensor");
+            for (var h = 0; h < 4; h++)
+            {
+                for (var w = 0; w < 3; w++)
+                {
+                    sensor.floatData[h, w] = 3 * h + w;
+                }
+            }
+
+            var output = new float[12];
+            var writer = new WriteAdapter();
+            writer.SetTarget(output, sensor.GetObservationShape(), 0);
+            sensor.Write(writer);
+            for (var i = 0; i < 9; i++)
+            {
+                Assert.AreEqual(i, output[i]);
+            }
+        }
+
+        [Test]
+        public void TestFloat2DSensorExternalData()
+        {
+            var data = new float[4, 3];
+            var sensor = new Float2DSensor(data, "floatsensor");
+            Assert.AreEqual(sensor.Height, 4);
+            Assert.AreEqual(sensor.Width, 3);
+        }
+    }
+}

UnitySDK/Assets/ML-Agents/Editor/Tests/Sensor/FloatVisualSensorTests.cs.meta

@@ -12,7 +12,7 @@ public void TestCtor()
             ISensor wrapped = new VectorSensor(4);
             ISensor sensor = new StackingSensor(wrapped, 4);
             Assert.AreEqual("StackingSensor_size4_VectorSensor_size4", sensor.GetName());
-            Assert.AreEqual(sensor.GetFloatObservationShape(), new [] {16});
+            Assert.AreEqual(sensor.GetObservationShape(), new [] {16});
         }
 
         [Test]

UnitySDK/Assets/ML-Agents/Editor/Tests/Sensor/StackingSensorTests.cs

@@ -18,7 +18,7 @@ public static void CompareObservation(ISensor sensor, float[] expected)
             Assert.AreEqual(fill, output[0]);
 
             WriteAdapter writer = new WriteAdapter();
-            writer.SetTarget(output, 0);
+            writer.SetTarget(output, sensor.GetObservationShape(), 0);
 
             // Make sure WriteAdapter didn't touch anything
             Assert.AreEqual(fill, output[0]);

UnitySDK/Assets/ML-Agents/Editor/Tests/Sensor/VectorSensorTests.cs

@@ -15,25 +15,26 @@ public void TestWritesToIList()
         {
             WriteAdapter writer = new WriteAdapter();
             var buffer = new[] { 0f, 0f, 0f };
+            var shape = new[] { 3 };
 
-            writer.SetTarget(buffer, 0);
+            writer.SetTarget(buffer, shape, 0);
             // Elementwise writes
             writer[0] = 1f;
             writer[2] = 2f;
             Assert.AreEqual(new[] { 1f, 0f, 2f }, buffer);
 
             // Elementwise writes with offset
-            writer.SetTarget(buffer, 1);
+            writer.SetTarget(buffer, shape, 1);
             writer[0] = 3f;
             Assert.AreEqual(new[] { 1f, 3f, 2f }, buffer);
 
             // AddRange
-            writer.SetTarget(buffer, 0);
+            writer.SetTarget(buffer, shape, 0);
             writer.AddRange(new [] {4f, 5f});
             Assert.AreEqual(new[] { 4f, 5f, 2f }, buffer);
 
             // AddRange with offset
-            writer.SetTarget(buffer, 1);
+            writer.SetTarget(buffer, shape, 1);
             writer.AddRange(new [] {6f, 7f});
             Assert.AreEqual(new[] { 4f, 6f, 7f }, buffer);
         }
@@ -47,12 +48,13 @@ public void TestWritesToTensor()
                 valueType = TensorProxy.TensorType.FloatingPoint,
                 data = new Tensor(2, 3)
             };
-            writer.SetTarget(t, 0, 0);
+            var shape = new[] { 3 };
+            writer.SetTarget(t, shape, 0, 0);
             Assert.AreEqual(0f, t.data[0, 0]);
             writer[0] = 1f;
             Assert.AreEqual(1f, t.data[0, 0]);
 
-            writer.SetTarget(t, 1, 1);
+            writer.SetTarget(t, shape, 1, 1);
             writer[0] = 2f;
             writer[1] = 3f;
             // [0, 0] shouldn't change
@@ -67,7 +69,7 @@ public void TestWritesToTensor()
                 data = new Tensor(2, 3)
             };
 
-            writer.SetTarget(t, 1, 1);
+            writer.SetTarget(t, shape, 1, 1);
             writer.AddRange(new [] {-1f, -2f});
             Assert.AreEqual(0f, t.data[0, 0]);
             Assert.AreEqual(0f, t.data[0, 1]);
@@ -87,11 +89,13 @@ public void TestWritesToTensor3D()
                 data = new Tensor(2, 2, 2, 3)
             };
 
-            writer.SetTarget(t, 0, 0);
+            var shape = new[] { 2, 2, 3 };
+
+            writer.SetTarget(t, shape,  0, 0);
             writer[1, 0, 1] = 1f;
             Assert.AreEqual(1f, t.data[0, 1, 0, 1]);
 
-            writer.SetTarget(t, 0, 1);
+            writer.SetTarget(t, shape, 0, 1);
             writer[1, 0, 0] = 2f;
             Assert.AreEqual(2f, t.data[0, 1, 0, 1]);
         }