Real-time retrieval for case-based reasoning in interactive multiagent-based simulations

The aim of this paper is to present the principles and results about case-based reasoning adapted to real- time interactive simulations, more precisely concerning retrieval mechanisms. The article begins by introducing the constraints involved in interactive multiagent-based simulations. The second section pre- sents a framework stemming from case-based reasoning by autonomous agents. Each agent uses a case base of local situations and, from this base, it can choose an action in order to interact with other auton- omous agents or users' avatars. We illustrate this framework with an example dedicated to the study of dynamic situations in football. We then go on to address the difficulties of conducting such simulations in real-time and propose a model for case and for case base. Using generic agents and adequate case base structure associated with a dedicated recall algorithm, we improve retrieval performance under time pressure compared to classic CBR techniques. We present some results relating to the performance of this solution. The article concludes by outlining future development of our project.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 29

01/31/2018

pv:SSCategory

The study and publication of historical scientific manuscripts are com- ...
10/24/2011

Quels formalismes temporels pour représenter des connaissances extraites de textes de recettes de cuisine ?

The Taaable projet goal is to create a case-based reasoning system for r...
01/31/2018

A Semantic Model for Historical Manuscripts

The study and publication of historical scientific manuscripts are com- ...
04/29/2019

Argus: Smartphone-enabled Human Cooperation via Multi-Agent Reinforcement Learning for Disaster Situational Awareness

Argus exploits a Multi-Agent Reinforcement Learning (MARL) framework to ...
08/31/2021

Autonomous Rollator: A Case Study in the Agebots Project

In this paper, we present an iterative development process for a functio...
02/28/2019

Real-time tree search with pessimistic scenarios

Autonomous agents need to make decisions in a sequential manner, under p...
06/09/2019

Analysis of a Poisson-picking symmetric winners-take-all game with randomized payoffs

Winners-take-all situations introduce an incentive for agents to diversi...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Videogame technologies have recently begun to be used for the purposes of scientific simulation and visualization (ferey-2008), industrial and military training (gonzalez-1998; Buche04b), and finally medical and health training and education (volbracht-1998; Bideau-2003). Within these simulations, users can interact with autonomous agents and/or human avatars of team members (Raybourn_iwc07).

Unlike video games, these simulations tend not to focus on the quality of graphical representations or animation which are not always necessary for optimizing understanding of these situations (metoyer-2000). The most important point is to ensure variability and sponteneity within the simulation. The present paper adresses this issue in dynamic and collaborative situations. Unlike procedural activities, dynamic and collaborative situations cannot easily be defined by sequences of rules as there are an infinite number of possible situations. These situations result from local interaction beetwen participants unaware of the overall situation. It is therefore possible to simulate such dynamics using autonomous agents interacting with one or more users. In this case, decision-making is a rapid process largely influenced by context, and therefore partial perception, time limitations, high stakes, uncertainty, unclear goals, and organizational constraints (jonsson03; kofod-petersen05:_contex). Consequently, the outcomes of agents’ actions are unpredictable but can be qualified as more or less believable than real-life experience. Moreover, the objective is to simulate adaptive behaviors capable of reacting to many different situations with some variability.

Credibility depends on psychological and subjective considerations (loyall-2004) and is difficult to quantify. Systematic approaches, such as defining an explicit set of rules (laird-2000), or automatically learning rules (sanza-1999), therefore conflict with believability. Even if these lastest methods are used to define behaviors in simulating collaborative and dynamic situations (ros-2006), they are based on the optimization of “simple” criteria (for example, an agent’s score, or time taken to complete a task). Consequently, the resulting behavior is efficient, but unnatural and unsuitable for human learning.

Another approach is available to interactively construct dynamic and collaborative situations: the use of case-based reasoning (CBR) (aamodt-1994) in association with context modeling (gonzalez-1998; brezillon-1999, benard06c). Case-based reasoning stems from analogous reasoning (Kolodner1993; Riesbeck1989; Eremeev2006), which is particularly relevant for addressing decision-making in dynamic and collaborative situations (bossard-2006). Context relies on all the elements perceived at any one time by a given agent which might influence its decision-making. This concept arises from ecological psychology (gibson-1958) and is strongly linked with naturalistic decision making (klein-2008

). This article mainly addresses the principal difficulty faced when using CBR in this way: maintaining performance in real-time. The time needed to retrieve a case increases with the size of the base multiplied by the number of autonomous agents. For real-time purposes, it is unacceptable for the time taken to make a decision to be linearly dependent on the size of the base (time taken to scan the base), as it is subject to great variation. Depending on the domain in which CBR is applied, the size of the base may increase with experience, or by means of machine learning algorithms executed during experimental sessions etc. Moreover, the term “dynamic situation” implies that, at any given time, agents must be able to carry out an action even if it is not the best one. Nevertheless, it is important to be aware that, even when these decisions may be inappropriate, they are the result of heuristics and are not merely random. Experts also claim that perceptions guide actions and that not all perceptions are equal, but rather they depend on their implication in the decision (

klein-2008). It is therefore important to highlight the fact that incorrect or incomplete perceptions may lead to inappropriate actions. Such approximate perception is attributed to a lack of time available to perceive.

These principles can be implemented using the architecture presented here in this paper. This architecture will be able to model 1) that some perceptions are more relevant than others in making decisions (under time pressure, agents will focus on these perceptions first), and 2) that the shorter the time, the worse the perception, and therefore decisions made due to that perception, will be.

This article is divided into three main parts: section 2 describes CBR and a context model associated to each case. An application, CoPeFoot, is used to illustrate this proposal. Section 3 addresses a real-time adaptation of case retrieval. Section 4 shows how this proposition improves recall results and system precision under real-time constraints. These results are also discussed in preparation for the conclusion in section 5.

2 CBR for Decision-Making in Virtual Agents

Case-based reasoning stems from analogous reasoning which states that each situation encountered can be associated with another similar well-known and appropriately-resolved situation. The difficulty is in defining how to associate situations in order to choose the most relevant, and to adapt one situation to fit another. The principles of case-based reasoning are summarized in figure 1. When the expert system encounters a problem (case target) it searches for a similar case in its base (case source) which is associated with a solution (solution(source)). It then adapts either (solution(source)) or the resolution derived from case source to (solution(source)), in order to define the solution (solution(target)). The main advantage is that it is unnecessary to detail an exhaustive resolution mechanism which can become so complex that it is in fact unknown. The adaptation step concerns either the resolving procedure or the solution directly (Lieber-2007; Cordier2006).

An application of CBR to decision-making in autonomous agents in interactive simulations is illustrated in figure 2. Each autonomous agent uses CBR to choose its subsequent decisions within the simulation.

The context box is the process of abstraction which extracts semantic information from features perceived in the simulated world. More precisely, whereas simulations produce low-level information like changes in the positions of objects, the context box gives information such as the qualitative distances between agents (agent a is far from agent b), or more domain dependent information (see examples in the following section). Each autonomous agent has its own context depending on its position in the virtual world. In CBR, this step is known as elaboration, during which all of the relevant context elements are defined by experts. This context is compared with elements from the case base in order to select one case (“recall step”). Finally, using semantic information, the case is adapted to the current situation and autonomous agents can act within the virtual world (“adaptation step”). Both the elaboration and adaptation steps are part of psychological research linked to the field in which the CBR is implemented.

2.1 Application

The theoretical proposition was implemented in the CoPeFoot simulation tool for studying collaborative and dynamic situations in sport (bossard-2006). This application will be used to illustrate each step of the theoritical model. The pratical uses of CoPeFoot are described in (bossard-2006). It is designed to be used for training sports coaches and referees. Both the starting conditions and the exercices can be configured in order to immerse a real player in a 3D scene with autonomous players (by means of stereo vision glasses). Users can also study the situations from different points of view by watching the recordings of their movements. Figure 3 depicts a user interacting with CoPeFoot in an immersive room.

2.2 Context Model

Although context is domain dependent, it is possible to formalize its data structure as follows: a context is a set of predicates. Each predicate stands for one possible perception of an agent, and is domain-specific. Examples of such perceptions for football are the fact that a player is marked (followed by an opponent) or that a team-mate is asking for the ball (asking for the ball is a possible action for any player).

A predicate is a triplet where:

  • is the name of the perception (for example to express the perception of a specific distance).

  • is a set of variables. Each variable has a type inherited from a generic type DomainObject or an Agent type. This type is interesting because, in dynamic situations, some cases are only different because the identity of some of the agents differ, whereas the other context elements remain the same. In order to reduce the case base size and improve adaptation, it is therefore possible to formalize a generic case representing all the cases with the same context except the identity of the agents (see section 2.4 for details).

  • is the variable which expresses the intended value of the predicate. It is used when transforming the case base into a hierachical tree (see section 3). Two types are possible:

    • : expresses the success of a Boolean test linked with the purpose of the predicate.

    • : an abstraction of a number (e.g. a distance beetwen 8 and 20 meters is equivalent to the qualitative value “far”) and enables the aggregation of a number of values into one when considered by experts to be similar enough.

