Resolving conflicts

config/ppo/GridWorld.yaml

       learning_rate_schedule: linear
     network_settings:
       normalize: false
-      hidden_units: 256
+      hidden_units: 100
       num_layers: 1
       vis_encode_type: simple
     reward_signals:

Project/Assets/ML-Agents/Examples/GridWorld/TFModels.meta

 fileFormatVersion: 2
 guid: b9c5639f5544e49d785119b8a28305bd
 folderAsset: yes
-timeCreated: 1505509039
-licenseType: Pro
+  externalObjects: {}
   userData: 
   assetBundleName: 
   assetBundleVariant: 

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

 using UnityEngine;
 using System.Linq;
 using Unity.MLAgents;
+using Unity.MLAgents.Sensors;
 using Unity.MLAgents.Actuators;
 using UnityEngine.Rendering;
 using UnityEngine.Serialization;
         "RenderTexture as observations.")]
     public Camera renderCamera;
 
+    VectorSensorComponent m_GoalSensor;
+
+    public enum GridGoal
+    {
+        Plus,
+        Ex,
+    }
+
+    public GameObject GreenBottom;
+    public GameObject RedBottom;
+
+    GridGoal m_CurrentGoal;
+
+    public GridGoal CurrentGoal
+    {
+        get { return m_CurrentGoal; }
+        set
+        {
+            switch (value)
+            {
+                case GridGoal.Plus:
+                    GreenBottom.SetActive(true);
+                    RedBottom.SetActive(false);
+                    break;
+                case GridGoal.Ex:
+                    GreenBottom.SetActive(false);
+                    RedBottom.SetActive(true);
+                    break;
+            }
+            m_CurrentGoal = value;
+        }
+    }
+
     [Tooltip("Selecting will turn on action masking. Note that a model trained with action " +
         "masking turned on may not behave optimally when action masking is turned off.")]
     public bool maskActions = true;
 
     public override void Initialize()
     {
+        m_GoalSensor = this.GetComponent<VectorSensorComponent>();
+    }
+
+    public override void CollectObservations(VectorSensor sensor)
+    {
+        Array values = Enum.GetValues(typeof(GridGoal));
+        int goalNum = (int)CurrentGoal;
+        m_GoalSensor.GetSensor().AddOneHotObservation(goalNum, values.Length);
     }
 
     public override void WriteDiscreteActionMask(IDiscreteActionMask actionMask)
 
             if (hit.Where(col => col.gameObject.CompareTag("goal")).ToArray().Length == 1)
             {
-                SetReward(1f);
+                ProvideReward(GridGoal.Plus);
-                SetReward(-1f);
+                ProvideReward(GridGoal.Ex);
+        }
+    }
+
+    private void ProvideReward(GridGoal hitObject)
+    {
+        if (CurrentGoal == hitObject)
+        {
+            SetReward(1f);
+        }
+        else
+        {
+            SetReward(-1f);
         }
     }
 
     public override void OnEpisodeBegin()
     {
         area.AreaReset();
+        Array values = Enum.GetValues(typeof(GridGoal));
+        CurrentGoal = (GridGoal)values.GetValue(UnityEngine.Random.Range(0, values.Length));
     }
 
     public void FixedUpdate()

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

 
     Camera m_AgentCam;
 
-    public GameObject goalPref;
-    public GameObject pitPref;
+    public GameObject GreenPref;
+    public GameObject RedPref;
-    public int numberOfObstacles = 1;
+    public int numberOfGreen = 1;
+    public int numberOfRed = 1;
 
     GameObject m_Plane;
     GameObject m_Sn;
     {
         m_ResetParams = Academy.Instance.EnvironmentParameters;
 
-        m_Objects = new[] { goalPref, pitPref };
+        m_Objects = new[] { GreenPref, RedPref };
 
         m_AgentCam = transform.Find("agentCam").GetComponent<Camera>();
 
         transform.position = m_InitialPosition * (m_ResetParams.GetWithDefault("gridSize", 5f) + 1);
         var playersList = new List<int>();
 
-        for (var i = 0; i < (int)m_ResetParams.GetWithDefault("numObstacles", numberOfObstacles); i++)
+        for (var i = 0; i < (int)m_ResetParams.GetWithDefault("numGreenGoals", numberOfGreen); i++)
-            playersList.Add(1);
+            playersList.Add(0);
-        for (var i = 0; i < (int)m_ResetParams.GetWithDefault("numGoals", 1f); i++)
+        for (var i = 0; i < (int)m_ResetParams.GetWithDefault("numRedGoals", numberOfRed); i++)
-            playersList.Add(0);
+            playersList.Add(1);
         }
         players = playersList.ToArray();
 

docs/Learning-Environment-Examples.md

 
 ![GridWorld](images/gridworld.png)
 
