public static float GetMinFromBeliefLevel(BeliefLevel level)
{
switch (level)
{
case BeliefLevel.NoBelief:
return(0);
case BeliefLevel.StronglyDisagree:
return(-1F);
case BeliefLevel.Disagree:
return(-0.75F);
case BeliefLevel.NeitherAgreeNorDisagree:
return(-0.25F);
case BeliefLevel.Agree:
return(0.25F);
case BeliefLevel.StronglyAgree:
return(0.75F);
case BeliefLevel.Random:
return(ContinuousUniform.Sample(0, 0.75F));
default:
throw new ArgumentOutOfRangeException(nameof(level), level, null);
}
}
/// <summary>
/// Add an agentId's beliefs
/// using the beliefLevel
/// </summary>
/// <param name="beliefId"></param>
/// <param name="beliefLevel"></param>
public void AddBelief(IAgentId beliefId, BeliefLevel beliefLevel)
{
if (!On)
{
return;
}
ActorBelief.CreateInstance(_actorBeliefNetwork, _agentId, beliefId, beliefLevel);
}
/// <summary>
/// Agent don't have still this belief, it's time to learn a new one
/// </summary>
/// <param name="beliefId"></param>
/// <param name="beliefLevel"></param>
public void LearnNewBelief(IAgentId beliefId, BeliefLevel beliefLevel)
{
if (_actorBeliefNetwork.Exists(_agentId, beliefId))
{
return;
}
ActorBelief.CreateInstance(_actorBeliefNetwork, _agentId, beliefId, beliefLevel);
InitializeBeliefs(true);
}
public void InitializeBitsTest(BeliefLevel level)
{
var knowledgeBits = _belief.InitializeBits(RandomGenerator.RandomBinary, level);
for (byte i = 0; i < _knowledge.Length; i++)
{
Assert.IsTrue(Math.Abs(knowledgeBits[i]) < Tolerance ||
Math.Abs(knowledgeBits[i] - 1) < Tolerance);
}
}
public void ReinforcementByDoing(IAgentId beliefId, byte beliefBit, BeliefLevel beliefLevel)
{
if (!On || !_beliefsModel.On)
{
return;
}
_beliefsModel.LearnNewBelief(beliefId, beliefLevel);
var agentBelief = _beliefsModel.GetActorBelief(beliefId);
agentBelief.Learn(_model, beliefBit);
}
public void InitializeBitsTest3(BeliefLevel level)
{
var knowledgeBits = _belief.InitializeBits(RandomGenerator.RandomUniform, level);
for (byte i = 0; i < _knowledge.Length; i++)
{
Assert.IsTrue(
Belief.GetMinFromBeliefLevel(level) <= knowledgeBits[i] ||
Math.Abs(knowledgeBits[i]) < Tolerance);
Assert.IsTrue(knowledgeBits[i] <=
Belief.GetMaxFromBeliefLevel(level));
}
}
/// <summary>
/// Add an agentId's beliefs based on a knowledgeId to the network
/// using the beliefLevel
/// </summary>
/// <param name="knowledgeId"></param>
/// <param name="beliefLevel"></param>
public void AddBeliefFromKnowledgeId(IAgentId knowledgeId, BeliefLevel beliefLevel)
{
if (!On)
{
return;
}
var belief = GetBeliefFromKnowledgeId(knowledgeId);
if (belief == null)
{
throw new NullReferenceException(nameof(belief));
}
ActorBelief.CreateInstance(_actorBeliefNetwork, _agentId, belief.EntityId, beliefLevel);
}
/// <summary>
/// Given a random model and a BeliefLevel
/// return the beliefBits for the agent: an array fill of random binaries
/// representing the detailed belief of an agent
/// </summary>
/// <param name="model"></param>
/// <param name="beliefLevel"></param>
/// <returns></returns>
public float[] InitializeBits(RandomGenerator model, BeliefLevel beliefLevel)
{
float[] beliefBits;
switch (model)
{
case RandomGenerator.RandomUniform:
{
float min;
float max;
if (beliefLevel == BeliefLevel.Random)
{
min = RangeMin;
max = RangeMax;
}
else
{
min = GetMinFromBeliefLevel(beliefLevel);
max = GetMaxFromBeliefLevel(beliefLevel);
}
beliefBits = ContinuousUniform.Samples(Length, min, max);
break;
}
case RandomGenerator.RandomBinary:
{
if (beliefLevel == BeliefLevel.Random)
{
beliefBits = ContinuousUniform.FilteredSamples(Length, RangeMin, RangeMax);
}
else
{
var mean = 1 - GetValueFromBeliefLevel(beliefLevel);
beliefBits = ContinuousUniform.FilteredSamples(Length, mean);
}
break;
}
default:
throw new ArgumentOutOfRangeException(nameof(model), model, null);
}
return(beliefBits);
}
/// <summary>
/// Be influenced beliefId from agentAgentId
/// </summary>
/// <param name="beliefId"></param>
/// <param name="beliefBits">from agentAgentId beliefBits</param>
/// <param name="agentId"></param>
/// <param name="beliefLevel"></param>
public void BeInfluenced(IAgentId beliefId, Bits beliefBits, IAgentId agentId, BeliefLevel beliefLevel)
{
if (!On || beliefBits == null)
{
return;
}
// Learning From agent
if (!_whitePages.ExistsAgent(agentId))
{
return;
}
var influentialness = _whitePages.GetAgent <CognitiveAgent>(agentId).InfluenceModel.Influentialness;
// to Learner
// Learner learn beliefId from agentAgentId with a weight of influenceability * influentialness
_beliefsModel.Learn(beliefId, beliefBits, Influenceability * influentialness, beliefLevel);
}
/// <summary>
/// Transform BeliefLevel into a value between [0;1]
/// </summary>
/// <param name="level"></param>
/// <returns></returns>
private static float GetValueFromBeliefLevel(BeliefLevel level)
{
return(ContinuousUniform.Sample(GetMinFromBeliefLevel(level), GetMaxFromBeliefLevel(level)));
}
/// <summary>
/// Get the name of a KnowledgeLevel
/// </summary>
/// <param name="level"></param>
/// <returns></returns>
public static string GetName(BeliefLevel level)
{
return(level.ToString());
}
/// <summary>
/// agent learn beliefId with a weight of influenceability * influentialness
/// </summary>
/// <param name="beliefId"></param>
/// <param name="beliefBits"></param>
/// <param name="influenceWeight"></param>
/// <param name="beliefLevel"></param>
public void Learn(IAgentId beliefId, Bits beliefBits, float influenceWeight,
BeliefLevel beliefLevel)
{
LearnNewBelief(beliefId, beliefLevel);
_actorBeliefNetwork.Edge <ActorBelief>(_agentId, beliefId).Learn(beliefBits, influenceWeight);
}
public void AddBeliefsFromKnowledge(IEnumerable <IEntityKnowledge> expertise, BeliefLevel beliefLevel)
{
if (expertise is null)
{
throw new ArgumentNullException(nameof(expertise));
}
foreach (var knowledgeId in expertise.Select(x => x.Target))
{
AddBeliefFromKnowledgeId(knowledgeId, beliefLevel);
}
}
public ActorBelief(ActorBeliefNetwork network, IAgentId actorId, IAgentId beliefId, BeliefLevel beliefLevel) : base(network, actorId, beliefId)
{
BeliefLevel = beliefLevel;
}
/// <summary>
/// Factory
/// </summary>
/// <param name="network"></param>
/// <param name="actorId"></param>
/// <param name="beliefId"></param>
/// <param name="beliefLevel"></param>
/// <returns></returns>
public static ActorBelief CreateInstance(ActorBeliefNetwork network, IAgentId actorId, IAgentId beliefId, BeliefLevel beliefLevel)
{
return(new ActorBelief(network, actorId, beliefId, beliefLevel));
}
public ActorBelief(IAgentId actorId, IAgentId beliefId, BeliefLevel beliefLevel) : base(actorId, beliefId)
{
BeliefLevel = beliefLevel;
}