Variables are instantiated in real-time by the simulator using a prolog-like mechanism when the CBR enquires about the validity of predicates during recall.

2.3 Application to CoPeFoot

Table 1 shows the predicates engaged at a specific moment in the

CoPeFoot simulator. Some predicates like or or are very general and applied to a type which represents all possible objects perceived in the 3D scene. Other predicates are more specific to football (, , , , , , , , ). They use variables which represent football players. Other football-specific predicate types are , , , or (these last three types inherit from ). For example, when CBR asks the simulator about the validity of one predicate which means is a marked football player currently perceived?, the simulator answers true with an instanciation: X=Agent.3 (in this case, Agent.3 is an instance of the Agent class of the simulation which is perceived by the Agent decision-maker and marked by an opponent). If no players are marked, the simulator answers false.

2.4 Generic Case Model

In the following section, we will outline the model of a generic case using generic agents and an instanciated case which corresponds to a concrete situation with instanciated agents. The case base, representing source cases, is made up of a set of generic cases whereas instanciated cases are elaborated from an “instantaneous” moment of the situation in the simulation; they correspond to target cases.

A generic case is a triplet , where:

  • is a set of the agent’s perceptions . A perception is a triplet where:

    • is the name of a predicate

    • is the set of values of the variables .

    • is the value of .

    In generic cases, variables are not instances of the simulation (like Agent.1 or Agent.2) but are rather generic agents representing every possible agent in the simulation. Predicates can thus be linked together in the case. For example, in CoPeFoot, a case can specify that the marked generic agent A is the same as the agent in possession of the ball, but that another generic agent B is far from the first (in this case ). It is worth noting that there is one exception: the agent , the decision maker, is not instanciated by a generic agent. Indeed, to obtain consistent decision-making, it is important to distinguish this agent from all the others, even in a generic case.

    This case base is heterogenous, i.e. the number of perceptions relative to a case and the type of perceptions differ for each case. Indeed, it depends on the situation/orientation/position of the player who will not always perceive the same elements.

  • is a set of predicate relevance weights: . Where:

    • is a perception of the generic case

    • is a case from the case base

    Hence, a weight is a real value, representative of the relevance of the perception for the case . This relevance must be defined by experts. The classical similarity function between two cases and is adapted for cases with non-constant numbers of parameters, and is described by equation 1 in section 2.6.

Figures 4 and 5, respectively give a simple example from CoPeFoot written in XML, for the context “ ” and of one generic case relying on this context.

2.5 Instanciated Case Model

An instanciated case arises from a generic case with generic agents substituted by instances of the simulation (noted Agent.1, Agent.2 …etc). Generally, they constitute target cases.

An example from CoPeFoot of a case which matches the example in figure 5 is .

2.6 Similarity

From a source case and a target case represented by a perception set , we define , the set of common perceptions of and when players of are instanciated with players of : . The similarity value beetwen the source case and the target case is defined by equation 1.

(1)

This equation takes into account the base’s heterogeneous nature. It is therefore possible to compare the similarity between two source cases and the target case even if the sources and the target differ in their numbers of perceptions. In such a case, the nearer the number of identical perceptions is to the case size , the greater the similarity. is a weighting parameter with a value between 0 and 1. Its influence on similarity, recall and precision is explained in section 4.

3 Anytime CBR

3.1 Search-Tree for Real-Time Selection

Theoretically, recall implies comparing an instantaneous target case with all the generic source cases in the base using the similarity function, in order to select the most similar source case. In an interactive simulation, the agent needs to make a decision at a precise moment under time pressure. This is dependent on processes like updating (refreshing) the 3D scene, the other agents’ decision-making (for example, 22 agents within the context of football), and interaction with users. Moreover, the base size could increase as the application improves both in terms of function and expertise.

Base scanning must be optimized for both quantity (reducing the number of tests) and quality (addressing first the relevant perception to make an adequate decision). Here we shall consider a brief summary of this mechanism. It is based on the following facts:

  • Some variables are shared by different predicates. In these cases it is possible to evaluate each case in parallel.

  • It is possible, with the help of experts, to define a global order of priority between the perceptions (predicates) taken into account by a player when identifying a case. This order improves both the retrieval speed and the adaptability of selected cases. Less adaptable and domain-specific perceptions are found at the top of the tree. Let us take an example from football. One crucial piece of information for making appropriate decisions is to know if the player in possession of the ball is in our team or not. Furthermore, it is more difficult for another player to change the player who is in possession of the ball than it is to reduce the distance between himself and that player. Consequently, the predicate representing the perception of the player in possession of the ball is positioned higher in the tree than the predicate relative to the distance from this player.