-- Set-up: A version of the classic grid-world task. Scene contains agent, goal,
+- Set-up: A version of the grid-world task. Scene contains agent, goal,
-- Goal: The agent must navigate the grid to the goal while avoiding the
-  obstacles.
+- Goal: The agent must navigate the grid to the appropriate goal while
+  avoiding the obstacles.
-  - +1.0 if the agent navigates to the goal position of the grid (episode ends).
-  - -1.0 if the agent navigates to an obstacle (episode ends).
+  - +1.0 if the agent navigates to the correct goal (episode ends).
+  - -1.0 if the agent navigates to an incorrect goal (episode ends).
 - Behavior Parameters:
   - Vector Observation space: None
   - Actions: 1 discrete action branch with 5 actions, corresponding to movement in
     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.
-- Float Properties: Three, corresponding to grid size, number of obstacles, and
-  number of goals.
+  - Goal Signal : A one hot vector corresponding to which color is the correct goal
+  for the Agent
+- Float Properties: Three, corresponding to grid size, number of green goals, and
+  number of red goals.
 - Benchmark Mean Reward: 0.8
 
 ## Push Block

com.unity.ml-agents/Tests/Runtime/Sensor/RenderTextureSensorTests.cs

                 }
             }
         }
+
+        [Test]
+        public void TestObservationType()
+        {
+            var width = 24;
+            var height = 16;
+            var camera = Camera.main;
+            var sensor = new CameraSensor(camera, width, height, true, "TestCameraSensor", SensorCompressionType.None);
+            var spec = sensor.GetObservationSpec();
+            Assert.AreEqual((int)spec.ObservationType, (int)ObservationType.Default);
+            sensor = new CameraSensor(camera, width, height, true, "TestCameraSensor", SensorCompressionType.None, ObservationType.Default);
+            spec = sensor.GetObservationSpec();
+            Assert.AreEqual((int)spec.ObservationType, (int)ObservationType.Default);
+            sensor = new CameraSensor(camera, width, height, true, "TestCameraSensor", SensorCompressionType.None, ObservationType.GoalSignal);
+            spec = sensor.GetObservationSpec();
+            Assert.AreEqual((int)spec.ObservationType, (int)ObservationType.GoalSignal);
+        }
     }
 }

com.unity.ml-agents/Tests/Editor/Sensor.meta

+fileFormatVersion: 2
+guid: 557a9e00396ed4cecb329bffb6912365
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Project/Assets/ML-Agents/Examples/GridWorld/TFModels/GridWorld.onnx.meta

+fileFormatVersion: 2
+guid: 255872f7c70ca4901b80bd5aed4a630f
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: main obj
+    11400002: model data
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 683b6cb6d0a474744822c888b46772c9, type: 3}
+  optimizeModel: 1
+  forceArbitraryBatchSize: 1
+  treatErrorsAsWarnings: 0
+  importMode: 1

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

+using System;
+using NUnit.Framework;
+using UnityEngine;
+using Unity.MLAgents.Sensors;
+
+namespace Unity.MLAgents.Tests
+{
+
+    [TestFixture]
+    public class CameraSensorTest
+    {
+        [Test]
+        public void TestCameraSensor()
+        {
+            foreach (var grayscale in new[] { true, false })
+            {
+                foreach (SensorCompressionType compression in Enum.GetValues(typeof(SensorCompressionType)))
+                {
+                    var width = 24;
+                    var height = 16;
+                    var camera = Camera.main;
+                    var sensor = new CameraSensor(camera, width, height, grayscale, "TestCameraSensor", compression);
+
+                    var obsWriter = new ObservationWriter();
+                    var obs = sensor.GetObservationProto(obsWriter);
+
+                    Assert.AreEqual((int)compression, (int)obs.CompressionType);
+                    var expectedShape = new[] { height, width, grayscale ? 1 : 3 };
+                    Assert.AreEqual(expectedShape, obs.Shape);
+                }
+            }
+        }
+
+        [Test]
+        public void TestObservationType()
+        {
+            var width = 24;
+            var height = 16;
+            var camera = Camera.main;
+            var sensor = new CameraSensor(camera, width, height, true, "TestCameraSensor", SensorCompressionType.None);
+            var spec = sensor.GetObservationSpec();
+            Assert.AreEqual((int)spec.ObservationType, (int)ObservationType.Default);
+            sensor = new CameraSensor(camera, width, height, true, "TestCameraSensor", SensorCompressionType.None, ObservationType.Default);
+            spec = sensor.GetObservationSpec();
+            Assert.AreEqual((int)spec.ObservationType, (int)ObservationType.Default);
+            sensor = new CameraSensor(camera, width, height, true, "TestCameraSensor", SensorCompressionType.None, ObservationType.GoalSignal);
+            spec = sensor.GetObservationSpec();
+            Assert.AreEqual((int)spec.ObservationType, (int)ObservationType.GoalSignal);
+        }
+    }
+}

com.unity.ml-agents/Tests/Editor/Sensor/CameraSensorTest.cs.meta

+fileFormatVersion: 2
+guid: b38f70e2664dc462b8ad7997eacd0168
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: