Mechanisms for Flexible Representation and Use of ... - CiteSeerX

In Anthony Jameson, Cécile Paris, and Carlo Tasso (Eds.), User Modeling: Proceedings of the Sixth International Conference, UM97. Vienna, New York: Springer Wien New York. © CISM, 1997. Available on−line from http://um.org.

Mechanisms for Flexible Representation and Use of Knowledge in User Modeling Shell Systems Wolfgang Pohl and J¨org H¨ohle? GMD FIT, Human-Computer Interaction Research Department, St. Augustin, Germany

Abstract. In many user modeling systems, assumptions about the user and other user modeling knowledge are represented in a knowledge base and used for individualized behavior of applications. Hence, user modeling shell systems need to support both representation and use of knowledge. Ideally, a shell provides powerful techniques for applications with sophisticated needs but is also flexible enough to be suitable for applications with specialized, less complex requirements. This paper describes two mechanisms that were developed for increasing the flexibility of user modeling shell systems: the AsTRa (Assumption Type Representation) framework for powerful and flexible logic-based representation of user modeling knowledge; and domain-based user modeling, which allows modularization and sharing of user modeling knowledge bases particularly in centralized user modeling scenarios. Both mechanisms have been implemented in the user modeling shell BGP-MS.

1 Introduction For almost ten years, user modeling shell or tool systems have been built in order to support developers of personalized applications. They offer generic implementations of user modeling techniques that can be exploited for the special purposes of an application. Core elements of any user modeling system and hence of any user modeling shell are mechanisms that permit the representation and use of assumptions about the user and of other user modeling knowledge. In addition, the resulting user modeling knowledge bases (short: UMKBs) must be managed and made available to applications. In the user modeling literature, a wide range of methods has been proposed for representing user modeling knowledge and for using it via knowledge base access and reasoning. This diversity implies that no user modeling shell system will be able to satisfy the needs of all adaptive applications. Nevertheless it is a challenge for shell systems to suit as many applications as possible. On principle, this can be achieved by providing powerful mechanisms that support a wide range of user modeling needs. However, for systems within this range that do not make use of the full power provided, unnecessary overhead is caused. So, more advantageous are powerful mechanisms, which are flexible in the sense that they can be tailored to better fit the specific requirements of each application. In this paper, we present mechanisms for flexible knowledge representation and use in user modeling shell systems. First, the AsTRa (Assumption Type Representation) framework for representation and reasoning within UMKBs is introduced. It integrates the partition approach and ? This work was supported by the German Science Foundation (grant no. Ko 1044/4). Parts of it were done

while the authors were at the University of Essen. We thank the anonymous reviewers for their fruitful remarks and Anthony Jameson for his help in preparing the final manuscript.

404

W. Pohl and J. Höhle

the modal logic approach of representing information about assumption types, i.e. different kinds of assumptions about the user and of other user modeling knowledge. Second, a mechanism for managing user modeling knowledge for several applications and user models of several users in a centralized user modeling scenario is presented. Its fundamental notion is the domain of user modeling knowledge, and it permits developers to modularize user modeling knowledge and applications to share assumptions about their users. Both the AsTRa framework and domain-based user modeling have been implemented in the shell system BGP-MS. In the next section, we will show how knowledge is represented and used in user modeling shells that were described in the literature, focusing on representation of assumption types and domains, maintenance of multiple users and applications, and reasoning possibilities and interfaces for knowledge use. In particular, the previous state of development of BGP-MS, as described by Kobsa and Pohl (1995), is summarized and discussed. The AsTRa framework, which is presented in the subsequent section, was developed as a formalization of the partition-based representation and reasoning facilities of BGP-MS in order to give them a formal semantics. Through the corresponding abstraction process, new possibilities for making BGP-MS more flexible were discovered. In Section 4, domain-based user modeling is described. The paper concludes with a summary and perspectives for future work.

2 Representation and Use of Knowledge in User Modeling Shell Systems 2.1 Representation, Reasoning, and Knowledge Base Access User modeling shell systems can be divided roughly into two categories. These are mainly determined by the knowledge representation approach employed, which is closely related to mechanisms for knowledge use. In the first category—which comprises GUMS (Finin, 1989), UMT (Brajnik and Tasso, 1994), and TAGUS (Paiva and Self, 1995)—symbolic, logic-oriented formalisms are offered for representing user modeling knowledge. In GUMS, there is a Prolog-like formalism, which supports default reasoning. In UMT, information about the user is represented as attribute-value pairs. TAGUS offers almost full predicate calculus for expressing assumptions about the user. In GUMS and TAGUS, special predicates can be used to distinguish between assumptions of different types. In examples given by Finin (1989) for GUMS, the predicate “knows” is used to express assumptions about user knowledge. In TAGUS, predicates like “b” and “characteristic” can be employed for assumptions about user beliefs and for (mostly fixed) characteristics of the user, respectively. While special predicates allow distinctions within a representation formalism, UMT and TAGUS make further distinctions beyond the formalism level: In both systems, inference rules are represented separately from genuine user model entries. Hence, these rules are viewed as meta-level knowledge that the user modeling system can use for determining implicit assumptions about the user. In all logic-oriented systems, user modeling knowledge can be used via “tell and ask” command interfaces for adding knowledge and asking queries. “Tell” commands may invoke forward reasoning (UMT), while “ask” commands may invoke backward reasoning (GUMS, TAGUS). All systems deal with the problem of user model dynamics by applying logic-oriented techniques like default reasoning (GUMS) or truth maintenance systems (UMT, TAGUS).

Flexible Representation and Use of Knowledge in User Modeling Shell Systems

405

In contrast to logic-oriented shells, both um (Kay, 1995) and Doppelg¨anger (Orwant, 1995) take the evidence for a user model entry as a central element of user modeling knowledge. Both systems provide quite simple representation formalisms for expressing assumptions about the user. Each assumption, however, is combined with evidence information, i.e., an evidence value and evidence sources. This representation approach is closely related to the way user modeling knowledge is used: Not UMKB contents are the main objects of manipulation, but their associated evidence information. In um, each assumption about the user (including evidence) is represented in an attribute-value structure named “component”. A query to um about the value of a component is answered by resolving possibly conflicting evidence information of the component. Information is added to a um user model by adding evidence information to components. um inference rules are processed in a forward reasoning manner to add further eviden ce information. As in most logic-oriented shells, these rules are viewed as inference rules of the system. In Doppelg¨anger, evidence information (which is split into numeric strength and confidence values) cannot be manipulated directly. Sensors, which may be hardware or software systems, report observations about user behavior to Doppelg¨anger. The system processes this input using statistical and machine learning algorithms to yield assumptions about the user plus strength and confidence values. User model contents can be retrieved using a matching mechanism. In both um and Doppelg¨anger, assumption types are distinguished by mechanisms which, unlike the special predicates of GUMS and TAGUS, are not part of a symbolic representation formalism. In um, each component can be labeled as “preference”, “knowledge”, “belief”, or as “arbitrary” information. In Doppelg¨anger, an orthogonal approach is taken: Information about the user is aggregated into lists like “preferences”, “times” (of user activities), or “biographical data”. These lists are themselves contained in so-called submodels, which partly reflect the applicability domain of user model contents. Example submodels are “news” (assumptions about news reading behavior) and “primary” (basic information about the user that is not likely to change). 2.2 Maintaining Multiple Applications and Users In case of um, UMT, and TAGUS, maintenance of multiple users and/or multiple applications is not possible or not discussed in detail. Finin (1989) describes such maintenance mechanisms for GUMS. GUMS can store the data of multiple applications and, for each application, user models of a number of users. However, GUMS can not handle multiple applications concurrently. Exactly one application instance with one user can communicate with GUMS, which selects the appropriate user model. Doppelg¨anger is the first user modeling server, which can be employed as a central user modeling system in a networked computing scenario. It communicates with a range of sensors for obtaining information about the user and can be accessed by multiple applications via network connections. For every user, one coherent model is maintained, which is shared by all applications. The model is stored permanently in a number of files, with each file storing one submodel. Every application instance can access every submodel, but the interest in thematic submodels like “news” may depend on the kind of application. 2.3 BGP-MS BGP-MS (as described by Kobsa and Pohl, 1995) is a logic-oriented system, but it has its own special way of handling assumption types. Following the partition approach to belief modeling

406

W. Pohl and J. Höhle

(Cohen, 1978, Kobsa, 1985), BGP-MS divides a UMKB into partial knowledge bases, called views, which are represented by partitions that are organized into an inheritance hierarchy. Each view stores assumptions of one specific type about the user; typical view names are SBUB (System Believes User Believes), SBUW (analogous, with W for “wants”), and SBMBUB (MB stands for “mutually believed”). In addition, most applications of BGP-MS make use of the view SB for maintaining system domain knowledge within the user modeling system. Stereotypes are also modeled with partitions: For each stereotype there is one partition, the contents of which are inherited into view SBUB, if the stereotype is applicable to the current user. View contents can be represented using SB-ONE, a KL-ONE-like formalism for terminological knowledge, and first-order predicate calculus (FOPC). So a content of a BGP-MS UMKB is an expression of either SB-ONE or FOPC, which is stored in one partition and hence is part of one or more views. Kobsa (1992) observed that, since SB-ONE expressions can be translated into FOPC, all view contents correspond to FOPC formulas. Hence, all BGP-MS UMKB contents can be expressed as modal logic formulas: A sequence of modal operators indicates a view, and a subsequent FOPC-expression stands for the view content. For example: An SB-ONE ISA-relation between the concepts “laserjet” and “laserprinter” that is contained in SBUB corresponds to the modal formula “2(B;S ) 2(B;U ) x laserjet(x) laserprinter(x)”, where 2(m;a) is a modal operator with modality m and agent a. Modal logic is a powerful representation formalism that exceeds the possibilities of view representation. In particular, negative assumptions about the user—assumptions about what the user does not believe, want, etc.—and system inference rules that refer to several views can be formulated. Therefore, facilities for modal logic representation and reasoning were developed for BGP-MS that also consider view contents (Pohl, 1996). Since all UMKB contents can be expressed as modal formulas, modal logic was chosen as a uniform language for referring to UMKB contents in the “tell and ask” interface of BGP-MS. For a modal expression, BGP-MS decides if it can be represented as view content or not, and whether SB-ONE or FOPC is applicable, thus pursuing a top-down approach to user model representation and use. However, experiences with applications showed that often only parts of the representation facilities of BGP-MS are employed. So, a bottom-up approach, which allows applications to address appropriate mechanisms directly, might give applications more flexible access to and control over representation facilities. Flexibility was also lacking with respect to maintenance of user modeling knowledge bases for applications. On the one hand, BGP-MS is typically used as a separate process and communicates with an application via an inter-process message interface. So technically BGP-MS is not part of an application, which makes it suitable for building centralized user modeling systems. On the other hand, a BGP-MS UMKB is filled with application-specific data and then used by one application only. Information sharing between different applications is not possible. Moreover, multiple users and applications are not supported by BGP-MS.

8

!

3 Flexibility Within Knowledge Bases: Assumption Type Representation This section describes the AsTRa framework. It was originally intended as a formalisation of the representation and reasoning facilities of BGP-MS. However, the abstraction process led to a more flexible approach to representing and using user modeling knowledge which is grounded on logic-based mechanisms.

Flexible Representation and Use of Knowledge in User Modeling Shell Systems

407

3.1 Basic Mechanisms The assumption type is the central notion of the AsTRa framework. An assumption type is a partial knowledge base that is supposed to contain all assumptions of one kind within a UMKB. An entry in an assumption type knowledge base (an assumption content) is represented in one of a set of content formalisms. That is, an AsTRa UMKB contains AsTRa expressions AT :ac; such an expression denotes an assumption content ac, which is expressed in the language F of a content formalism F and is stored in KBAT , the knowledge base of assumption type AT . In the partition approach and in other work on belief modeling (like Taylor et al., 1996), a quite standard way of labeling different kinds of knowledge is used, which we will adopt and extend for general user modeling purposes: An assumption type label is a sequence of agent/modality pairs, a1 m1 : : : an mn . Possible agents ai are S (the system) and U (the user), and standard modalities mi are B (belief) and W (wants/goals). Together with B, the special agent M can be used to express mutual belief. Developers of user modeling systems can define further modalities, e.g. I for “interest”, which can be used with agents S and U. All assumption type labels start with the pair SB. This is to stress that user model contents are system assumptions which are not claimed to hold objectively in the world. Examples for possible assumption types are SB, SBUB, SBUW, SBUPref (if Pref is a defined modality), SBMB, SBMBUW, etc. The AsTRa framework also permits the representation of stereotypes (Rich, 1979). However, stereotypes do not constitute distinct assumption types. If a user is identified as member of a user group, the stereotypical assumptions about this group become part of the system assumptions about the user. Hence they belong to assumption types like SBUB, SBUW, etc., depending on whether they make a statement about potential beliefs, goals or other attitudes of group members. An AsTRa implementation should provide means for dynamically adding and removing stereotype contents to and from the knowledge bases of appropriate assumption types. For knowledge use, the AsTRa framework provides two basic knowledge base access functions, tell and ask, thus satisfying the minimal requirement for knowledge representation formalisms (Russell and Norvig, 1995). Typically, such access functions receive two arguments: a knowledge base K and an expression . In the AsTRa framework, knowledge use additionally depends on the level of reasoning, which becomes a third parameter. Then, a call to tell schematically looks like tell(L; K; ), where L is the reasoning level, K is an AsTRa UMKB, and  is an AsTRa expression. A call to ask is analogous. In the AsTRa framework as described so far, knowledge use must rely on the facilities that are provided by content formalisms. On principle, quite arbitrary formalisms are possible for assumption content representation. However, there is one main requirement: An AsTRa content formalism F must implement four knowledge base access functions:

L

tellF (K; ) adds the F -expression  into the knowledge base K , perhaps after consistency checking. In addition, forward reasoning may add further, implicit knowledge to K . askF (K; ) determines if  logically follows from K or not. storeF (K; ) simply adds  to K . fetchF (K; ) determines if  is explicitly contained in K .

Normally, tellF and askF consider only F -expressions, but AsTRa implementations may provide hybrid reasoning capabilities that use expressions of more than one formalism. With the above functions at hand, we can define two AsTRa reasoning levels. At Level 0, there is no reasoning at all. At Level 1, reasoning takes place within assumption type knowledge

408

W. Pohl and J. Höhle

bases. Formally, tell and ask are defined to handle AsTRa expressions AT :ac by invoking access functions of the applicable content formalism F (ac) on KBAT and ac: – tell(0; UMKB; AT :ac) := storeF (ac) (KBAT ; ac) ask(0; UMKB; AT :ac) := fetchF (ac) (KBAT ; ac) – tell(1; UMKB; AT :ac) := tellF (ac) (KBAT ; ac) ask(1; UMKB; AT :ac) := askF (ac) (KBAT ; ac)

3.2 Extended AsTRa: Adding Modal Logic Representation and Reasoning For BGP-MS, a relationship between user model contents within views and modal logic expressions had been pointed out (see Section 2.3). In the AsTRa framework, this observation is put on a firm foundation. Given that certain conditions hold for content formalisms, a formal equivalence of AsTRa and a restricted modal logic can be proven. On this foundation, the AsTRa framework can naturally be extended with modal logic representation and reasoning mechanisms. Thus, a third level of reasoning becomes available in an extended AsTRa system. A syntactical relationship between AT :ac expressions and modal logic expressions is fairly obvious: An assumption type label AT = a1 m1 : : : an mn corresponds to a sequence of modal operators with modality and agent indices, (AT ) := 2(m1 ;a1 ) : : : 2(mn ;an ) . Then, given that assumption contents can be transferred to FOPC, an AsTRa expression AT :ac corresponds to a modal expression (AT ) ac. The multi-modal multi-agent logic, which exactly comprises such expressions, is called assumption logic (AL). AsTRa requires that all expressions of a content formalism F can be translated to first-order logic. We call such formalisms logic-based if they additionally satisfy a second requirement: Their reasoning behavior must be sound w.r.t. FOPC entailment. Ideally it is also complete, i.e.:

M

M

askF (KBAT ; ac) = true

() KBAT j

=

ac

(1)

