public void TestRemotePolicyEvent()
        {
            var behaviorName = "testBehavior";
            var sensor1      = new Test3DSensor("SensorA", 21, 20, 3);
            var sensor2      = new Test3DSensor("SensorB", 20, 22, 3);
            var sensors      = new List <ISensor> {
                sensor1, sensor2
            };

            var actionSpec = ActionSpec.MakeContinuous(2);

            var vectorActuator = new VectorActuator(null, actionSpec, "test'");
            var actuators      = new IActuator[] { vectorActuator };

            var remotePolicyEvent = TrainingAnalytics.GetEventForRemotePolicy(behaviorName, sensors, actionSpec, actuators);

            // The behavior name should be hashed, not pass-through.
            Assert.AreNotEqual(behaviorName, remotePolicyEvent.BehaviorName);

            Assert.AreEqual(2, remotePolicyEvent.ObservationSpecs.Count);
            Assert.AreEqual(3, remotePolicyEvent.ObservationSpecs[0].DimensionInfos.Length);
            Assert.AreEqual(20, remotePolicyEvent.ObservationSpecs[0].DimensionInfos[0].Size);
            Assert.AreEqual(0, remotePolicyEvent.ObservationSpecs[0].ObservationType);
            Assert.AreEqual("None", remotePolicyEvent.ObservationSpecs[0].CompressionType);
            Assert.AreEqual(Test3DSensor.k_BuiltInSensorType, remotePolicyEvent.ObservationSpecs[0].BuiltInSensorType);

            Assert.AreEqual(2, remotePolicyEvent.ActionSpec.NumContinuousActions);
            Assert.AreEqual(0, remotePolicyEvent.ActionSpec.NumDiscreteActions);

            Assert.AreEqual(2, remotePolicyEvent.ActuatorInfos[0].NumContinuousActions);
            Assert.AreEqual(0, remotePolicyEvent.ActuatorInfos[0].NumDiscreteActions);
        }
        public void TestResetData()
        {
            var ar = new TestActionReceiver();
            var va = new VectorActuator(ar, ActionSpec.MakeDiscrete(1, 2, 3), "name");

            var discreteActions = new[] { 0, 1, 1 };
            var ab = new ActionBuffers(ActionSegment <float> .Empty,
                                       new ActionSegment <int>(discreteActions, 0, 3));

            va.OnActionReceived(ab);
        }
        public void TestConstruct()
        {
            var ar = new TestActionReceiver();
            var va = new VectorActuator(ar, ActionSpec.MakeDiscrete(1, 2, 3), "name");

            Assert.IsTrue(va.ActionSpec.NumDiscreteActions == 3);
            Assert.IsTrue(va.ActionSpec.SumOfDiscreteBranchSizes == 6);
            Assert.IsTrue(va.ActionSpec.NumContinuousActions == 0);

            var va1 = new VectorActuator(ar, ActionSpec.MakeContinuous(4), "name");

            Assert.IsTrue(va1.ActionSpec.NumContinuousActions == 4);
            Assert.IsTrue(va1.ActionSpec.SumOfDiscreteBranchSizes == 0);
            Assert.AreEqual(va1.Name, "name-Continuous");
        }
        public void TestConstruct()
        {
            var ar = new TestActionReceiver();
            var va = new VectorActuator(ar, new[] { 1, 2, 3 }, SpaceType.Discrete, "name");

            Assert.IsTrue(va.ActionSpec.NumDiscreteActions == 3);
            Assert.IsTrue(va.ActionSpec.SumOfDiscreteBranchSizes == 6);
            Assert.IsTrue(va.ActionSpec.NumContinuousActions == 0);

            var va1 = new VectorActuator(ar, new[] { 4 }, SpaceType.Continuous, "name");

            Assert.IsTrue(va1.ActionSpec.NumContinuousActions == 4);
            Assert.IsTrue(va1.ActionSpec.SumOfDiscreteBranchSizes == 0);
            Assert.AreEqual(va1.Name, "name-Continuous");
        }
        public void TestOnActionReceived()
        {
            var ar = new TestActionReceiver();
            var va = new VectorActuator(ar, ActionSpec.MakeDiscrete(1, 2, 3), "name");

            var discreteActions = new[] { 0, 1, 1 };
            var ab = new ActionBuffers(ActionSegment <float> .Empty,
                                       new ActionSegment <int>(discreteActions, 0, 3));

            va.OnActionReceived(ab);

            Assert.AreEqual(ar.LastActionBuffers, ab);
            va.ResetData();
            Assert.AreEqual(va.ActionBuffers.ContinuousActions, ActionSegment <float> .Empty);
            Assert.AreEqual(va.ActionBuffers.DiscreteActions, ActionSegment <int> .Empty);
        }
        public void TestWriteDiscreteActionMask()
        {
            var ar   = new TestActionReceiver();
            var va   = new VectorActuator(ar, ActionSpec.MakeDiscrete(1, 2, 3), "name");
            var bdam = new ActuatorDiscreteActionMask(new[] { va }, 6, 3);

            var groundTruthMask = new[] { false, true, false, false, true, true };

            ar.Branch = 1;
            ar.Mask   = new[] { 0 };
            va.WriteDiscreteActionMask(bdam);
            ar.Branch = 2;
            ar.Mask   = new[] { 1, 2 };
            va.WriteDiscreteActionMask(bdam);

            Assert.IsTrue(groundTruthMask.SequenceEqual(bdam.GetMask()));
        }
        public void TestModelEvent()
        {
            var sensors = new List <ISensor> {
                sensor_21_20_3.Sensor, sensor_20_22_3.Sensor
            };
            var behaviorName = "continuousModel";
            var actionSpec   = GetContinuous2vis8vec2actionActionSpec();

            var vectorActuator = new VectorActuator(null, actionSpec, "test'");
            var actuators      = new IActuator[] { vectorActuator };

            var continuousEvent = InferenceAnalytics.GetEventForModel(
                continuousONNXModel, behaviorName,
                InferenceDevice.CPU, sensors, actionSpec,
                actuators
                );

            // The behavior name should be hashed, not pass-through.
            Assert.AreNotEqual(behaviorName, continuousEvent.BehaviorName);

            Assert.AreEqual(2, continuousEvent.ActionSpec.NumContinuousActions);
            Assert.AreEqual(0, continuousEvent.ActionSpec.NumDiscreteActions);
            Assert.AreEqual(2, continuousEvent.ObservationSpecs.Count);
            Assert.AreEqual(3, continuousEvent.ObservationSpecs[0].DimensionInfos.Length);
            Assert.AreEqual(20, continuousEvent.ObservationSpecs[0].DimensionInfos[0].Size);
            Assert.AreEqual(0, continuousEvent.ObservationSpecs[0].ObservationType);
            Assert.AreEqual((int)DimensionProperty.TranslationalEquivariance, continuousEvent.ObservationSpecs[0].DimensionInfos[0].Flags);
            Assert.AreEqual((int)DimensionProperty.None, continuousEvent.ObservationSpecs[0].DimensionInfos[2].Flags);
            Assert.AreEqual("None", continuousEvent.ObservationSpecs[0].CompressionType);
            Assert.AreEqual(Test3DSensor.k_BuiltInSensorType, continuousEvent.ObservationSpecs[0].BuiltInSensorType);
            Assert.AreEqual((int)BuiltInActuatorType.VectorActuator, continuousEvent.ActuatorInfos[0].BuiltInActuatorType);
            Assert.AreNotEqual(null, continuousEvent.ModelHash);

            // Make sure nested fields get serialized
            var jsonString = JsonUtility.ToJson(continuousEvent, true);

            Assert.IsTrue(jsonString.Contains("ObservationSpecs"));
            Assert.IsTrue(jsonString.Contains("ActionSpec"));
            Assert.IsTrue(jsonString.Contains("NumDiscreteActions"));
            Assert.IsTrue(jsonString.Contains("SensorName"));
            Assert.IsTrue(jsonString.Contains("Flags"));
            Assert.IsTrue(jsonString.Contains("ActuatorInfos"));
        }