public void FinalizeForgettingKnowledge(ActorKnowledge forget, ushort step)
{
if (forget is null)
{
throw new ArgumentNullException(nameof(forget));
}
var forgetBits = forget.CloneBits();
var agentKnowledge = _entityKnowledgeNetwork.Edge <ActorKnowledge>(_agentId, forget.Target);
switch (InternalCharacteristics.ForgettingSelectingMode)
{
case ForgettingSelectingMode.Random:
for (byte i = 0; i < forgetBits.Length; i++)
{
AgentKnowledgeForget(agentKnowledge, i, forgetBits.GetBit(i), step);
}
break;
case ForgettingSelectingMode.Oldest:
AgentKnowledgeForgetOldest(agentKnowledge, NextRate(), step);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Agent learn _knowledgeBits at a learningRate
/// OnAfterLearning event is triggered if learning occurs, you can subscribe to this event to treat the new learning
/// </summary>
/// <param name="actorKnowledge"></param>
/// <param name="index"></param>
/// <param name="learningRate"></param>
/// <param name="step"></param>
/// <returns>The real learning value</returns>
public float AgentKnowledgeLearn(ActorKnowledge actorKnowledge, byte index, float learningRate, ushort step)
{
if (actorKnowledge == null)
{
throw new ArgumentNullException(nameof(actorKnowledge));
}
if (Math.Abs(learningRate) < Tolerance)
{
return(0);
}
var realLearning = actorKnowledge.KnowledgeBits.UpdateBit(index, learningRate, step);
CumulativeLearning += realLearning;
if (!(realLearning > Tolerance))
{
return(realLearning);
}
var learningEventArgs = new LearningEventArgs(actorKnowledge.Target, index, realLearning);
OnAfterLearning?.Invoke(this, learningEventArgs);
return(realLearning);
}
public void Initialize()
{
_cognitiveArchitecture = new CognitiveArchitecture
{
KnowledgeAndBeliefs = { HasBelief = true, HasKnowledge = true },
MessageContent = { CanReceiveBeliefs = true, CanReceiveKnowledge = true },
InternalCharacteristics = { CanLearn = true, CanForget = true, CanInfluenceOrBeInfluence = true }
};
var modelEntity = new KnowledgeModelEntity {
On = true
};
_knowledgeModel = new KnowledgeModel(_agentId, modelEntity, _cognitiveArchitecture, Network,
RandomGenerator.RandomBinary);
_knowledge = new Knowledge(Network, MainOrganization.Models, "1", 1);
_knowledge1 = new Knowledge(Network, MainOrganization.Models, "1", 1);
_knowledge2 = new Knowledge(Network, MainOrganization.Models, "1", 1);
_knowledge3 = new Knowledge(Network, MainOrganization.Models, "1", 1);
_taskBits.SetMandatory(new byte[] { 0 });
_taskBits.SetRequired(new byte[] { 0 });
_actorKnowledge0 = new ActorKnowledge(_agentId, _knowledge.EntityId, _knowledge0Bits, 0, -1);
_actorKnowledge1 = new ActorKnowledge(_agentId, _knowledge1.EntityId, _knowledge1Bits, 0, -1);
_actorKnowledge01 = new ActorKnowledge(_agentId, _knowledge2.EntityId, _knowledge01Bits, 0, -1);
_actorKnowledgeFloat = new ActorKnowledge(_agentId, _knowledge3.EntityId, _knowledgeFloatBits, 0, -1);
}
/// <summary>
/// Agent forget _knowledgeBits at a forgetRate coming from ForgettingModel
/// If forgetRate is below the minimumLevel of KnowledgeBit that should stay, the forgetRate is adjusted to stay at the
/// minimumLevel
/// </summary>
/// <param name="actorKnowledge"></param>
/// <param name="index">Index of the knowledgeBit</param>
/// <param name="forgetRate">value of the decrement</param>
/// <param name="step"></param>
/// <returns>The real forgetting value</returns>
public float AgentKnowledgeForget(ActorKnowledge actorKnowledge, byte index, float forgetRate, ushort step)
{
if (actorKnowledge == null)
{
throw new ArgumentNullException(nameof(actorKnowledge));
}
var value = actorKnowledge.KnowledgeBits.GetBit(index) - forgetRate;
if (value < actorKnowledge.MinimumKnowledge)
{
// forgetRate > 0
forgetRate = Math.Max(0, actorKnowledge.KnowledgeBits.GetBit(index) - actorKnowledge.MinimumKnowledge);
}
if (Math.Abs(forgetRate) < Tolerance)
{
return(0);
}
var realForgetting = actorKnowledge.KnowledgeBits.UpdateBit(index, -forgetRate, step);
CumulativeForgetting += realForgetting;
return(realForgetting);
}
public void InitializeForgettingProcessTest1()
{
InitializeModel(true, 0);
_forgettingModel.InternalCharacteristics.ForgettingMean = 1;
ActorKnowledge.CreateInstance(Network.ActorKnowledge, _agentId, _knowledge.EntityId, new float[] { 0 }, 0, -1);
_forgettingModel.InitializeForgettingProcess();
Assert.AreEqual(1, _forgettingModel.ForgettingExpertise.Count);
}
public void InitializeAgentKnowledgeTest()
{
var actorKnowledgeNo = new ActorKnowledge(_agentId, _knowledge.EntityId, KnowledgeLevel.NoKnowledge, 0, -1);
Assert.IsTrue(actorKnowledgeNo.KnowledgeBits.IsNull);
_knowledgeModel.InitializeActorKnowledge(actorKnowledgeNo, false, 0);
Assert.IsFalse(actorKnowledgeNo.KnowledgeBits.IsNull);
Assert.AreEqual(0, actorKnowledgeNo.KnowledgeBits.GetBit(0));
}
public void HasTest()
{
float[] bits = { 0, 1 };
var knowledgeBits = new KnowledgeBits(bits, 0, -1);
ActorKnowledge.CreateInstance(Network.ActorKnowledge, _agentId, _knowledge.EntityId, knowledgeBits);
Assert.IsFalse(_knowledgeModel.KnowsEnough(_knowledge.EntityId, 0, 0.1F, 0));
Assert.IsTrue(_knowledgeModel.KnowsEnough(_knowledge.EntityId, 1, 0.1F, 0));
}
public void ForgetTest1()
{
InitializeModel(true, 0);
var actorKnowledge = new ActorKnowledge(_agentId, _knowledge.EntityId, new float[] { 1, 1 }, 0, -1);
var realForget = _forgettingModel.AgentKnowledgeForget(actorKnowledge, 0, 2, 0);
Assert.AreEqual(0, actorKnowledge.GetKnowledgeBit(0));
Assert.AreEqual(-1, realForget);
}
/// <summary>
/// Forget knowledgeBits based on knowledgeBits.LastTouched and timeToLive value
/// </summary>
public static void ForgettingProcess(ActorKnowledge actorKnowledge, float forgettingRate, ushort step)
{
if (actorKnowledge == null)
{
throw new ArgumentNullException(nameof(actorKnowledge));
}
actorKnowledge.KnowledgeBits.ForgetOldest(forgettingRate, step);
}
/// <summary>
/// Add an agentId's Knowledge to the network
/// </summary>
/// <param name="knowledgeId"></param>
/// <param name="knowledgeBits"></param>
/// <param name="minimumKnowledge"></param>
/// <param name="timeToLive"></param>
public void AddKnowledge(IAgentId knowledgeId, float[] knowledgeBits, float minimumKnowledge, short timeToLive)
{
if (!On || !_knowledgeAndBeliefs.HasKnowledge)
{
return;
}
ActorKnowledge.CreateInstance(_actorKnowledgeNetwork, _agentId, knowledgeId, knowledgeBits, minimumKnowledge, timeToLive);
}
public void LearnByDoingTest0()
{
_learningModel.On = false;
var actorKnowledge = new ActorKnowledge(Network.ActorKnowledge, _agentId, _knowledge.EntityId, new float[] { 0 }, 0, -1);
var realLearning = _learningModel.LearnByDoing(_knowledge.EntityId, 0, 0, -1, 0);
Assert.AreEqual(0, actorKnowledge.GetKnowledgeSum());
Assert.AreEqual(0, realLearning);
}
public void AddBeliefsTest1()
{
_cognitiveArchitecture.KnowledgeAndBeliefs.HasBelief = true;
var actorKnowledge = new ActorKnowledge(_agentId, _knowledge.EntityId, new float[] { 0 }, 0, -1);
var expertise = new List <IEntityKnowledge> {
actorKnowledge
};
Assert.ThrowsException <NullReferenceException>(() => _beliefsModel.AddBeliefsFromKnowledge(expertise));
}
public void AddBeliefsTest()
{
_cognitiveArchitecture.KnowledgeAndBeliefs.HasBelief = false;
var actorKnowledge = new ActorKnowledge(_agentId, _knowledge.EntityId, new float[] { 0 }, 0, -1);
var expertise = new List <IEntityKnowledge> {
actorKnowledge
};
_beliefsModel.AddBeliefsFromKnowledge(expertise);
Assert.IsFalse(Network.ActorBelief.Exists(_agentId, actorKnowledge.Target));
}
public void SetForgettingKnowledgeTest()
{
var knowledgeBits = new float[] { 1 };
var actorKnowledge = new ActorKnowledge(_agentId, _knowledge.EntityId, knowledgeBits, 0, -1);
InitializeModel(true, 0);
_forgettingModel.InternalCharacteristics.ForgettingMean = 0;
var forgetting = _forgettingModel.InitializeForgettingKnowledge(actorKnowledge);
Assert.AreEqual(0, forgetting.GetKnowledgeBit(0));
}
public void FinalizeForgettingProcessTest()
{
InitializeModel(true, 0);
_forgettingModel.InternalCharacteristics.ForgettingMean = 0;
_forgettingModel.InternalCharacteristics.PartialForgettingRate = 1;
var actorKnowledge = new ActorKnowledge(Network.ActorKnowledge, _agentId, _knowledge.EntityId, new float[] { 1 }, 0, -1);
_forgettingModel.InitializeForgettingProcess();
_forgettingModel.FinalizeForgettingProcess(0);
Assert.AreEqual(1, actorKnowledge.GetKnowledgeSum());
}
/// <summary>
/// Forget knowledgeBits based on knowledgeBits.LastTouched and timeToLive value
/// </summary>
/// <param name="actorKnowledge"></param>
/// <param name="forgettingRate"></param>
/// <param name="step"></param>
/// <returns>The real forgetting value</returns>
public float AgentKnowledgeForgetOldest(ActorKnowledge actorKnowledge, float forgettingRate, ushort step)
{
if (actorKnowledge == null)
{
throw new ArgumentNullException(nameof(actorKnowledge));
}
var realForgetting = actorKnowledge.KnowledgeBits.ForgetOldest(forgettingRate, step);
CumulativeForgetting += realForgetting;
return(realForgetting);
}
public void Initialize()
{
var agentId = new AgentId(1, 1);
_knowledge = new Knowledge(Network, MainOrganization.Models, "0", 10);
_knowledge1 = new Knowledge(Network, MainOrganization.Models, "1", 10);
_knowledge2 = new Knowledge(Network, MainOrganization.Models, "2", 10);
_actorKnowledge0 = new ActorKnowledge(agentId, _knowledge.EntityId, _knowledge0Bits, 0, -1);
_actorKnowledge1 = new ActorKnowledge(agentId, _knowledge1.EntityId, _knowledge1Bits, 0, -1);
_actorKnowledge01 = new ActorKnowledge(agentId, _knowledge2.EntityId, _knowledge01Bits, 0, -1);
_actorKnowledge = new ActorKnowledge(agentId, _knowledge.EntityId, KnowledgeLevel.BasicKnowledge, 0, -1);
}
public void AddExpertiseTest1()
{
_cognitiveArchitecture.KnowledgeAndBeliefs.HasKnowledge = true;
_cognitiveArchitecture.KnowledgeAndBeliefs.HasBelief = true;
var actorKnowledge = new ActorKnowledge(_agentId, _knowledge.EntityId, new float[] { 0 }, 0, -1);
var expertise = new List <IEntityKnowledge> {
actorKnowledge
};
_knowledgeModel.AddExpertise(expertise);
Assert.AreEqual(1, Network.ActorKnowledge.EdgesFilteredBySource(_agentId).Count());
}
public void InitializeKnowledge(IAgentId knowledgeId, ushort step)
{
if (ExistsKnowledge(knowledgeId))
{
return;
}
var knowledge = MetaNetwork.Knowledge.GetEntity <Knowledge>(knowledgeId);
var resourceKnowledge = new ActorKnowledge(MetaNetwork.ResourceKnowledge, EntityId, knowledgeId, KnowledgeLevel.NoKnowledge, 0, TimeToLive);
resourceKnowledge.InitializeWith0(knowledge.Length, step);
}
public void FinalizeForgettingProcessTest1()
{
var actorKnowledge = new ActorKnowledge(Network.ActorKnowledge, _agentId, _knowledge.EntityId, new float[] { 1 }, 0, -1);
InitializeModel(true, 0);
_forgettingModel.InternalCharacteristics.ForgettingMean = 1;
// ForgettingRate < minimumRemainingLevel
_forgettingModel.InternalCharacteristics.PartialForgettingRate = 0.1F;
_forgettingModel.InternalCharacteristics.PartialForgetting = true;
_forgettingModel.InitializeForgettingProcess();
_forgettingModel.FinalizeForgettingProcess(0);
Assert.AreEqual(0.9F, actorKnowledge.GetKnowledgeSum());
}
public void FinalizeForgettingKnowledgeTest()
{
var actorKnowledge = new ActorKnowledge(Network.ActorKnowledge, _agentId, _knowledge.EntityId, new float[] { 1 }, 0, -1);
InitializeModel(true, 0);
// ForgettingBits value > minimumRemainingLevel
var forgettingBits = new[] { 0.1F };
var forgetting = new ActorKnowledge(_agentId, _knowledge.EntityId, forgettingBits, 0, -1);
_forgettingModel.FinalizeForgettingKnowledge(forgetting, 0);
// Knowledge has been forgotten
Assert.AreEqual(0.9F, actorKnowledge.GetKnowledgeBit(0));
}
public void SetForgettingKnowledgeTest3()
{
var knowledgeBits = new float[] { 1 };
var actorKnowledge = new ActorKnowledge(_agentId, _knowledge.EntityId, knowledgeBits, 0, -1);
InitializeModel(true, 0);
_forgettingModel.InternalCharacteristics.ForgettingMean = 1;
_forgettingModel.InternalCharacteristics.ForgettingSelectingMode = ForgettingSelectingMode.Random;
_forgettingModel.InternalCharacteristics.PartialForgetting = true;
var forgetting = _forgettingModel.InitializeForgettingKnowledge(actorKnowledge);
Assert.AreEqual(_forgettingModel.InternalCharacteristics.PartialForgettingRate,
forgetting.GetKnowledgeBit(0));
}
public void CheckKnowledgeTest1()
{
var mandatoryCheck = false;
var requiredCheck = false;
byte mandatoryIndex = 0;
byte requiredIndex = 0;
_murphy.On = true;
ActorKnowledge.CreateInstance(Network.ActorKnowledge, Uid1, _knowledge.EntityId, new float[] { 0 }, 0, -1);
_murphy.CheckKnowledge(_knowledge.EntityId, _taskBits, _knowledgeModel, ref mandatoryCheck,
ref requiredCheck, ref mandatoryIndex,
ref requiredIndex, 0);
Assert.IsFalse(mandatoryCheck && requiredCheck);
}
public void UpdateForgettingKnowledgeTest()
{
var forgettingBits = new float[] { 1 };
var forgetting = new ActorKnowledge(_agentId, _knowledge.EntityId, forgettingBits, 0, -1);
InitializeModel(true, 0);
_forgettingModel.ForgettingExpertise.Add(forgetting);
// working on the index 0 today
var workingBits = new byte[] { 0 };
_forgettingModel.UpdateForgettingProcess(new AgentId(2, 1), workingBits);
// ForgettingBits should not be updated because the KnowledgeId is not the same
Assert.AreEqual(1, forgetting.GetKnowledgeBit(0));
}
public void UpdateForgettingKnowledgeTest1()
{
var forgettingBits = new float[] { 1 };
var forgetting = new ActorKnowledge(_agentId, _knowledge.EntityId, forgettingBits, 0, -1);
InitializeModel(true, 0);
_forgettingModel.ForgettingExpertise.Add(forgetting);
// working on the index 0 today
var workingBits = new byte[] { 0 };
_forgettingModel.UpdateForgettingProcess(_knowledge.EntityId, workingBits);
// ForgettingBits should be set to 0
Assert.AreEqual(0, forgetting.GetKnowledgeBit(0));
}
public void AddBeliefsTest2()
{
_cognitiveArchitecture.KnowledgeAndBeliefs.HasBelief = true;
var actorKnowledge = new ActorKnowledge(_agentId, _knowledge.EntityId, new float[] { 0 }, 0, -1);
Belief.CreateInstance(Network, _knowledge, _knowledge.Length, RandomGenerator.RandomUniform,
BeliefWeightLevel.RandomWeight);
var expertise = new List <IEntityKnowledge> {
actorKnowledge
};
_beliefsModel.AddBeliefsFromKnowledge(expertise);
Assert.IsTrue(Network.ActorBelief.ExistsSource(_agentId));
Assert.AreEqual(2, Network.ActorBelief.EdgesFilteredBySourceCount(_agentId));
}
/// <summary>
/// Initialize the forgetting knowledge process with a random Selecting mode
/// </summary>
/// <param name="actorKnowledge"></param>
/// <param name="nextForgettingRate"></param>
/// <returns></returns>
public float[] InitializeForgettingKnowledgeRandom(ActorKnowledge actorKnowledge, float nextForgettingRate)
{
if (actorKnowledge is null)
{
throw new ArgumentNullException(nameof(actorKnowledge));
}
var forgettingKnowledgeBits = ContinuousUniform.Samples(actorKnowledge.Length, 0, 1);
var threshold = NextMean();
for (byte i = 0; i < actorKnowledge.Length; i++)
{
forgettingKnowledgeBits[i] = forgettingKnowledgeBits[i] < threshold ? nextForgettingRate : 0;
}
return(forgettingKnowledgeBits);
}
/// <summary>
/// Initialize AgentExpertise with a stochastic process based on the agent knowledge level
/// </summary>
/// <param name="actorKnowledge">AgentKnowledge to initialize</param>
/// <param name="neutral">if !HasInitialKnowledge, then a neutral (KnowledgeLevel.NoKnowledge) initialization is done</param>
/// <param name="step"></param>
public void InitializeActorKnowledge(ActorKnowledge actorKnowledge, bool neutral, ushort step)
{
if (actorKnowledge is null)
{
throw new ArgumentNullException(nameof(actorKnowledge));
}
var knowledge = GetKnowledge(actorKnowledge.Target);
if (knowledge == null)
{
throw new ArgumentNullException(nameof(knowledge));
}
var level = neutral ? KnowledgeLevel.NoKnowledge : actorKnowledge.KnowledgeLevel;
actorKnowledge.InitializeKnowledge(knowledge.Length, _model, level, step);
}
/// <summary>
/// Agent don't have still this Knowledge, it's time to create one
/// </summary>
/// <param name="agentId"></param>
/// <param name="knowledgeId"></param>
/// <param name="minimumKnowledge"></param>
/// <param name="timeToLive"></param>
/// <param name="step"></param>
public void LearnNewKnowledge(IAgentId agentId, IAgentId knowledgeId, float minimumKnowledge, short timeToLive,
ushort step)
{
if (!_knowledgeNetwork.Exists(knowledgeId))
{
throw new NullReferenceException(nameof(knowledgeId));
}
if (_entityKnowledgeNetwork.Exists(agentId, knowledgeId))
{
return;
}
var agentKnowledge = new ActorKnowledge(_entityKnowledgeNetwork, agentId, knowledgeId, KnowledgeLevel.NoKnowledge, minimumKnowledge,
timeToLive);
var knowledge = _knowledgeNetwork.GetEntity <Knowledge>(knowledgeId);
agentKnowledge.InitializeKnowledge(knowledge.Length, _model, KnowledgeLevel.NoKnowledge, step);
}
public void KnowsEnoughTest()
{
var knowledge4 = new Knowledge(Network, MainOrganization.Models, "1", 1);
var actorKnowledge =
new ActorKnowledge(_agentId, knowledge4.EntityId, KnowledgeLevel.BasicKnowledge, 0, -1);
// Non passing test
Assert.IsFalse(KnowledgeModel.KnowsEnough(actorKnowledge, 0, Threshold, 0));
// Passing tests
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge0, 0, 0, 0));
Assert.IsFalse(KnowledgeModel.KnowsEnough(_actorKnowledge0, 0, Threshold, 0));
Assert.IsFalse(KnowledgeModel.KnowsEnough(_actorKnowledge0, 1, Threshold, 0));
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge1, 0, Threshold, 0));
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge1, 1, Threshold, 0));
Assert.IsFalse(KnowledgeModel.KnowsEnough(_actorKnowledge01, 0, Threshold, 0));
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge01, 1, Threshold, 0));
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledgeFloat, 0, Threshold, 0));
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledgeFloat, 1, Threshold, 0));
}