Hence, perceptions are grouped together in a tree which re-organizes the case base. Figure 6 shows an example of one such tree relative to:

  1. the context of figure 4,

  2. three generic cases (for simplicity the set of pertinence weights are not defined here):

    • case1={{{hasBall,{me},false},{partner,{A},true},{distance,{ball,A},long}}, }

    • case2={{{hasBall,{me},true},{partner,{B},true}}, }

    • case3={{{hasBall,{me},false},{partner,{A},false},{distance,{ball,B},long}}, }

  3. an order of priority :

Each node represents a predicate , with each variable of being instanciated according to the value corresponding to each individual case. Each arrow is an instantiation of the which contributes to its validation according to case base. Some nodes are shared by different cases but each case corresponds to one branch. It must be noted that this example is simplified in order to illustrate the principle; typically, trees such as these contain about one hundred nodes.

Technically, algorithm 1 constructs such a tree from the case base and the priority order beetween predicates. This tree is built only once, at the beginning of the simulation, and is then used for real-time case retrieval.

Data: generic cases ;
context
priority order of Result: Hierarchical tree of generic cases
begin  Create an empty node root;
;
forall do  forall in the priority order do  if ( is labelled with ) then  if (exists an arc starting from , ending with a node n and labelled with the test ) then  ;
end else  Create an arc from to a new empty node labelled with the test ;
end end else  Labelling with ;
Create an empty node and an arc from to labelled with the test ;
;
end end Labelling ( a leaf of the tree) with the name ;
;
end end
Algorithm 1 Building the generic cases tree: note that ( such that and and )

3.2 Evaluating Similarity in Real-Time

The tree is scanned widthwise during the simulation to identify cases similar to the current situation. This scanning is interrupted by the simulator when it is the turn of the corresponding autonomous agent to make a decision. Consequently, the most similar case in the base must be available at any time. In order to do so, requests are sent to the context box, starting from the root (see figure 2). In response, the values of variables validating the perception of each scanned node ( and ) are transmitted, if they exist. If they do not exist, the variables remain un-instanciated in the tree. The longer the delay beetwen two interruptions, the higher the number of scanned nodes and instanciated variables. If an arc is invalidated by the value of its corresponding tested variable (), the branch is pruned and the similarities of corresponding cases are no longer evaluated.

For one source case , the set of nodes which are along the branch from the root to the final node corresponds to . In section 2.6, we defined the similarity function beetwen such a case and a target case represented by a perception set (equation 1). It is possible to adapt this definition for real-time similarity evaluation in the following manner: can be defined as is the set of perceptions of which are already scanned (starting from the root) at time . Similarly, it is possible to define . This definition implies that:

(2)
(3)

The real-time similarity function beetween and a target case defined by a set is given in equation 4.

(4)

4 Results

The aim of the following experiment is to illustrate the performance of this proposition as compared to a classical approach in terms of real-time performance for recall and precision criteria. The first part evaluates the improvement in terms of memory size. The second part shows the influence of the

parameter on precision and recall. Finally, we adress variations in recall and precision relative to time taken for the algorithm to retrieve similar source cases. To obtain these results, we used two different types of bases representing the same cases. The first,

linear Base, was a standard base, composed of a list of cases that were an enumeration of perceptions such as those shown in figure 5. The second base, tree Base, was a tree obtained with the algorithm 1 applied to the linear Base.

4.1 Case Base Size

The first results deal with the size of the case base and, more precisely, memory space gained due to the base’s tree structure. To obtain these curves, an increasing number of cases are introduced in the two bases (tree Base and linear Base). Cases in CoPeFoot occur in the following manner: from an empty case base, users control avatars, and every time they act (press a button), the system records the corresponding case and stores it in the base. Figure 7 shows the evolution of the number of perceptions stored in bases during acquisition. The dotted lines represent linear Base and the continuous line tree Base.

4.2 Impact of on Recall and Precision

The results introduced in this section are identical for linear Base and tree Base. They indicate the ways in which it is possible to favor recall relative to precision. In equation 1, similarity depends on a parameter, . For this measurement, experts define a set of cases which are similar to a target case, . This pre-defined set is called . The set of cases found through case retrieval is called . To carry out this set, similarity function 1 is combined with an acceptance threshold. Similarity functions use relevant weights which are also defined by an expert. The acceptance threshold corresponds to the least significant similarity beetwen each case in and the target : .

