/// <summary> /// Try different strategy to unblocked the blocker from incomplete knowledge /// Other strategies failed. Asking externally of the organization (to override) /// Don't forget to call RecoverBlockerIncompleteKnowledgeByGuessing as the last chance to unblock the task /// </summary> /// <param name="task"></param> /// <param name="blocker"></param> /// <param name="knowledgeId"></param> /// <param name="knowledgeBit"></param> public virtual void TryRecoverBlockerIncompleteKnowledgeExternally(SymuTask task, Blocker blocker, IAgentId knowledgeId, byte knowledgeBit) { RecoverBlockerIncompleteKnowledgeByGuessing(task, blocker, knowledgeId, knowledgeBit, BlockerResolution.Guessing); }
public void Reply(IAgentId receiverId, MessageAction action, byte content, MessageAttachments parameter, CommunicationMediums communicationMedium) { var message = new Message(AgentId, receiverId, action, content, parameter, communicationMedium); Reply(message); }
/// <summary> /// Remove the first item of the Required Array, because the task has been done /// </summary> /// <param name="knowledgeId"></param> public void RemoveFirstMandatory(IAgentId knowledgeId) { var bits = GetBits(knowledgeId); if (bits is null) { return; } byte[] removedMandatory; if (bits.GetMandatory().Length > 1) { removedMandatory = new byte[bits.GetMandatory().Length - 1]; for (byte i = 1; i < bits.GetMandatory().Length; i++) { removedMandatory[i - 1] = bits.GetMandatory()[i]; } } else { removedMandatory = new byte[0]; } bits.SetMandatory(removedMandatory); }
public ForgettingModel(IAgentId agentId, TwoModesNetwork <IEntityKnowledge> entityKnowledgeNetwork, CognitiveArchitecture cognitive, ForgettingModelEntity entity, bool knowledgeModelOn, byte randomLevel) { if (entity is null) { throw new ArgumentNullException(nameof(entity)); } if (cognitive is null) { throw new ArgumentNullException(nameof(cognitive)); } _agentId = agentId; _entityKnowledgeNetwork = entityKnowledgeNetwork ?? throw new ArgumentNullException(nameof(entityKnowledgeNetwork)); InternalCharacteristics = cognitive.InternalCharacteristics; _randomLevel = randomLevel; entity.CopyTo(this); if (!knowledgeModelOn || !cognitive.KnowledgeAndBeliefs.HasKnowledge || !InternalCharacteristics.CanForget) { // If KnowledgeModel Off or has no knowledge, there is no knowledge to forget // Agent is not concerned by this model On = false; } }
/// <summary> /// Check a particular beliefId from Task.BeliefBits against Agent.Beliefs /// Prevent the agent from acting on a particular belief /// Task may be blocked if it is the case /// </summary> public void CheckBlockerIncompleteBelief(SymuTask task, IAgentId knowledgeId) { if (task is null) { throw new ArgumentNullException(nameof(task)); } if (!Environment.MainOrganization.Murphies.IncompleteBelief.On || !Environment.MainOrganization.Models.Beliefs.On) { return; } var taskBits = task.KnowledgesBits.GetBits(knowledgeId); float mandatoryScore = 0; float requiredScore = 0; byte mandatoryIndex = 0; byte requiredIndex = 0; var belief = BeliefsModel.GetBeliefFromKnowledgeId(knowledgeId); var actorBelief = BeliefsModel.GetActorBelief(belief.EntityId); Environment.MainOrganization.Murphies.IncompleteBelief.CheckBelief(belief, taskBits, actorBelief, ref mandatoryScore, ref requiredScore, ref mandatoryIndex, ref requiredIndex); if (Math.Abs(mandatoryScore + requiredScore) < Tolerance) { // Check belief is ok return; } CheckBlockerIncompleteBelief(task, knowledgeId, mandatoryScore, requiredScore, mandatoryIndex, requiredIndex); }
/// <summary> /// Subscribe to the Message content /// </summary> public void Subscribe(IAgentId agentId, byte content) { if (!HasSubscribed(agentId, content)) { _subscriptions.Add(new MessageSubscription(agentId, content)); } }
/// <summary> /// Initialize Knowledge model : /// update NetworkKnowledges /// </summary> /// <param name="agentId"></param> /// <param name="entity"></param> /// <param name="cognitiveArchitecture"></param> /// <param name="network"></param> /// <param name="model"></param> public KnowledgeModel(IAgentId agentId, KnowledgeModelEntity entity, CognitiveArchitecture cognitiveArchitecture, GraphMetaNetwork network, RandomGenerator model) { if (entity is null) { throw new ArgumentNullException(nameof(entity)); } if (network == null) { throw new ArgumentNullException(nameof(network)); } if (cognitiveArchitecture == null) { throw new ArgumentNullException(nameof(cognitiveArchitecture)); } On = entity.IsAgentOn(); _agentId = agentId; _knowledgeNetwork = network.Knowledge; _actorKnowledgeNetwork = network.ActorKnowledge; _knowledgeAndBeliefs = cognitiveArchitecture.KnowledgeAndBeliefs; _messageContent = cognitiveArchitecture.MessageContent; _model = model; }
/// <summary> /// Agent learn from an other agent who send KnowledgeBits. /// Knowledge is stored in NetworkKnowledges /// </summary> /// <param name="knowledgeId">the knowledge Id to learn</param> /// <param name="knowledgeBits">the knowledge Bits to learn</param> /// <param name="maxRateLearnable">Maximum rate learnable from the message, depending on the medium used</param> /// <param name="minimumKnowledge"></param> /// <param name="timeToLive"></param> /// <param name="step"></param> public void Learn(IAgentId knowledgeId, Bits knowledgeBits, float maxRateLearnable, float minimumKnowledge, short timeToLive, ushort step) { if (!IsAgentOn()) { return; } if (knowledgeId == null) { throw new ArgumentNullException(nameof(knowledgeId)); } if (knowledgeId.IsNull || knowledgeBits == null || Math.Abs(TasksAndPerformance.LearningRate) < Tolerance || Math.Abs(maxRateLearnable) < Tolerance) { return; } if (!knowledgeId.IsNull && knowledgeBits == null) { throw new ArgumentNullException(nameof(knowledgeBits)); } LearnNewKnowledge(_agentId, knowledgeId, minimumKnowledge, timeToLive, step); var agentKnowledge = _entityKnowledgeNetwork.Edge <ActorKnowledge>(_agentId, knowledgeId); Learn(knowledgeBits, maxRateLearnable, agentKnowledge, step); }
/// <summary> /// </summary> /// <param name="agentId"></param> /// <param name="models"></param> /// <param name="knowledgeNetwork"></param> /// <param name="entityKnowledgeNetwork">ActorKnowledgeNetwork, ResourceKnowledgeNetwork depending on the agent</param> /// <param name="cognitiveArchitecture"></param> /// <param name="model"></param> /// <param name="randomLevel"></param> public LearningModel(IAgentId agentId, MainOrganizationModels models, OneModeNetwork knowledgeNetwork, TwoModesNetwork <IEntityKnowledge> entityKnowledgeNetwork, CognitiveArchitecture cognitiveArchitecture, RandomGenerator model, byte randomLevel) { if (models == null) { throw new ArgumentNullException(nameof(models)); } if (cognitiveArchitecture == null) { throw new ArgumentNullException(nameof(cognitiveArchitecture)); } models.Learning.CopyTo(this); _agentId = agentId; TasksAndPerformance = cognitiveArchitecture.TasksAndPerformance; _internalCharacteristics = cognitiveArchitecture.InternalCharacteristics; _knowledgeNetwork = knowledgeNetwork; _entityKnowledgeNetwork = entityKnowledgeNetwork ?? throw new ArgumentNullException(nameof(entityKnowledgeNetwork)); _randomLevel = randomLevel; if (!cognitiveArchitecture.InternalCharacteristics.CanLearn || !cognitiveArchitecture.KnowledgeAndBeliefs.HasKnowledge) { // Agent is not concerned by this model On = false; } _model = model; }
/// <summary> /// Initializes a new instance of the Message class. /// </summary> /// <param name="senderId">The name of the agent that sends the message</param> /// <param name="receiverId">The name of the agent that needs to receive the message</param> /// <param name="action"></param> /// <param name="subject">The subject of the message</param> public Message(IAgentId senderId, IAgentId receiverId, MessageAction action, byte subject) : this() { Sender = senderId; Receiver = receiverId; Action = action; Subject = subject; }
/// <summary> /// The agent have received a message that ask for belief in return /// stochastic Filtering agentKnowledge based on MinimumBitsOfKnowledgeToSend/MaximumBitsOfKnowledgeToSend /// Work with non binary KnowledgeBits /// </summary> /// <returns>null if he don't have the belief or the right</returns> /// <returns>a beliefBits if he has the belief or the right</returns> /// <returns>With binary KnowledgeBits it will return a float of 0</returns> /// <example>KnowledgeBits[0,1,0.6] and MinimumKnowledgeToSend = 0.8 => KnowledgeBits[0,1,0]</example> public Bits FilterBeliefToSendFromKnowledgeId(IAgentId knowledgeId, byte beliefBit, CommunicationTemplate medium) { var beliefId = GetBeliefIdFromKnowledgeId(knowledgeId); return(FilterBeliefToSend(beliefId, beliefBit, medium)); }
/// <summary> /// Constructor with standard agent template /// and with an existing IAgentId /// </summary> /// <param name="agentId"></param> /// <param name="environment"></param> protected ReactiveAgent(IAgentId agentId, SymuEnvironment environment) { AgentId = agentId; Environment = environment ?? throw new ArgumentNullException(nameof(environment)); Environment.AgentNetwork.AddAgent(this); State = AgentState.NotStarted; Created = Schedule.Step; }
/// <summary> /// Get a typed agent by its agentId /// </summary> /// <typeparam name="TAgent"></typeparam> /// <param name="agentId"></param> /// <returns>The typed agent</returns> public TAgent Get <TAgent>(IAgentId agentId) where TAgent : T { if (Exists(agentId)) { return(_list[agentId] as TAgent); } return(null); }
public bool Exists(IAgentId agentId) { if (agentId == null) { throw new ArgumentNullException(nameof(agentId)); } return(_list.ContainsKey(agentId)); }
/// <summary> /// Check Knowledge required against the worker expertise /// </summary> /// <param name="knowledgeId"></param> /// <param name="knowledgeBit">KnowledgeBit index of the task that must be checked against worker Knowledge</param> /// <param name="knowledgeModel"></param> /// <param name="step"></param> /// <returns>False if the agent is On and if the knowledgeBit is not known enough</returns> /// <returns>True if the agent is not On or the knowledgeBit is known enough</returns> public bool CheckKnowledge(IAgentId knowledgeId, byte knowledgeBit, KnowledgeModel knowledgeModel, ushort step) { if (knowledgeModel == null) { throw new ArgumentNullException(nameof(knowledgeModel)); } return(!IsAgentOn() || knowledgeModel.KnowsEnough(knowledgeId, knowledgeBit, ThresholdForReacting, step)); }
/// <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> /// Constructor based on the knowledge Id and the knowledge Level. /// KnowledgeBits is not yet initialized. /// NetworkKnowledges.InitializeAgentKnowledge must be called to initialized KnowledgeBits /// </summary> /// <param name="actorId"></param> /// <param name="knowledgeId"></param> /// <param name="level"></param> /// <param name="minimumKnowledge"></param> /// <param name="timeToLive"></param> public ActorKnowledge(IAgentId actorId, IAgentId knowledgeId, KnowledgeLevel level, float minimumKnowledge, short timeToLive) : base(actorId, knowledgeId) { KnowledgeLevel = level; MinimumKnowledge = minimumKnowledge; TimeToLive = timeToLive; KnowledgeBits = new KnowledgeBits(minimumKnowledge, timeToLive); Length = KnowledgeBits.Length; }
/// <summary> /// Constructor based on the knowledge Id and the knowledge Level. /// KnowledgeBits is not yet initialized. /// NetworkKnowledges.InitializeAgentKnowledge must be called to initialized KnowledgeBits /// </summary> /// <param name="network"></param> /// <param name="actorId"></param> /// <param name="knowledgeId"></param> /// <param name="level"></param> /// <param name="minimumKnowledge"></param> /// <param name="timeToLive"></param> public ActorKnowledge(TwoModesNetwork <IEntityKnowledge> network, IAgentId actorId, IAgentId knowledgeId, KnowledgeLevel level, float minimumKnowledge, short timeToLive) : base(network, actorId, knowledgeId) { KnowledgeLevel = level; MinimumKnowledge = minimumKnowledge; TimeToLive = timeToLive; KnowledgeBits = new KnowledgeBits(minimumKnowledge, timeToLive); Length = KnowledgeBits.Length; }
/// <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); }
/// <summary> /// Store the knowledge bit of the KnowledgeId in the Database /// The Knowledge must have been InitializeKnowledge first /// </summary> /// <param name="knowledgeId"></param> /// <param name="knowledgeBit"></param> /// <param name="knowledgeValue"></param> /// <param name="step"></param> public void StoreKnowledge(IAgentId knowledgeId, byte knowledgeBit, float knowledgeValue, ushort step) { if (!ExistsKnowledge(knowledgeId)) { throw new ArgumentNullException("knowledgeId must have been initialized first"); } _learningModel.AgentKnowledgeLearn(GetKnowledge(knowledgeId), knowledgeBit, knowledgeValue, step); }
/// <summary> /// Constructor used by Agent.Cognitive for ForgettingKnowledge /// </summary> /// <param name="network"></param> /// <param name="actorId"></param> /// <param name="knowledgeId"></param> /// <param name="knowledgeBits"></param> /// <param name="minimumKnowledge"></param> /// <param name="timeToLive"></param> /// <param name="step"></param> public ActorKnowledge(TwoModesNetwork <IEntityKnowledge> network, IAgentId actorId, IAgentId knowledgeId, float[] knowledgeBits, float minimumKnowledge, short timeToLive, ushort step = 0) : base(network, actorId, knowledgeId) { MinimumKnowledge = minimumKnowledge; TimeToLive = timeToLive; KnowledgeBits = new KnowledgeBits(minimumKnowledge, timeToLive); KnowledgeBits.SetBits(knowledgeBits, step); Length = KnowledgeBits.Length; }
/// <summary> /// Constructor used by Agent.Cognitive for ForgettingKnowledge /// </summary> /// <param name="actorId"></param> /// <param name="knowledgeId"></param> /// <param name="knowledgeBits"></param> /// <param name="minimumKnowledge"></param> /// <param name="timeToLive"></param> /// <param name="step"></param> public ActorKnowledge(IAgentId actorId, IAgentId knowledgeId, float[] knowledgeBits, float minimumKnowledge, short timeToLive, ushort step = 0) : base(actorId, knowledgeId) { MinimumKnowledge = minimumKnowledge; TimeToLive = timeToLive; KnowledgeBits = new KnowledgeBits(minimumKnowledge, timeToLive); KnowledgeBits.SetBits(knowledgeBits, step); Length = KnowledgeBits.Length; }
/// <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 SetKnowledge(IAgentId knowledgeId, byte index, float value, ushort step) { var actorKnowledge = GetActorKnowledge(knowledgeId); if (actorKnowledge == null) { throw new NullReferenceException(nameof(actorKnowledge)); } actorKnowledge.SetKnowledgeBit(index, value, step); }
public void SetKnowledge(IAgentId knowledgeId, float[] knowledgeBits, ushort step) { var actorKnowledge = GetActorKnowledge(knowledgeId); if (actorKnowledge == null) { throw new NullReferenceException(nameof(actorKnowledge)); } actorKnowledge.SetKnowledgeBits(knowledgeBits, step); }
public bool ExistsAndStarted(IAgentId agentId) { if (!ExistsAgent(agentId)) { return(false); } var agent = GetAgent(agentId); return(agent != null && agent.State == AgentState.Started); }
/// <summary> /// Check that agent has the BeliefId[knowledgeBit] == 1 /// </summary> /// <param name="beliefId"></param> /// <param name="beliefBit"></param> /// <param name="beliefThreshHoldForAnswer"></param> /// <returns>true if the agent has the knowledge</returns> public bool BelievesEnough(IAgentId beliefId, byte beliefBit, float beliefThreshHoldForAnswer) { if (!_actorBeliefNetwork.Exists(_agentId, beliefId)) { return(false); } var belief = _actorBeliefNetwork.Edge <ActorBelief>(_agentId, beliefId); return(belief.BelievesEnough(beliefBit, beliefThreshHoldForAnswer)); }
public Message(IAgentId senderId, IAgentId receiverId, MessageAction action, byte subject, MessageAttachments attachments, CommunicationMediums medium) : this(senderId, receiverId, action, subject, medium) { if (attachments == null) { return; } Attachments = attachments; }
public Message(IAgentId senderId, IAgentId receiverId, MessageAction action, byte subject, MessageAttachments attachments) : this(senderId, receiverId, action, subject) { if (attachments == null) { return; } Attachments = attachments; }
/// <summary> /// Add an agentId's Knowledge to the network /// </summary> /// <param name="knowledgeId"></param> /// <param name="level"></param> /// <param name="internalCharacteristics"></param> public void AddKnowledge(IAgentId knowledgeId, KnowledgeLevel level, InternalCharacteristics internalCharacteristics) { if (internalCharacteristics == null) { throw new ArgumentNullException(nameof(internalCharacteristics)); } AddKnowledge(knowledgeId, level, internalCharacteristics.MinimumRemainingKnowledge, internalCharacteristics.TimeToLive); }