NLAINIMAT::CMHiCSagent Class Reference

#include <mhics.h>

---

Detailed Description

A Modular Hierarchical Classifier System. This is the agent component where motivations levels and perceptions are stored.

Author:

Gabriel ROBERT

Nevrax France

Date:

2002

Definition at line 200 of file mhics.h.

Public Member Functions
	CMHiCSagent (CMHiCSbase *pMHiCSbase)
void	getDebugString (std::string &t) const
	Chaine de debug.
double	getExecutionIntensity (TAction action, TTargetId target) const
	Retourne l'intensité d'exécution d'une action.
const CMHiCSbase *	getMHiCSbase () const
double	getMotivationPP (TMotivation motivationName) const
	Retourne la Puissance Propre d'une Motivation.
double	getMotivationValue (TMotivation motivationName) const
	Retourne la valeur d'une motiation.
uint32	getTemporaryClassifierPriorityTime (TMotivation motivationName, TClassifierNumber classifierNumber) const
void	run ()
	* if (selectedClassifierNumber < 0)
const std::map< TTargetId, std::map< TAction, CMotivationEnergy > > *	selectBehavior ()
	Return the Behavior that must be active.
void	setLearning (bool active)
void	setMotivationPP (TMotivation motivationName, double PP)
	Donne la Puissance Propre d'une Motivation.
void	setMotivationValue (TMotivation motivationName, double value)
	Fixe la valeur d'une motivation.
void	setSensors (CCSPerception *psensorMap)
	Set the sensor source.
bool	wasClassifierPreviouslyActive (TMotivation motivationName, TClassifierNumber classifierNumber) const
virtual	~CMHiCSagent ()
Private Member Functions
void	learningComputation ()
	If _Learning == true, it will compute new priority for each classifier.
void	motivationCompute ()
std::string	targetId2String (TTargetId id) const
	function used in debug to change a TTargetId in a string
Private Attributes
std::map< TMotivation, CMotivationEnergy >	_ClassifiersAndMotivationIntensity
bool	_Learning
std::map< TMotivation, CMotivationEnergy >	_OldClassifiersAndMotivationIntensity
std::map< TTargetId, std::map< TAction, CMotivationEnergy > > *	_pActionsExecutionIntensityByTarget
std::map< TMotivation, std::map< TClassifierNumber, CClassifierActivityInfo > > *	_pInfoClassifierActivity
CMHiCSbase *	_pMHiCSbase
std::map< TTargetId, std::map< TAction, CMotivationEnergy > > *	_pOldActionsExecutionIntensityByTarget
std::map< TMotivation, std::map< TClassifierNumber, CClassifierActivityInfo > > *	_pOldInfoClassifierActivity
CCSPerception *	_pSensorsValues
std::map< TMotivation, std::map< TClassifierNumber, CTemporaryPriority > >	_TemporaryPriority

---

Constructor & Destructor Documentation

NLAINIMAT::CMHiCSagent::CMHiCSagent (  CMHiCSbase *  pMHiCSbase  )