As in (kumar-2009), recall and precision are defined as:

(5)
(6)

with:

  • , number of cases correctly found by the algorithm relative to the expert’s definitions.

  • , number of cases which should not have been considered (expert did not consider them similar to the target)

  • , cases not found by the algorithm.

Figure 8 shows that depending on the parameter, we can favor either recall or precision. The nearer is to 1, the worse the similarities: recall is poor and precision is great. On the contrary, the closer is to 0, the better the similarities are: recall is optimized and precision is poor. The best results are obtained with which is the value used to define the acceptance threshold . For the following evaluations, is set at 0.5.

4.3 Real-Time Performance

In this section, we compare real-time performance between the linear Base and the tree Base for both recall and precision. The evaluation of both bases is illustred in figure 9. In the case of the linear Base, the shorter the time, the smaller the number of evaluated cases. This impacts negatively on both recall and precision. To prevent bias linked to case scanning order, cases are chosen randomly and the calculation repeated one hundred times. The curve indicates average precision and recall. With tree Base, the order of perceptions is fixed following an analysis by the expert. Similarly to linear base, the shorter the time, the less nodes

are taken into account. This negatively impacts on similarity but a value can be estimated for every case using equation

4.

The system took between 2 and 10 ms to evaluate the most similar cases. Simulations were performed with a dual-core processor (3,4 GHz with 2Gb of memory). With more than 10 ms the system has enough time to scan and evaluate the entire linear Base and all the nodes of the treeBase. In order to enhance the credibility of the simulation, it is important not to leave too much time between two decisions. For example, in CoPeFoot, with 10 autonomous agents, all of the decision-making calculations for the whole team can be acheived in between 20 and 100 ms. For interactive simulation, a frame rate of 25 images per second is generally considered acceptable.

Figure 9 shows that recall obtained with linear Base decreases to 8ms. At this speed, not all of the cases from the base could be evaluated, so precision also begins to decrease. The situation is better for the tree Base since precision and recall decrease to 4.2 and 3.4 ms respectively. Nevertheless, when precision and recall values for tree Base decrease, they fall sharply until they are poorer than those of the linear Base. This can easily be explained since, when processing the tree, if the number of nodes to be processed is so low (falls below a threshold value) that there are not enough significant nodes to be able to calculate the similarities, this affects all of the cases within the base and not only some of them, as is the case in the linear Base. Indeed, within this time (4.2 ms), it is possible to scan 1/10 of the linear Base, but this is not the case for Tree Base. Nevertheless, section 4.1 showed that tree Base is smaller than linear Base. Problems stem from the fact that it takes a long time to browse tree nodes. To illustrate this aspect, figure 10 shows the same results as figure 9. However, this time, the abscissa do not indicate real-time but rather the number of comparisons between the perceptions given to the system. Due to this fact, treeBase performance is better than that of linear Base.

It is worth noting that in these experiments, the case base contains only 50 cases, to ease the work of the experts defining the set. The base size is much larger when simulating a football game. The bigger the base, the greater the difference between treeBase and linearBase will be. In this case, the curves in figure 9 would be much more similar to those in figure 10.

5 Conclusions

Real-time constraints are a critical problem for CBR use in interactive simulations. However, experts claim that it is an appropriate solution for modeling relevant decision-making in simulations of collaborative and dynamic situations (Bossard-2007). The main topic of this article is real-time case retrieval. The proposed solution stems from arborescent case bases, which enable the similarity between a target situation and all the cases in the base to be calculated at any time. The precision of this calculation depends on the time allocated for it but unlike the use of a linear Base, there is a proposed value for each case at any given time. Moreover, in accordance with psychological considerations, the longer the time allowed, the better the evaluation of a situation. Some prelimilary tests confirmed the credibility of the resulting behavior in CoPeFoot (bossard-2009).

Case genericity, obtained by the use of a generic agent, means that a general configuration can be adapted to a given instanciated target situation coming from the simulator. In order to do so, all instanciated players are unified with the corresponding generic agent. These instanciated agents are part of generic actions, which are not detailed in this article. Indeed, for the moment, we are testing some further definitions of generic action in order to better formalize adaptation, but further coordination with experts is required. We are currently developing an expert module of CoPeFoot: ExPeCoPeFoot. This new module facilitates the interactions beetwen the simulator and experts. They can refine the case base (weight of , set of relevant perceptions) during the course of the simulation.