AL is a normal modal logic, so that the standard axioms hold for any operator 2(m;a) in AL: 2(m;a)  ^ 2(m;a)( ! ) ! 2(m;a) (modal modus ponens) (2)  ! 2(m;a)  (necessitation rule) (3) AsTRa and AL are semantically equivalent if the following holds (let UMKBAL be the UMKB

`

reformulated as a set of AL formulas, and let AL be the derivability relation of AL): ask(1; UMKB; AT :ac) = true

() UMKBAL `AL M AT (

)

ac

This proposition can be proven if content formalisms satisfy proposition (1). Then, within assumption type knowledge bases modus ponens is applicable and tautologies of FOPC hold. These properties correspond to modal modus ponens (2) and the necessitation rule (3), respectively. Note that these conditions are not always desirable for user modeling; AsTRa implementations may decide to abandon them. Given the syntactic and semantic relationships between AsTRa and the restricted modal logic AL, it is natural to extend AsTRa with representation and reasoning mechanisms for the corresponding unrestricted logic (called AL+ ). In AL+ , both negative assumptions and system inference rules that express relationships between assumption types can be represented. For instance,

Flexible Representation and Use of Knowledge in User Modeling Shell Systems

409

the following formula states that the expression printed on(userdoc,lw plus) is not mutually believed: 2(B;S) 2(B;M ) printed on(userdoc; lw plus) (4)

:

A rule for inferring a belief assumption (SBUB) from a goal assumption (SBUW) is

8doc; p 2 B;S 2 W;U (

)

(

)

printed on(doc; p)

! 2 B;S 2 B;U (

)

(

printable on(doc; p)

)



(5)

General relationships between assumption types may be expressed by modal formula schemes:

2(B;S)2(W;U )  ^ 2(B;S)2(B;U ) ( ! )

?




! 2 B;S 2 W;U (

)

(

)



(6)

( and being formula variables) represents the (system) rule that users want any implication of their immediate goals if they know the implication relation. Since both basic AsTRa expressions and extended UMKB contents can be represented as modal expressions, extended AsTRa representation and reasoning could be completely based on modal logic. However, with modal logic only, the possibility of flexibly using different formalisms for assumption contents and different reasoning levels would be abolished. This is especially disadvantageous if most parts of the UMKB can be represented within assumption types. Therefore, an extended AsTRa implementation keeps assumption types and contents. In addition, it implements modal reasoning functions modal-tell(UMKBAL+ ; ) and modalask(UMKBAL+ ; ), both receiving an AL+ reformulation of the UMKB and an AL+ expression  as arguments. Then, AL+ reasoning can be offered on a separate reasoning level, namely Level 2:

M AT ac M AT ac

– tell(2; UMKB; AT :ac) := modal-tell(UMKBAL+ ; ask(2; UMKB; AT :ac) := modal-ask(UMKBAL+ ;

(

)

)

(

)

)

Thus, full expressive power becomes available, but the flexibility of AsTRa is not sacrificed. In order to make its internal mechanisms transparent to the user model developer, an extended AsTRa implementation may admit AL+ as a uniform interface language for UMKB contents. This requires that simple AL expressions of the form (AT ) ac can be detected and, if desired, can be handled like their corresponding basic AsTRa expressions AT :ac.

M

3.3 BGP-MS Is an AsTRa Implementation Since AsTRa was originally intended to be a formalization of the representation and reasoning mechanisms of BGP-MS, it is not surprising that BGP-MS fits into the framework: 1. Assumption types correspond to views in BGP-MS, which are organized in partition hierarchies with inheritance. Thus, BGP-MS exceeds the AsTRa framework (but does not violate its specification) in allowing inheritance relationships between assumption types. 2. SB-ONE and FOPC are available as content formalisms. They both satisfy the AsTRa conditions: First, they offer access functions tell, ask, store, and fetch, so that AsTRa knowledge base access at levels 0 and 1 can be realized; second, they are logic-based, i.e. their expressions can be translated into FOPC, and reasoning is sound w.r.t. first-order logic. FOPC reasoning is hybrid; i.e., it considers SB-ONE structures within views.

410

W. Pohl and J. Höhle

3.

AL+ representation and reasoning was realized (Pohl, 1996), so that BGP-MS is an extended AsTRa system offering knowledge base access on all three AsTRa reasoning levels.

However, the AsTRa framework is more than just the result of a formalization exercise. On the theoretical side, it provides a semantics in terms of modal logic for the representation and reasoning facilities of BGP-MS. This formal characterization is also a solid ground for modal logic reasoning in BGP-MS. E.g., specific reasoning mechanisms involving negative assumptions are currently being developed, which are derived from the modal logic semantics (cf. Pohl, 1997). On the practical side, the development of AsTRa led to several important changes to BGP-MS. These changes increase the degree of flexibility in BGP-MS significantly: 1. BGP-MS offers a standard set of modalities, B and W. An application developer is allowed to add further modalities to this set, according to application needs. So a wide range of assumption types is possible. 2. Following AsTRa, stereotypical assumptions about one user group may belong to different assumption types: BGP-MS implements stereotypes as sets of partitions. Each stereotype partition is associated with one view. If a stereotype applies to a user, all its partitions are linked to the appropriate view partitions. 3. The inner representation levels of BGP-MS, views and view contents, can be addressed directly. Specific languages SB-ONE and FOPC are available for formulating assumption contents ac in AsTRa expressions AT :ac. So the user model developer can better control how BGP-MS processes user modeling knowledge. However, the developer can still choose to employ modal logic as unique interface format for UMKB contents and let BGP-MS determine appropriate processing mechanisms. 4. BGP-MS offers a choice of three reasoning levels for knowledge base access: no reasoning, reasoning within views, and full modal logic reasoning.

L

L

Figure 1 shows a simple BGP-MS UMKB that could be used for modeling the user with respect to printing documents. The UMKB consists of four assumption types that involve modalities B and I (for “interest”). In addition, there are two stereotypes, NOVICE and EXPERT. EXPERT has only one stereotype partition, which is associated with the view SBUB, while NOVICE has two partitions, which are associated with SBUB and SBUI, respectively. The NOVICE stereotype is active, so that SBUB and SBUI inherit the contents of the NOVICE partitions. Hence, the SBUB view contains an SB-ONE structure corresponding to the SB-ONE expression (isa laserjet laserprinter) by stereotype inheritance and an FOPC formula corresponding to the FOPC expression laserjet(thunder). We present three queries to this UMKB (labelled “printing”) to illustrate AsTRa reasoning (with basic mechanisms only) as implemented in BGP-MS.

L

L

1. ask(0; printing; SBUB:(isa laserjet laserprinter)) returns true, since an ISA relation between the concepts “laserjet” and “laserprinter” is explicitly contained in the view SBUB. 2. ask(0; printing; SBUB:laserprinter(thunder)) returns false, since in SBUB, the FOPC formula “laserprinter(thunder)” is not explicitly contained. 3. ask(1; printing; SBUB:laserprinter(thunder)) returns true, since FOPC reasoning (invoked via askFOPC ) can infer the query expression using FOPC and SB-ONE contents of SBUB.

Flexible Representation and Use of Knowledge in User Modeling Shell Systems

411

NOVICE

EXPERT

laserprinter

laserjet

SBMB

laserjet(thunder)

SB

SBUB

SBUI

Figure 1. A simple UMKB in BGP-MS.

4 Flexibility Beyond Knowledge Bases: Domain-Based User Modeling So far, we have discussed methods for representing knowledge in a UMKB and using it by accessing the UMKB. However, establishing flexible representation and UMKB access facilities is not sufficient for supporting the user modeling process in realistic adaptive applications. In addition, UMKBs (i.e., user models) need to be managed for developers and applications. This section describes a flexible approach to UMKB management in user modeling shell systems. Typically, UMKBs are used during two phases of the user modeling process: development time: User-independent user modeling knowledge is engineered for an application into a UMKB. In BGP-MS, assumption types and possible stereotypes are defined, system knowledge may be entered into assumption type SB, and system inference rules can be defined. Together with other user modeling data like dialog act types or interview definitions (cf. Kobsa and Pohl, 1995), a UMKB is maintained in a so-called environment, which can be saved in a file. run time: A running application communicates with its user modeling system, reporting observations about the user and querying the current user model, which is maintained in a UMKB together with development time knowledge. In the currently distributed version of BGP-MS, an application accesses a development time environment, which is loaded from the file system. Messages from the application lead to user-specific entries into this environment. Hence, there are mainly two kinds of UMKBs. A development time UMKB contains knowledge that is user-independent, but specific to an application A. A run time UMKB, which is accessed by an instance of A with a user U , contains both application data of A and the individual user model of U . In BGP-MS, such (A; U ) UMKBs could be realized by employing user-specific copies of development time environments. These copies would be called (A; U ) environments.

412

W. Pohl and J. Höhle

At run time, an instance of an application A must identify its current user U , so that the corresponding (A; U ) environment can be created or loaded from long-time storage. The idea of employing (A; U ) UMKBs was similarly realized in the shell GUMS (cf. Section 2). Unfortunately, the (A; U ) approach means that each UMKB can be used by one application only, and that assumptions about the user in a UMKB originate from one application only. This is sufficient if a user modeling system is built for a single application. However, it has disadvantages in centralized user modeling scenarios, where a user modeling system serves a number of applications. Such a user modeling server should exploit the fact that information about one user might be contributed to and employed by instances of different applications. Observations of an application Ai about a user Ur could be relevant to the adaptive behavior of application Ak and should therefore be accessible to it. The user modeling server Doppelg a¨ nger (cf. Section 2) supports such information sharing by modularizing UMKBs. For every user, there is one global user model that is divided into submodels. A submodel may be quite specific to an application domain (e.g., “news”) but can also be of general interest (e.g., the “primary” data of a user). All Doppelg¨anger clients can access all submodels, so that assumptions about the user can be shared. In contrast to Doppelg¨anger, BGP-MS represents not only assumptions about the user but also background data like system domain knowledge and stereotypes. So simply dividing user information into submodels is not appropriate. However, a similar idea has been employed for BGP-MS. Taken precisely, it is not application data that is set up at development time, but rather application domain data. Therefore, the (A; U ) environments, which were suggested above as containers for run time UMKBs, should better be regarded as (D; U ) environments that store the assumptions about a user U concerning a domain D together with other domain-specific data. There is no reason to constrain an application Ai to one domain only; user modeling data could be modularized into several domains D1 ; : : : ; Dn . Vice versa, there is no reason to constrain a domain to be used by one application only. Another application Ak could make use of one or more domains from Ai and other applications, in addition to defining its own domains. If a domain Dy is shared by two applications, the corresponding (Dy ; U ) environments will be shared by their instances (cf. Figure 2).

Applications / Domains / UMKBs

:

: Dx

Ai

:

:

Dy

Ak

:

:

Dz :

: (Dx,Ur) : : (Dy,Ur) : : (Dz,Ur) :

Application Instances

Users

: Ai

:

:

Ur

Ak

:

:

Figure 2. Applications, domains, application instances and users.

Flexible Representation and Use of Knowledge in User Modeling Shell Systems

413

For a more illustrative example, imagine two applications “Adaptex” (a text processor) and “IntelliDraw” (a drawing tool), which both employ a centralized BGP-MS instance for user modeling. They make use of the domains “text-processing” and “vector-graphics”, respectively, and share the domain “printing”. Assume further that the user “WP” starts an instance of each of these applications. Using “IntelliDraw”, he is observed to know the concept “PostScript”, which leads to an entry of a corresponding SB-ONE concept into view SBUB in the “(printing,WP)” environment. When “WP” needs assistance in printing a document from “Adaptex”, also the “(printing,WP)” environment is accessed, so that “WP” within “Adaptex” can also be assumed to know the concept “PostScript”. In sum, a new approach to managing user modeling knowledge on the UMKB level has been developed for BGP-MS, namely domain-based user modeling. Its main advantage is that user modeling knowledge needed by one application can be modularized and that this knowledge and the corresponding user model contents can be shared by other applications. In contrast to the approach of Doppelg¨anger, domain-based user modeling supports “knowledge-based user modeling” that makes use of domain-specific background knowledge. Domain-based user modeling was developed and implemented in BGP-MS in order to realize server capabilities. At the same time, the communication interface of BGP-MS was also changed. Previously, BGP-MS could be accessed via a proprietary inter-process communication system from applications running on the same computer. Now BGP-MS offers a message interface based on KQML (Finin et al., 1994), the proposed standard communication language for knowledgebased agents. A KQML implementation is employed that permits communication with BGP-MS across the Internet. Due to domain-based user modeling, BGP-MS employs an extended syntax of KQML: First, some administrative message types (“performatives” in KQML terms) were added that allow registration of application instances and users. Second, additional parameters for domain and user information were introduced in standard performatives like “tell”; these parameters must be used to address the appropriate (D; U ) environment. Currently, the European project AVANTI (Fink et al., 1997) uses BGP-MS in its distributed user modeling servers, which are the core elements of an adaptive World-Wide Web information system.

5 Summary and Future Work In this paper, we presented mechanisms that are designed for employment in user modeling shell systems for (1) flexible representation and use of user modeling knowledge and (2) flexible management of UMKBs. The AsTRa knowledge representation framework was introduced. It basically allows expressions of logic-based formalisms to be maintained within partial knowledge bases that represent one type of assumption about the user (or other user modeling knowledge). These basic mechanisms can be related formally to modal logic and hence be extended with modal representation and reasoning. The AsTRa framework offers a rich and flexible choice of representation and reasoning possibilities. By allowing developers to define inference rules declaratively instead of providing fixed inference procedures, experiments with alternatives are possible. Flexibility is also gained with domain-based user modeling. This approach proposes an organization of user modeling knowledge and hence also of user models according to knowledge domains. An application may use one domain only or modularize its user modeling knowledge into several domains. In centralized user modeling systems that serve more than one application, sharing of domains and user models is possible.

414

W. Pohl and J. Höhle

Both AsTRa and domain-based user modeling have been implemented in the user modeling shell BGP-MS. Consequently, BGP-MS provides more powerful and more flexible features concerning knowledge representation and use than other shell systems (cf. Section 2). However, BGP-MS lags behind other shells with respect to the important aspect of handling the dynamics of user modeling knowledge. Other shell systems either use truth maintenance techniques in combination with logic-based representation or maintain changing evidence information. In principle, both approaches can be imagined as extensions to the core capabilities of the AsTRa framework. Since the framework focuses on logic-based mechanisms, truth maintenance techniques seem to be a natural add-on. But it would also be possible to assign evidence values to AsTRa UMKB contents. As in other evidence-oriented systems, they would originate from acquisition processes (i.e., also from logic-based reasoning), and could be retrieved from the user model. The integration of evidence information into BGP-MS is planned as future work.

References Brajnik, G., and Tasso, C. (1994). A shell for developing non-monotonic user modeling systems. International Journal of Human-Computer Studies 40:31–62. Cohen, P. R. (1978). On knowing what to say: Planning speech acts. Technical Report 118, Department of Computer Science, University of Toronto, Canada. Finin, T., Fritzson, R., McKay, D., and McEntire, R. (1994). KQML as an agent communication language. In Third International Conference on Knowledge and Information Management, 456–463. New York, NY: ACM Press. Finin, T. W. (1989). GUMS: A general user modeling shell. In Kobsa, A., and Wahlster, W., eds., User Models in Dialog Systems. Berlin, Heidelberg: Springer. 411–430. Fink, J., Kobsa, A., and Nill, A. (1997). Adaptable and adaptive information access for all users, including the disabled and the elderly. In this volume. Kay, J. (1995). The um toolkit for reusable, long term user models. User Modeling and User-Adapted Interaction 4(3):149–196. Kobsa, A., and Pohl, W. (1995). The user modeling shell system BGP-MS. User Modeling and UserAdapted Interaction 4(2):59–106. Kobsa, A. (1985). Benutzermodellierung in Dialogsystemen. Berlin, Heidelberg: Springer-Verlag. Kobsa, A. (1992). Towards inferences in BGP-MS: Combining modal logic and partition hierarchies for user modeling. In Proceedings of the Third International Workshop on User Modeling, 35–41. Orwant, J. (1995). Heterogeneous learning in the Doppelg¨anger user modeling system. User Modeling and User-Adapted Interaction 4(2):107–130. Paiva, A., and Self, J. (1995). TAGUS—A user and learner modeling workbench. User Modeling and User-Adapted Interaction 4(3):197–226. Pohl, W. (1996). Combining partitions and modal logic for user modeling. In Gabbay, D. M., and Ohlbach, H. J., eds., Practical Reasoning: Proceedings of the International Conference on Formal and Applied Practical Reasoning, 480–494. Berlin, Heidelberg: Springer. Pohl, W. (1997). Logic-Based Representation and Inference for User Modeling Shell Systems. Ph.D. Dissertation, University of Essen. Forthcoming. Rich, E. (1979). User modeling via stereotypes. Cognitive Science 3:329–354. Russell, S., and Norvig, P. (1995). Artificial Intelligence: A Modern Approach. Upper Saddle River, NJ: Prentice-Hall. Taylor, J. A., Carletta, J., and Mellish, C. (1996). Requirements for belief models in cooperative dialogue. User Modeling and User-Adapted Interaction 6(1):23–68.