Definition at line 668 of file mhics.cpp. References _Learning, _pActionsExecutionIntensityByTarget, _pInfoClassifierActivity, _pMHiCSbase, _pOldActionsExecutionIntensityByTarget, _pOldInfoClassifierActivity, and nlassert. { nlassert (pMHiCSbase != NULL); _pMHiCSbase = pMHiCSbase; _pActionsExecutionIntensityByTarget = new std::map<TTargetId, std::map<TAction, CMotivationEnergy> >(); _pOldActionsExecutionIntensityByTarget = new std::map<TTargetId, std::map<TAction, CMotivationEnergy> >(); _Learning = true; _pInfoClassifierActivity = new std::map<TMotivation, std::map<TClassifierNumber, CClassifierActivityInfo> >(); _pOldInfoClassifierActivity = new std::map<TMotivation, std::map<TClassifierNumber, CClassifierActivityInfo> >(); // _ActionsExecutionIntensity[Action_DoNothing] = CMotivationEnergy(); // _IdByActions[Action_DoNothing] = NullTargetId; // _ItCurrentAction = _IdByActions.find(Action_DoNothing); }

NLAINIMAT::CMHiCSagent::~CMHiCSagent (   )  [virtual]

Definition at line 682 of file mhics.cpp. References _pActionsExecutionIntensityByTarget, _pInfoClassifierActivity, _pOldActionsExecutionIntensityByTarget, and _pOldInfoClassifierActivity. { delete _pOldActionsExecutionIntensityByTarget; delete _pActionsExecutionIntensityByTarget; delete _pInfoClassifierActivity; delete _pOldInfoClassifierActivity; }

---

Member Function Documentation

void NLAINIMAT::CMHiCSagent::getDebugString (  std::string &  t  )  const

Chaine de debug. Definition at line 707 of file mhics.cpp. References _ClassifiersAndMotivationIntensity, _pSensorsValues, NLAINIMAT::CCSPerception::NoTargetSensors, t, targetId2String(), NLAINIMAT::CCSPerception::TargetSensors, and NLMISC::toString(). { std::string ret = "\n\n---------------------------\n"; ret += "\nPerceptions :"; ret += "\n Without target"; NLAINIMAT::TSensorMap::const_iterator itNoTargetSensors; for (itNoTargetSensors = _pSensorsValues->NoTargetSensors.begin(); itNoTargetSensors != _pSensorsValues->NoTargetSensors.end(); itNoTargetSensors++) { ret += "\n " + conversionSensor.toString((*itNoTargetSensors).first) + "(" + (*itNoTargetSensors).second + ")"; } std::map<TTargetId, TSensorMap>::const_iterator itTargetSensors; for (itTargetSensors = _pSensorsValues->TargetSensors.begin(); itTargetSensors != _pSensorsValues->TargetSensors.end(); itTargetSensors++) { ret += "\n On target n#" + targetId2String((*itTargetSensors).first); for (itNoTargetSensors = (*itTargetSensors).second.begin(); itNoTargetSensors != (*itTargetSensors).second.end(); itNoTargetSensors++) { ret += "\n " + conversionSensor.toString((*itNoTargetSensors).first) + "(" + (*itNoTargetSensors).second + ")"; } } ret += "\n\nMotivations :"; std::map<TMotivation, CMotivationEnergy>::const_iterator itClassifiersAndMotivationIntensity; for (itClassifiersAndMotivationIntensity = _ClassifiersAndMotivationIntensity.begin(); itClassifiersAndMotivationIntensity != _ClassifiersAndMotivationIntensity.end(); itClassifiersAndMotivationIntensity++) { ret += "\n <" + conversionMotivation.toString((*itClassifiersAndMotivationIntensity).first) + "> "; ret += "[MI=" + NLMISC::toString((*itClassifiersAndMotivationIntensity).second.getSumValue()) + "] :"; (*itClassifiersAndMotivationIntensity).second.getDebugString(ret); // ret += "\n -> Classifier number " + NLMISC::toString((*itClassifiersAndMotivationIntensity).second.ClassifierNumber); ret += "\n"; } // ret += "\nVirtual Actions :"; // std::map<TAction, CMotivationEnergy>::const_iterator itClassifiersAndVirtualActionIntensity; // for (itClassifiersAndVirtualActionIntensity = _ClassifiersAndVirtualActionIntensity.begin(); // itClassifiersAndVirtualActionIntensity != _ClassifiersAndVirtualActionIntensity.end(); // itClassifiersAndVirtualActionIntensity++) // { // ret += "\n <" + conversionAction.toString((*itClassifiersAndVirtualActionIntensity).first) + "> "; // ret += "[MI=" + NLMISC::toString((*itClassifiersAndVirtualActionIntensity).second.getSumValue()) + "] :"; // (*itClassifiersAndVirtualActionIntensity).second.getDebugString(ret); // ret += "\n -> Classifier number " + NLMISC::toString((*itClassifiersAndVirtualActionIntensity).second.ClassifierNumber); // ret += "\n"; // } ret += "\nACTIONS :"; std::map<TAction, CMotivationEnergy>::const_iterator itActionsExecutionIntensity; // for (itActionsExecutionIntensity = _ActionsExecutionIntensity.begin(); itActionsExecutionIntensity != _ActionsExecutionIntensity.end(); itActionsExecutionIntensity++) // { // ret += "\n <" + conversionAction.toString((* itActionsExecutionIntensity).first) + "> [EI=" + NLMISC::toString((*itActionsExecutionIntensity).second.getSumValue()) + "] : "; // (*itActionsExecutionIntensity).second.getDebugString(ret); // std::map<TAction, TTargetId>::const_iterator itIdByActions = _IdByActions.find((*itActionsExecutionIntensity).first); // nlassert (itIdByActions != _IdByActions.end()); // ret += " on target n#" + targetId2String((*itIdByActions).second); // } // if (_ItCurrentAction != _IdByActions.end()) // { // ret += "\nACTION ACTIVE : " + NLAINIMAT::conversionAction.toString((*_ItCurrentAction).first) + " on " + targetId2String((*_ItCurrentAction).second); // } t+=ret; }

double NLAINIMAT::CMHiCSagent::getExecutionIntensity (  TAction  action, TTargetId  target )  const

Retourne l'intensité d'exécution d'une action. Definition at line 855 of file mhics.cpp. References _pActionsExecutionIntensityByTarget, and NLAINIMAT::TTargetId. { std::map<TTargetId, std::map<TAction, CMotivationEnergy> >::const_iterator itActionsExecutionIntensityByTarget; itActionsExecutionIntensityByTarget = _pActionsExecutionIntensityByTarget->find(target); if (itActionsExecutionIntensityByTarget == _pActionsExecutionIntensityByTarget->end()) { return -1; } std::map<TAction, CMotivationEnergy>::const_iterator itActionsExecutionIntensity = (*itActionsExecutionIntensityByTarget).second.find(action); if (itActionsExecutionIntensity != (*itActionsExecutionIntensityByTarget).second.end()) { return (*itActionsExecutionIntensity).second.getSumValue(); } else { return -1; } }

const CMHiCSbase* NLAINIMAT::CMHiCSagent::getMHiCSbase (   )  const [inline]

Definition at line 240 of file mhics.h. References _pMHiCSbase. Referenced by NLAINIMAT::CMotivationEnergy::computeMotivationValue(). {return _pMHiCSbase;}

double NLAINIMAT::CMHiCSagent::getMotivationPP (  TMotivation  motivationName  )  const

Retourne la Puissance Propre d'une Motivation. Definition at line 788 of file mhics.cpp. References _ClassifiersAndMotivationIntensity. Referenced by NLAINIMAT::CMotivationEnergy::computeMotivationValue(). { std::map<TMotivation, CMotivationEnergy>::const_iterator itClassifiersAndMotivationIntensity = _ClassifiersAndMotivationIntensity.find(motivationName); if (itClassifiersAndMotivationIntensity != _ClassifiersAndMotivationIntensity.end()) { return (*itClassifiersAndMotivationIntensity).second.getMotivationPP(motivationName); } else { return -1; } }

double NLAINIMAT::CMHiCSagent::getMotivationValue (  TMotivation  motivationName  )  const

Retourne la valeur d'une motiation. Definition at line 827 of file mhics.cpp. References _ClassifiersAndMotivationIntensity. Referenced by NLAINIMAT::CMotivationEnergy::computeMotivationValue(). { std::map<TMotivation, CMotivationEnergy>::const_iterator itClassifiersAndMotivationIntensity = _ClassifiersAndMotivationIntensity.find(motivationName); if (itClassifiersAndMotivationIntensity != _ClassifiersAndMotivationIntensity.end()) { return (*itClassifiersAndMotivationIntensity).second.getMotivationValue(motivationName); } else { return -1; } }

uint32 NLAINIMAT::CMHiCSagent::getTemporaryClassifierPriorityTime (  TMotivation  motivationName, TClassifierNumber  classifierNumber )  const

Definition at line 1608 of file mhics.cpp. References _TemporaryPriority, NLAINIMAT::TClassifierNumber, and uint32. Referenced by NLAINIMAT::CMotivationEnergy::computeMotivationValue(). { std::map<TMotivation, std::map<TClassifierNumber, CTemporaryPriority> >::const_iterator itTemporaryPriority = _TemporaryPriority.find(motivationName); if (itTemporaryPriority == _TemporaryPriority.end()) { return 0; } std::map<TClassifierNumber, CTemporaryPriority>::const_iterator itIteratorBis = (*itTemporaryPriority).second.find(classifierNumber); if (itIteratorBis == (*itTemporaryPriority).second.end()) { return 0; } uint32 bibureturn = (*itIteratorBis).second.TemporaryClassifierPriorityTime; return bibureturn; }

void NLAINIMAT::CMHiCSagent::learningComputation (   )  [private]

If _Learning == true, it will compute new priority for each classifier. Definition at line 1219 of file mhics.cpp. References _ClassifiersAndMotivationIntensity, _OldClassifiersAndMotivationIntensity, _pActionsExecutionIntensityByTarget, _pMHiCSbase, _TemporaryPriority, NLMISC::CTime::getSecondsSince1970(), NLAINIMAT::CMHiCSbase::learningUpdatePriorityValueClassifierTime(), NLAINIMAT::CMHiCSbase::learningUpdatePriorityValueTimeToSuccess(), nlassert, NLAINIMAT::TClassifierNumber, NLAINIMAT::TMotivation, and uint32. Referenced by selectBehavior(). { /* * Le but de l'apprentissage par ajustement des valeurs de priorité : * La valeur de priorité est utilisé pour choisir un classeur lorsque plusieurs classeurs sont activable simultanement * et partagent une même ressource d'action. * On veut la faire évoluer afin que dans une situation donnée, c'est le classeur le plus apte à satisfaire la motivation * qui soit sélectionné. * Celon le principe de bucket brigade, un classeur qui mène à satisfaire une motivation est un bon classeur. * Ensuite un classeur qui a défaut de satisfaire la motivation mène à un classeur pouvant la satisfaire est bon mais un peut moins, etc. */ // std::map<TMotivation, std::set<TClassifierNumber> > oldClassifierByMotivation; // Liste des classeurs actifs au pas précédent. // std::map<TMotivation, std::set<TClassifierNumber> > classifierByMotivation; // Liste des classeurs activés // On note les descentes de motivations uint32 newTime = NLMISC::CTime::getSecondsSince1970(); std::set<TMotivation> decreasingMotivations; std::map<TMotivation, CMotivationEnergy>::iterator itOldClassifiersAndMotivationIntensity, itClassifiersAndMotivationIntensity; for(itOldClassifiersAndMotivationIntensity = _OldClassifiersAndMotivationIntensity.begin(); itOldClassifiersAndMotivationIntensity != _OldClassifiersAndMotivationIntensity.end(); itOldClassifiersAndMotivationIntensity++) { TMotivation motivationName = (*itOldClassifiersAndMotivationIntensity).first; double oldMV = (*itOldClassifiersAndMotivationIntensity).second.getMotivationValue(motivationName); itClassifiersAndMotivationIntensity = _ClassifiersAndMotivationIntensity.find(motivationName); nlassert(itClassifiersAndMotivationIntensity != _ClassifiersAndMotivationIntensity.end()); double newMV = (*itClassifiersAndMotivationIntensity).second.getMotivationValue(motivationName); if (newMV < oldMV) { decreasingMotivations.insert(motivationName); } } // // On établit la liste des classeurs utilisés précédemment // std::map<TMotivation, std::set<TClassifierNumber> >::iterator itOldClassifierByMotivation; // std::map<TTargetId, std::map<TAction, CMotivationEnergy> >::iterator itOldActionsExecutionIntensityByTarget; // std::map<TAction, CMotivationEnergy>::iterator itOldActionsExecutionIntensity; // for(itOldActionsExecutionIntensityByTarget = _pOldActionsExecutionIntensityByTarget->begin(); // itOldActionsExecutionIntensityByTarget != _pOldActionsExecutionIntensityByTarget->end(); // itOldActionsExecutionIntensityByTarget++) // { // for(itOldActionsExecutionIntensity = (*itOldActionsExecutionIntensityByTarget).second.begin(); // itOldActionsExecutionIntensity != (*itOldActionsExecutionIntensityByTarget).second.end(); // itOldActionsExecutionIntensity++) // { // const std::map<TMotivation, std::set<TClassifierNumber> >* provounet = (*itOldActionsExecutionIntensity).second.getProviders(); // std::map<TMotivation, std::set<TClassifierNumber> >::const_iterator itProvounet; // for(itProvounet = provounet->begin(); // itProvounet != provounet->end(); // itProvounet++) // { // TMotivation motivationName = (*itProvounet).first; // std::set<TClassifierNumber>::const_iterator itClassifierNumber; // for (itClassifierNumber = (*itProvounet).second.begin(); itClassifierNumber != (*itProvounet).second.end(); itClassifierNumber++) // { // TClassifierNumber classifierNumber = (*itClassifierNumber); // // On établit une liste des classeurs ayant été actifs. // oldClassifierByMotivation[motivationName].insert(classifierNumber); // } // } // } // } // On remet à zero les compteurs de temps pour les actions qui on satisfait une motivation std::set<TMotivation>::iterator itDecreasingMotivations; for (itDecreasingMotivations = decreasingMotivations.begin(); itDecreasingMotivations != decreasingMotivations.end(); itDecreasingMotivations++) { TMotivation motivationName = (*itDecreasingMotivations); std::map<TMotivation, std::map<TClassifierNumber, CTemporaryPriority> >::iterator itTemporaryPriority = _TemporaryPriority.find(motivationName); if (itTemporaryPriority != _TemporaryPriority.end()) { std::map<TClassifierNumber, CTemporaryPriority>::iterator itPrioByCl; for (itPrioByCl = (*itTemporaryPriority).second.begin(); itPrioByCl != (*itTemporaryPriority).second.end(); itPrioByCl++ ) { // Si le temps a été fixé // bool aUnFixedStartTime = (*itPrioByCl).second.FixedStartTime; // if (aUnFixedStartTime) // { uint32 startTime = (*itPrioByCl).second.StartTime; if (startTime > newTime) { newTime = startTime; } uint32 timeToSatisfaction = newTime - startTime; TClassifierNumber classifierNumber = (*itPrioByCl).first; // On met à jour la fitness des classeurs ayant été activés. _pMHiCSbase->learningUpdatePriorityValueTimeToSuccess(motivationName, classifierNumber, timeToSatisfaction); // } } } _TemporaryPriority.erase(motivationName); } // On établit la liste des classeurs nouveaux utilisés à ce pas ci std::map<TTargetId, std::map<TAction, CMotivationEnergy> >::iterator itActionsExecutionIntensityByTarget; std::map<TAction, CMotivationEnergy>::iterator itActionsExecutionIntensity; for(itActionsExecutionIntensityByTarget = _pActionsExecutionIntensityByTarget->begin(); itActionsExecutionIntensityByTarget != _pActionsExecutionIntensityByTarget->end(); itActionsExecutionIntensityByTarget++) { for(itActionsExecutionIntensity = (*itActionsExecutionIntensityByTarget).second.begin(); itActionsExecutionIntensity != (*itActionsExecutionIntensityByTarget).second.end(); itActionsExecutionIntensity++) { const std::map<TMotivation, std::set<TClassifierNumber> >* provounet = (*itActionsExecutionIntensity).second.getProviders(); std::map<TMotivation, std::set<TClassifierNumber> >::const_iterator itProvounet; for(itProvounet = provounet->begin(); itProvounet != provounet->end(); itProvounet++) { TMotivation motivationName = (*itProvounet).first; std::set<TClassifierNumber>::const_iterator itClassifierNumber; for (itClassifierNumber = (*itProvounet).second.begin(); itClassifierNumber != (*itProvounet).second.end(); itClassifierNumber++) { TClassifierNumber classifierNumber = (*itClassifierNumber); // itOldClassifierByMotivation = oldClassifierByMotivation.find(motivationName); // if (itOldClassifierByMotivation != oldClassifierByMotivation.end() ) // { // ajout du classeur dans la liste des classeurs activés (*_pInfoClassifierActivity)[motivationName][classifierNumber].IsActive = true; // classifierByMotivation[motivationName].insert(classifierNumber); // } } } } } // on établit la liste des classeurs qui étaient activables et qui ne le sont plus std::map<TMotivation, std::map<TClassifierNumber, CClassifierActivityInfo> >::iterator itOldInfoClassifierActivity; std::map<TMotivation, std::map<TClassifierNumber, CClassifierActivityInfo> >::iterator itInfoClassifierActivity; for(itOldInfoClassifierActivity = (*_pOldInfoClassifierActivity).begin(); itOldInfoClassifierActivity != (*_pOldInfoClassifierActivity).end(); itOldInfoClassifierActivity++ ) { TMotivation motivationName = (*itOldInfoClassifierActivity).first; std::map<TClassifierNumber, CClassifierActivityInfo>::iterator itClassifiers, itClassifiersBis; for (itClassifiers = (*itOldInfoClassifierActivity).second.begin(); itClassifiers != (*itOldInfoClassifierActivity).second.end(); itClassifiers++) { // std::set<TClassifierNumber>::iterator itClassifiersBisBis; // bool isStillActivable = false; TClassifierNumber classifierNumber = (*itClassifiers).first; bool wasActive = (*itClassifiers).second.IsActive; bool isActive = (*_pInfoClassifierActivity)[motivationName][classifierNumber].IsActive; if (wasActive && !isActive) { // Le classeur vient de finir son activité, je calcule sa nouvelle priorité. uint32 diffTime = _TemporaryPriority[motivationName][classifierNumber].TemporaryClassifierPriorityTime; if (diffTime >0) { _pMHiCSbase->learningUpdatePriorityValueClassifierTime(motivationName, classifierNumber, diffTime); // _TemporaryPriority[motivationName][classifierNumber].FixedStartTime = false; } } // bool wasActivable = (*itClassifiers).second.IsActivable; // if (wasActivable) // { // itInfoClassifierActivity = (*_pInfoClassifierActivity).find(motivationName); // if (itInfoClassifierActivity != (*_pInfoClassifierActivity).end()) // { // itClassifiersBis = (*itInfoClassifierActivity).second.find(classifierNumber); // if ( itClassifiersBis != (*itInfoClassifierActivity).second.end() ) // { // isStillActivable = true; // } // } // if (isStillActivable) // { // // s'il est activable mais plus activé alors on met à jour son compteur de temps d'execution // bool estActif = (*_pInfoClassifierActivity)[motivationName][classifierNumber].IsActive; // if (!estActif) // { // std::map<TMotivation, std::set<TClassifierNumber> >::iterator itOldClassifierByMotivation = oldClassifierByMotivation.find(motivationName); // if (itOldClassifierByMotivation != oldClassifierByMotivation.end()) // { // itClassifiersBisBis = (*itOldClassifierByMotivation).second.find(classifierNumber); // if ( itClassifiersBisBis != (*itOldClassifierByMotivation).second.end() ) // { // // Le classeur vient de finir son activité, je calcule sa nouvelle priorité. // uint32 diffTime = _TemporaryPriority[motivationName][classifierNumber].TemporaryClassifierPriorityTime; // if (diffTime >0) // { // _pMHiCSbase->learningUpdatePriorityValueClassifierTime(motivationName, classifierNumber, diffTime); // _TemporaryPriority[motivationName][classifierNumber].FixedStartTime = false; // } // } // } // } // } // else // { // // Dans tous les cas on met à jour son temps d'activation s'il a été activé par le passé. // std::map<TMotivation, std::map<TClassifierNumber, CTemporaryPriority> >::iterator itTemporaryPriority = _TemporaryPriority.find(motivationName); // if (itTemporaryPriority != _TemporaryPriority.end()) // { // std::map<TClassifierNumber, CTemporaryPriority>::iterator itClassifiersTerce = (*itTemporaryPriority).second.find(classifierNumber); // if (itClassifiersTerce != (*itTemporaryPriority).second.end() ) // { // // Le classeur vient de finir son activité, je calcule sa nouvelle priorité. // uint32 diffTime = _TemporaryPriority[motivationName][classifierNumber].TemporaryClassifierPriorityTime; // if (diffTime >0) // { // _pMHiCSbase->learningUpdatePriorityValueClassifierTime(motivationName, classifierNumber, diffTime); // _TemporaryPriority[motivationName][classifierNumber].FixedStartTime = false; // } // } // } // // // S'il n'était pas activé (avant de n'être plus activable), on le retire de la liste des éligibles au T2S // _TemporaryPriority[motivationName][classifierNumber].FixedStartTime = false; // } // } } } std::map<TClassifierNumber, CClassifierActivityInfo>::iterator itUnChtitClassifierNumberInfo; // On regarde quelles sont les nouveaux classeurs activés for(itInfoClassifierActivity = (*_pInfoClassifierActivity).begin(); itInfoClassifierActivity != (*_pInfoClassifierActivity).end(); itInfoClassifierActivity++) { TMotivation motivationName = (*itInfoClassifierActivity).first; for(itUnChtitClassifierNumberInfo = (*itInfoClassifierActivity).second.begin(); itUnChtitClassifierNumberInfo != (*itInfoClassifierActivity).second.end(); itUnChtitClassifierNumberInfo++) { TClassifierNumber leNumberDuClasseur = (*itUnChtitClassifierNumberInfo).first; bool wasActive = (*_pOldInfoClassifierActivity)[motivationName][leNumberDuClasseur].IsActive; bool isActive = (*itUnChtitClassifierNumberInfo).second.IsActive; if (isActive) { if (!wasActive) { _TemporaryPriority[motivationName][leNumberDuClasseur].StartTime = newTime; _TemporaryPriority[motivationName][leNumberDuClasseur].LastTime = newTime; _TemporaryPriority[motivationName][leNumberDuClasseur].FixedStartTime = true; _TemporaryPriority[motivationName][leNumberDuClasseur].TemporaryClassifierPriorityTime = 0; } // Je fais progresser le timer uint32 lastTime = _TemporaryPriority[motivationName][leNumberDuClasseur].LastTime; if (lastTime > newTime) { newTime = lastTime; } uint32 diffTime = newTime - lastTime; _TemporaryPriority[motivationName][leNumberDuClasseur].LastTime = newTime; _TemporaryPriority[motivationName][leNumberDuClasseur].TemporaryClassifierPriorityTime += diffTime; } // if (isActive) // { // // Si l'action n'avait pas de startTime fixé, on lui en donne un. // bool avaitUnFixedStartTime = false; // std::map<TMotivation, std::map<TClassifierNumber, CTemporaryPriority> >::iterator itTemporaryPriority = _TemporaryPriority.find(motivationName); // if (itTemporaryPriority != _TemporaryPriority.end() ) // { // std::map<TClassifierNumber, CTemporaryPriority>::iterator itClassifierAndPrio = (*itTemporaryPriority).second.find(leNumberDuClasseur); // if (itClassifierAndPrio != (*itTemporaryPriority).second.end() ) // { // avaitUnFixedStartTime = (*itClassifierAndPrio).second.FixedStartTime; // } // } // if (!avaitUnFixedStartTime) // { // _TemporaryPriority[motivationName][leNumberDuClasseur].StartTime = newTime; // _TemporaryPriority[motivationName][leNumberDuClasseur].FixedStartTime = true; // _TemporaryPriority[motivationName][leNumberDuClasseur].TemporaryClassifierPriorityTime = 0; // } // else // { // // Si elle avait un startime, on regarde si elle était active au tour précédent. // bool etaitActifJusteAvant = false; // std::map<TMotivation, std::set<TClassifierNumber> >::iterator itOldClassifierByMotivation = oldClassifierByMotivation.find(motivationName); // if (itOldClassifierByMotivation != oldClassifierByMotivation.end()) // { // std::set<TClassifierNumber>::iterator itClassifier = (*itOldClassifierByMotivation).second.find(leNumberDuClasseur); // if (itClassifier != (*itOldClassifierByMotivation).second.end() ) // { // etaitActifJusteAvant = true; // } // } // if (!etaitActifJusteAvant) // { // _TemporaryPriority[motivationName][leNumberDuClasseur].LastTime = newTime; // } // } // // // Je fais progresser le timer // uint32 lastTime = _TemporaryPriority[motivationName][leNumberDuClasseur].LastTime; // if (lastTime > newTime) // { // newTime = lastTime; // } // uint32 diffTime = newTime - lastTime; // _TemporaryPriority[motivationName][leNumberDuClasseur].LastTime = newTime; // _TemporaryPriority[motivationName][leNumberDuClasseur].TemporaryClassifierPriorityTime += diffTime; // } } } }

void NLAINIMAT::CMHiCSagent::motivationCompute (   )  [private]

Definition at line 982 of file mhics.cpp. References _ClassifiersAndMotivationIntensity, _pMHiCSbase, _pSensorsValues, NLAINIMAT::Action_DoNothing, NLAINIMAT::CMHiCSbase::getActionPart(), NLAINIMAT::CMotivationEnergy::getSumValue(), NLAINIMAT::CMHiCSbase::selectBehavior(), NLAINIMAT::TAction, NLAINIMAT::TClassifierNumber, NLAINIMAT::TMotivation, and NLAINIMAT::TTargetId. Referenced by run(). { TAction behav; std::map<TMotivation, CMotivationEnergy>::iterator itClassifiersAndMotivationIntensity; // On parcour toutes les motivations. for (itClassifiersAndMotivationIntensity = _ClassifiersAndMotivationIntensity.begin(); itClassifiersAndMotivationIntensity != _ClassifiersAndMotivationIntensity.end(); itClassifiersAndMotivationIntensity++) { CMotivationEnergy* pCSselection = &((*itClassifiersAndMotivationIntensity).second); TMotivation selectionName = (*itClassifiersAndMotivationIntensity).first; double energy = pCSselection->getSumValue(); // Si une motivation est active (une energie >0 ) on actionne ses règles. if (energy > 0) { // On fait calculer le CS std::multimap<CClassifierPriority, std::pair<TClassifierNumber, TTargetId> > mapActivableCS; std::multimap<CClassifierPriority, std::pair<TClassifierNumber, TTargetId> >::iterator itMapActivableCS; // On fait la liste des classeurs activables. _pMHiCSbase->selectBehavior(selectionName,_pSensorsValues, mapActivableCS); // Pour chaque classeur activable, on transmet la valeur de motivation à l'action selectionnée. for (itMapActivableCS = mapActivableCS.begin(); itMapActivableCS != mapActivableCS.end(); itMapActivableCS++) { TClassifierNumber selectedClassifierNumber = (*itMapActivableCS).second.first; TTargetId currentTargetId = (*itMapActivableCS).second.second; behav = _pMHiCSbase->getActionPart(selectionName, selectedClassifierNumber); (*_pInfoClassifierActivity)[selectionName][selectedClassifierNumber].IsActivable = true; // We add the current motivation energy to the selected action. if (behav != Action_DoNothing) { // std::map<TTargetId, std::map<TAction, CMotivationEnergy> >::const_iterator itOldActionsExecutionIntensityByTarget = (*_pOldActionsExecutionIntensityByTarget).find(currentTargetId); // if (itOldActionsExecutionIntensityByTarget != (*_pOldActionsExecutionIntensityByTarget).end() ) // { // std::map<TAction, CMotivationEnergy>::const_iterator itIntensityByTarget = (*itOldActionsExecutionIntensityByTarget).second.find(behav); // if (itIntensityByTarget != (*itOldActionsExecutionIntensityByTarget).second.end()) // { // (*_pActionsExecutionIntensityByTarget)[currentTargetId][behav].setWasPreviouslyActived(true); // } // } (*_pActionsExecutionIntensityByTarget)[currentTargetId][behav].setMHiCSagent(this); (*_pActionsExecutionIntensityByTarget)[currentTargetId][behav].addProvider(selectionName, selectedClassifierNumber); } } } } }

void NLAINIMAT::CMHiCSagent::run (   )

* if (selectedClassifierNumber < 0) Definition at line 1159 of file mhics.cpp. References _pActionsExecutionIntensityByTarget, _pInfoClassifierActivity, _pOldActionsExecutionIntensityByTarget, _pOldInfoClassifierActivity, and motivationCompute(). { std::map<TTargetId, std::map<TAction, CMotivationEnergy> > *bibu = _pOldActionsExecutionIntensityByTarget; _pOldActionsExecutionIntensityByTarget = _pActionsExecutionIntensityByTarget; _pActionsExecutionIntensityByTarget = bibu; _pActionsExecutionIntensityByTarget->clear(); std::map<TMotivation, std::map<TClassifierNumber, CClassifierActivityInfo> > *biba = _pOldInfoClassifierActivity; _pOldInfoClassifierActivity = _pInfoClassifierActivity; _pInfoClassifierActivity = biba; _pInfoClassifierActivity->clear(); motivationCompute(); // virtualActionCompute(); }

const std::map< TTargetId, std::map< TAction, CMotivationEnergy > > * NLAINIMAT::CMHiCSagent::selectBehavior (   )

Return the Behavior that must be active. Definition at line 1548 of file mhics.cpp. References _ClassifiersAndMotivationIntensity, _Learning, _OldClassifiersAndMotivationIntensity, _pActionsExecutionIntensityByTarget, _pMHiCSbase, NLAINIMAT::CActionResources::filterMyActions(), learningComputation(), nlassert, NLAINIMAT::CMHiCSbase::pActionResources, NLAINIMAT::TAction, and NLAINIMAT::TTargetId. { //We sort actions by priority double priority; TAction action; TTargetId target; std::multimap<double, std::pair<TTargetId,TAction> > actionsToRemove; std::map<TTargetId, std::map<TAction, CMotivationEnergy> >::iterator itActionsExecutionIntensityByTarget; std::map<TAction, CMotivationEnergy>::const_iterator itMotiveByAction; for (itActionsExecutionIntensityByTarget = _pActionsExecutionIntensityByTarget->begin(); itActionsExecutionIntensityByTarget != _pActionsExecutionIntensityByTarget->end(); itActionsExecutionIntensityByTarget++) { for (itMotiveByAction = (*itActionsExecutionIntensityByTarget).second.begin(); itMotiveByAction != (*itActionsExecutionIntensityByTarget).second.end(); itMotiveByAction++) { priority = (*itMotiveByAction).second.getSumValue(); action = (*itMotiveByAction).first; target = (*itActionsExecutionIntensityByTarget).first; // on rajoute du bruit sur les priorité afin d'avoir une diversité si des priorités sont proches // double randomeNumber = ((rand()%5)*priority)/100; // priority += randomeNumber; actionsToRemove.insert(std::make_pair(priority, std::make_pair(target,action))); } } _pMHiCSbase->pActionResources->filterMyActions(actionsToRemove); std::multimap<double, std::pair<TTargetId,TAction> >::iterator itActionsToRemove; for (itActionsToRemove = actionsToRemove.begin(); itActionsToRemove != actionsToRemove.end(); itActionsToRemove++) { target = (*itActionsToRemove).second.first; action = (*itActionsToRemove).second.second; itActionsExecutionIntensityByTarget = _pActionsExecutionIntensityByTarget->find(target); nlassert (itActionsExecutionIntensityByTarget != _pActionsExecutionIntensityByTarget->end()); itMotiveByAction = (*itActionsExecutionIntensityByTarget).second.find(action); nlassert (itMotiveByAction != (*itActionsExecutionIntensityByTarget).second.end()); (*itActionsExecutionIntensityByTarget).second.erase(action); if ( (*itActionsExecutionIntensityByTarget).second.begin() == (*itActionsExecutionIntensityByTarget).second.end() ) { _pActionsExecutionIntensityByTarget->erase(target); } } if (_Learning) { learningComputation(); _OldClassifiersAndMotivationIntensity = _ClassifiersAndMotivationIntensity; } return _pActionsExecutionIntensityByTarget; }

void NLAINIMAT::CMHiCSagent::setLearning (  bool  active  )

Definition at line 1181 of file mhics.cpp. References _Learning. { _Learning = active; }

void NLAINIMAT::CMHiCSagent::setMotivationPP (  TMotivation  motivationName, double  PP )

Donne la Puissance Propre d'une Motivation. Definition at line 780 of file mhics.cpp. References _ClassifiersAndMotivationIntensity. { _ClassifiersAndMotivationIntensity[motivationName].setMHiCSagent(this); _ClassifiersAndMotivationIntensity[motivationName].setMotivationPP(motivationName, PP); // spreadMotivationReckon(motivationName); }

void NLAINIMAT::CMHiCSagent::setMotivationValue (  TMotivation  motivationName, double  value )

Fixe la valeur d'une motivation. Definition at line 802 of file mhics.cpp. References _ClassifiersAndMotivationIntensity, and value. { // if (_Learning) // { // double lastMotiveValue = _ClassifiersAndMotivationIntensity[motivationName].getMotivationValue(motivationName); // // Si la valeur de motivation a diminuée, il est temps d'apprendre // if (lastMotiveValue > value) // { // learningComputationMotivationDecrease(motivationName); // } // } std::map<TMotivation, CMotivationEnergy>::iterator itClassifiersAndMotivationIntensity = _ClassifiersAndMotivationIntensity.find(motivationName); if (itClassifiersAndMotivationIntensity == _ClassifiersAndMotivationIntensity.end()) { itClassifiersAndMotivationIntensity = _ClassifiersAndMotivationIntensity.insert(std::make_pair(motivationName,CMotivationEnergy())).first; // On en profite pour mettre à zero la date de la première réponse positive d'une motivation // _TimeOfLastMotivationValueDecrease[motivationName] = NLMISC::CTime::getSecondsSince1970(); } (*itClassifiersAndMotivationIntensity).second.setMHiCSagent(this); (*itClassifiersAndMotivationIntensity).second.setMotivationValue(motivationName, value); // spreadMotivationReckon(motivationName); }

void NLAINIMAT::CMHiCSagent::setSensors (  CCSPerception *  psensorMap  )

Set the sensor source. Definition at line 1176 of file mhics.cpp. References _pSensorsValues. { _pSensorsValues = psensorMap; }

std::string NLAINIMAT::CMHiCSagent::targetId2String (  TTargetId  id  )  const [private]

function used in debug to change a TTargetId in a string Definition at line 691 of file mhics.cpp. References NLMISC::toString(), and NLAINIMAT::TTargetId. Referenced by getDebugString(). { /* // Le format est celui pour afficher en debug le Nb comme dans Ryzom. uint32 aiBoteId = id; uint32 managerID = (aiBoteId>>(8+12))&( (1<<10)-1 ); uint32 groupeID = (aiBoteId>>8)&( (1<<12)-1 ); uint32 boteID = aiBoteId&( (1<<8)-1 ); char result[30]; sprintf(result,"AI:%04x:BOT:%04x:%04x:%04x",aiBoteId,managerID,groupeID,boteID); return result; */ std::string ret = NLMISC::toString(id); return ret; }

bool NLAINIMAT::CMHiCSagent::wasClassifierPreviouslyActive (  TMotivation  motivationName, TClassifierNumber  classifierNumber )  const

Definition at line 1624 of file mhics.cpp. References _pOldInfoClassifierActivity, and NLAINIMAT::TClassifierNumber. Referenced by NLAINIMAT::CMotivationEnergy::computeMotivationValue(). { bool wasPreviouslyActived = false; std::map<TMotivation, std::map<TClassifierNumber, CClassifierActivityInfo> >::const_iterator itOldInfoClassifierActivity; itOldInfoClassifierActivity = (*_pOldInfoClassifierActivity).find(motivationName); if (itOldInfoClassifierActivity != _pOldInfoClassifierActivity->end()) { std::map<TClassifierNumber, CClassifierActivityInfo>::const_iterator itClassifierInfo = (*itOldInfoClassifierActivity).second.find(classifierNumber); if (itClassifierInfo != (*itOldInfoClassifierActivity).second.end() ) { wasPreviouslyActived = (*itClassifierInfo).second.IsActive; } } return wasPreviouslyActived; }

---

Field Documentation

std::map<TMotivation, CMotivationEnergy> NLAINIMAT::CMHiCSagent::_ClassifiersAndMotivationIntensity [private]

Definition at line 294 of file mhics.h. Referenced by getDebugString(), getMotivationPP(), getMotivationValue(), learningComputation(), motivationCompute(), selectBehavior(), setMotivationPP(), and setMotivationValue().

bool NLAINIMAT::CMHiCSagent::_Learning [private]

Definition at line 300 of file mhics.h. Referenced by CMHiCSagent(), selectBehavior(), and setLearning().

std::map<TMotivation, CMotivationEnergy> NLAINIMAT::CMHiCSagent::_OldClassifiersAndMotivationIntensity [private]

Definition at line 295 of file mhics.h. Referenced by learningComputation(), and selectBehavior().

std::map<TTargetId, std::map<TAction, CMotivationEnergy> >* NLAINIMAT::CMHiCSagent::_pActionsExecutionIntensityByTarget [private]

Definition at line 298 of file mhics.h. Referenced by CMHiCSagent(), getExecutionIntensity(), learningComputation(), run(), selectBehavior(), and ~CMHiCSagent().

std::map<TMotivation, std::map<TClassifierNumber, CClassifierActivityInfo> >* NLAINIMAT::CMHiCSagent::_pInfoClassifierActivity [private]

Definition at line 304 of file mhics.h. Referenced by CMHiCSagent(), run(), and ~CMHiCSagent().

CMHiCSbase* NLAINIMAT::CMHiCSagent::_pMHiCSbase [private]

Definition at line 293 of file mhics.h. Referenced by CMHiCSagent(), getMHiCSbase(), learningComputation(), motivationCompute(), and selectBehavior().

std::map<TTargetId, std::map<TAction, CMotivationEnergy> >* NLAINIMAT::CMHiCSagent::_pOldActionsExecutionIntensityByTarget [private]

Definition at line 299 of file mhics.h. Referenced by CMHiCSagent(), run(), and ~CMHiCSagent().

std::map<TMotivation, std::map<TClassifierNumber, CClassifierActivityInfo> >* NLAINIMAT::CMHiCSagent::_pOldInfoClassifierActivity [private]

Definition at line 305 of file mhics.h. Referenced by CMHiCSagent(), run(), wasClassifierPreviouslyActive(), and ~CMHiCSagent().

CCSPerception* NLAINIMAT::CMHiCSagent::_pSensorsValues [private]

Definition at line 297 of file mhics.h. Referenced by getDebugString(), motivationCompute(), and setSensors().

std::map<TMotivation, std::map<TClassifierNumber, CTemporaryPriority> > NLAINIMAT::CMHiCSagent::_TemporaryPriority [private]

Definition at line 303 of file mhics.h. Referenced by getTemporaryClassifierPriorityTime(), and learningComputation().

---

The documentation for this class was generated from the following files:

• mhics.h
• mhics.cpp

---