References

6 Table

S
(with their types) (with its type)
distance {O1 (Physical object), O2 (Physical object) } D (Qualitative value)
relativePosition {O1 (Physical object), O2 (Physical object) } O (Qualitative value)
orientation { O1 (Physical object) } O (Qualitative value)
hasBall {P1 (Agent) } V (Boolean)
isMarked {P1 (Agent) } V (Boolean)
markedBy {P1 (Agent), P2 (Agent) } V (Boolean)
callForBall {P1 (Agent) } V (Boolean)
callForSupport {P1 (Agent) } V (Boolean)
partner {P1 (Agent) } V (Boolean)
isInAttack {P1 (Agent) } V (Boolean)
ratio {DO1 (Team) } N (Qualitative value)
lastAction {DO1 (Action) } B (Boolean)
Table 1: Predicates expressing the context of an agent in CoPeFoot. For example, the first predicate expresses a distance between two objects and is formalized by . When , (for a distance, qualitative values of this variable are {close, far, long}).

7 Figure captions

Caption of figure 1

The Principles of CBR.

Caption of figure 2

Case-based reasoning within simulations of interactive dynamic situations.

Caption of figure 3

A user interacting with agents in the CoPeFoot simulator.

Caption of figure 4

Example of XML formalization of a small context in CoPeFoot:

Caption of figure 5

XML formalization of a generic case in CoPeFoot.

. The main difference with the context is that the variables are instanciated (with generic agents for agent variables and with constants for all other variables).

Caption of figure 6

Example of a case base tree.

Caption of figure 7

Number of perceptions stored in linearBase (dotted line) relative to treeBase (continuous line) during acquisition of new cases.

Caption of figure 8

Influence of the parameter on precision and recall (see text for details). When changes from 0 to 1 precision decreases and recall increases.

Caption of figure 9

Precision and recall under time pressure (in milliseconds) for classical and perceptions tree similarities.

8 Figures

Figure 1: The Principles of CBR
Figure 2: Case-based reasoning within simulation of interactive dynamic situations
Figure 3: A user interacting with agents in the CoPeFoot simulator
<ctx>
Ψ<predicate>
Ψ  <name=hasball>
Ψ  <variable name=Y1 type=Agent />
Ψ  <choiceVariable name=Y2 type=Boolean />
Ψ </predicate>
Ψ <predicate>
Ψ  <name> partner </name>
Ψ  <variable name=X1 type=Agent />
Ψ  <choiceVariable name=X2 type=Boolean />
Ψ </predicate>
Ψ <predicate>
Ψ  <name> distance </name>
Ψ  <variable name=Z1 type=PhysicalObject />
Ψ  <variable name=Z2 type=Agent />
Ψ  <choiceVariable name=Z3 type=QualitativeValue value=far />
Ψ </predicate>
</ctx>
Figure 4: Example of XML formalization of a small context in CoPeFoot:
<case id=case1>
Ψ <predicate>
Ψ   <name> hasball </name>
Ψ   <value val="me" type=GenericAgent />
Ψ   <valueChoice val=false type=Boolean />
Ψ   <w11 val=0,3 />
Ψ </predicate>
Ψ <pred>
Ψ  <name> partner </name>
Ψ  <value val=A type=GenericAgent />
Ψ  <valueChoice val=true type=Boolean />
Ψ  <w21 val=0,7 />
Ψ </predicate>
Ψ <predicate>
Ψ Ψ<name> distance </name>
Ψ Ψ<value val=ball type=Ball />
Ψ  <value val=A type=GenericAgent />
Ψ  <valueChoice val=long type=QualitativeValue values={close,far,long} />
Ψ  <w31 val=0,45 />
Ψ </predicate>
</case>
Figure 5: XML formalization of a generic case in CoPeFoot. . The main difference with the context is that the variables are instanciated (with generic agents for agent variables and with constants for all other variables)

.

Figure 6: Example of a case base tree
Figure 7: Number of perceptions stored in linearBase (dotted line) relative to treeBase (continuous line) during acquisition of new cases.
Figure 8: Influence of the parameter on precision and recall (see text for details).When changes from 0 to 1 precision decreases and recall increases.
Figure 9: Precision and recall under time pressure (in milliseconds) for classical and perceptions tree similarities
Figure 10: Precision and recall under the number of authorized tests on perceptions for linear Base and tree Base similarity