Software Design Retrieval using Bayesian Networks and WordNet Paulo Gomes CISUC - Centro de Inform´ atica e Sistemas da Universidade de Coimbra, Departamento de Engenharia Inform´ atica, Universidade de Coimbra, 3030 Coimbra, Portugal
[email protected]
Abstract. The complexity of software systems makes design reuse a necessary task in the software development process. CASE tools can provide cognitive assistance in this task, helping the software engineers to select designs to be reused. In this paper, we propose an approach for case indexing and retrieval based on Bayesian Networks, Case-Based Reasoning and WordNet. This approach is integrated in a CASE tool that reuses UML class diagrams, providing cognitive help for the software design phase.
1
Motivations
Software design [1] is a complex task involving the modelization of software systems representing the world around us. Despite the design guidelines described in software engineering methodologies, designers still rely on experience to build the system model. The experience level often distinguishes good designers from average ones. A possible solution to overcome the lack of experience is to reuse software [2, 3]. Reuse enables more efficient development of software systems, because the development costs and the number of software errors decrease. But, due to the abstract level of software design, reuse of designs is not a simple task. In our work, we are interested in developing CASE (Computer Aided Software Engineering) tools capable of assisting the software designer in the reuse of designs. Common CASE tools do not provide help in this field, they are just complex diagram editors, some with syntax verification functionalities. Our goal is to go a step further and to enable the CASE tools to provide semantic and structural retrieval functionalities. One mechanism that has provided good results in case indexing and retrieval is Bayesian Networks (BNs, [4]). BNs can provide an efficient retrieval mechanism based on probabilistic knowledge. One of our goals is to integrate this reasoning mechanism in a CASE tool, in order to provide retrieval functionalities for the software designer. An interesting challenge that we encountered was how to consider structural and semantic similarity in the BN. We have developed an approach that deals with both similarity aspects.
2
Our Approach
Case-Based Reasoning (CBR) [5, 6] is an Artificial Intelligence [7] field, based on reuse of experience. The reasoning framework is based on the storage of experience episodes in the form of cases. Each case represents a specific situation or entity, and is stored in a case library ready for reuse in new situations. Cases can be retrieved from the case library through a query defined by the designer. This query describes the current situation which needs to be solved or completed. The retrieval output is a list of cases ranked by similarity to the query. A CBR system can go further and adapt one or more retrieved cases to generate a new solution for the query. This new solution can then be stored in the library as a new case closing the reasoning cycle [8] and enabling the CBR system to learn and evolve in time. In our previous work, we have developed REBUILDER [9, 10], a CASE tool based on CBR and WordNet [11]. In REBUILDER, cases are UML class diagrams and they are stored in a central repository, making them available for reuse within the development team or company. This tool also provides several cognitive functionalities for aiding the software design task. One important functionality of REBUILDER is the capacity of understanding natural language. This capability is possible due to WordNet, which is used as an ontology, enabling the association of senses to words and other natural language processing tasks. As seen before, CBR and WordNet are central issues in our system, constraining the integration of BNs in REBUILDER. In this paper, we present this integration and how issues such as semantic and structural similarity of class diagrams are addressed. The next session provides some background knowledge about BNs and WordNet. Section 4 describes REBUILDER architecture briefly. Section 5 describes our approach to retrieval using BNs within REBUILDER. Section 6 compares our approach with several research works on CBR and BNs. Finally section 7 concludes this paper with some final remarks and future work.
3
Background Knowledge
This section presents some background knowledge about Bayesian networks and WordNet, so that our approach becomes clearer to the reader. 3.1
Bayesian Networks
A Bayesian Network[4] is an acyclic directed graph that represents dependencies between variables and their associated probabilities. It can be used for diagnostic tasks, causal inferences, explanation inferences or mixed inferences. Nodes represent variables and directed links represent influences between variables. The semantics of a link can be described in the following way: there is a link from X to Y, if X has a direct influence on Y. Each node has a conditional probability
table (CPT) associated that quantifies the effects that the parents have on the node. An example of a simple Bayesian network (BN) is given in figure 1 (tables represent CPT for nodes). In this example, there is a burglar alarm that can be fired by a burglar or by mistake due to an earthquake. The probability of happening a burglary (P(B)) is 0.001, and the probability of happening an earthquake (P(E)) is 0.002. The probability of the alarm going off depends on the nodes Burglary and Earthquake, which is depicted in the table near the alarm node. Supposing that there are two persons that can call when the alarm goes off, John and Mary, the probability of any of them calling because the alarm went off is also represented in the tables for nodes John Calls and Mary Calls.
P(B)
Burglary
Earthquake
P(E)
0.001
0.002 Alarm
B
E
P(B)
True True False False
True False True False
0.95 0.94 0.29 0.001
John Calls A
P(J)
True False
0.90 0.05
Mary Calls A
P(M)
True False
0.70 0.01
Fig. 1. An example of a Bayesian network taken from [7].
Inference in a BN is the computation of the posterior probability distribution for the set of query variables. Given a set of evidence variables for which the exact value is known, an inference algorithm is used to propagate these values through the BN, according to Bayes rule. There are several inference algorithms, but basically they fall in two categories: exact inference and approximate inference. Exact inference algorithms perform the exact computation of the probability distributions. Belief propagation in trees is linear, while belief propagation in multiply connected graphs has been shown to be NP-hard [12]. Approximate inference algorithms try to deal with this difficulty in a more tractable way, trying to provide an approximation to the probability distribution for query variables. 3.2
WordNet
WordNet [11] is used in REBUILDER as a common sense ontology. It uses a differential theory where concept meanings are represented by symbols that enable a theorist to distinguish among them. Symbols are words, and concept meanings are called synsets. A synset is a concept represented by one or more
words. Words that can be used to represent a synset are called synonyms. A word with more than one meaning is called a polysemous word. For instance, the word mouse has two meanings, it can denote a rat, or it can express a computer mouse. WordNet is built around the concept of synset. Basically a synset comprises a list of words and a list of semantic relations between other synsets. The first part is a list of words, each one with a list of synsets that the word represents. The second part, is a set of semantic relations between synsets, like is-a relations, part-of relations, and other relations. REBUILDER uses the word synset list and four semantic relations: is-a, part-of, substance-of, and member-of. Synsets are classified in four different types: nouns, verbs, adjectives, and adverbs. Synsets are used in REBUILDER for categorization of software objects. Each object has a context synset which represents the object meaning. In order to find the correct synset, REBUILDER uses the object name, and the names of the objects related with it, which define the object context. The object’s context synset can then be used for computing object similarity (using the WordNet semantic relations), or it can be used as a case index, allowing rapid access to objects with the same classification. WordNet is used to compute the semantic distance between two context synsets. This distance is the length of the shortest path between the two synsets. Any of the four relation types can be used to establish the path between the synsets. This distance is used in REBUILDER to assess the type similarity between objects, and to select the correct synset when the object name has more than one synset. This process is called name disambiguation [13] and is a crucial task in REBUILDER. If a diagram object has a name with several synsets, then more information about this object has to be used to find which synset is the correct one. The extra information are the diagram objects that directly or indirectly are associated with it. In case of the object being a class, its attributes can also be used in the disambiguation process. This process is used when a case is inserted in the case library or when the designer calls the retrieval module.
4
REBUILDER
REBUILDER creates and manages a repository of software designs, providing the software designer with a set of functionalities that promote the reuse of previous design experiences. This section gives an overview on REBUILDER describing it’s architecture and modules. Figure 2 illustrates the architecture of REBUILDER. It comprises four main modules: the UML editor, the knowledge base manager, the knowledge base (KB), and the CBR engine. It also depicts the two different user types: software designers and KB administrators. Software designers use REBUILDER as a CASE tool and subsequently reuse the software design knowledge previously stored. The KB administrator keeps the KB updated and consistent. The UML editor serves as the intermediary between REBUILDER and the software designer while the KB manager is the interface between the KB administrator and the system (see [9] for a more detailed description of REBUILDER).
Manager Client CBR Engine
Designer Client
Knowledge Base WordNet Server
UML Editor
WordNet
Case Indexes
File Server Design Cases
CBR Engine
UML Editor
Data Type Taxonomy
KB Manager Module
KB Administrator
Software Designers
Fig. 2. REBUILDER’s Architecture.
The CBR engine performs all the inference work in REBUILDER. It comprises six sub modules: retrieval, analogy, composition, design patterns, verification, and learning. The retrieval module searches the case library for designs or design objects similar to the query. The most similar ones are presented to the user, allowing the designer to reuse these designs or part of them. The analogy module maps designs from the case library, to the query design. The resulting mapping establishes the knowledge transfer from the old design to the query design. The composition module can be used to adapt a past design (or part of it) to the query using design composition. The design patterns module uses a CBR approach to the application of software design patterns [14]. This module is able to generate new diagrams through the automatic application of design patterns. The verification module checks the current design for inconsistencies. The learning module acquires new knowledge from the user interaction, or from the system reasoning. Figure 3 describes how a new UML diagram can be generated in REBUILDER. Note that adaptation stands for analogy, composition or design patterns. These are adaptation strategies, and can be used to generate a new UML diagram using one or more cases.
New Problem
RETRIEVE
Retrieved Cases
ADAPT
New UML Diagram
VERIFY
Revised UML Diagram
Fig. 3. REBUILDER solution generation cycle.
5
Retrieval Using Bayesian Networks and WordNet
This section presents our approach to the retrieval of software designs using BNs and WordNet. We start by describing how the BNs are built and then we explain the retrieval process.
5.1
Building the Bayesian Network
REBUILDER uses BNs to index cases, to retrieve cases and to rank cases. The network construction is possible using WordNet synsets and is-a arcs. Network nodes represent three types of entities: cases, synsets and relations. For each case in the library a node is created, with the synsets associated to the case objects as parent nodes. All the parents of each synset are recursively added to the network, until the top nodes are reached, using the is-a arcs of WordNet. Relations in the library cases are also represented as nodes in the network, with a node for each relation. The synsets involved in the relation are parent nodes of the relation node, and the case node having this relation is a child of the relation node. As an example, consider cases Case1 and Case2 in figures 4 and 5 (attributes and methods are not considered for the sake of simplicity). Figure 6 represents the BN built from these two cases. Each case is represented by a node with the respective objects added, for instance Case1 related with Student, School and Teacher. Then each of the synsets associated with a case adds it’s parents recursively to the network until it reaches a top synset, synset Student parents go from Enrollee to Entity. The relation nodes are also represented, for example the relation Student-School has Student and School as parents and Case1 as a child.
Student
School
Teacher
1..*
1..*
Fig. 4. Case1 diagram.
Student
1..*
1..*
School
Course
1..*
Fig. 5. Case2 diagram.
Conditional probability tables for each node are defined accordingly to each node type. The node types are: top nodes, synset nodes with only one parent, synset nodes with several parents, case nodes and relation nodes.
Entity
Group
Act
Object Social Group Living Thing Activity Being
Organization
Human Institution Enrollee
Education
Adult
Professional
Educational Institution
Educator Course
School
Teacher
Student
StudentCourse
SchoolTeacher
SchoolCourse
StudentSchool
Case1
Case2
Fig. 6. The Bayesian Network resulting from cases Case1 and Case2.
Top nodes correspond to WordNet top nodes, and their probability is given by: P (T opN ode) =
1 T opN odes(BN )
(1)
where T opN odes(BN ) returns the number of top nodes in the BN. The CPT of synset nodes with only one parent, which corresponds to the majority of synsets, are computed using table 1. Parent P(Synset) P(¬Synset) True α 1−α False 0 1 Table 1. The CPT for a single parent synset node.
Where α is given by: α=
1 Children(P arent)
(2)
and Children(P arent) returns the number of children for node P arent. In the computation of the CPT for nodes with more than one parent, we consider that each cause has an independent chance of causing the effect according to the noisy-OR model [15]. In the case of synset nodes, the probability for a synset S is given by: P (S|P arents(S)) = 1 − P (¬S|P arents(S)) Y (1 − P (S|pi )) P (¬S|P arents(S)) =
(3) (4)
(pi ∈P arents(S))∧(pi =T rue)
where P arents(S) represents the parent nodes of S and pi one of these nodes. P (S|pi ) is given by: 1 P (S|pi ) = (5) Children(pi ) where Children(pi ) returns the number of children nodes of pi . The computation of the CPT for a case node C is given using: P (C|P arents(C)) = 1 − P (¬C|P arents(C)) Y P (¬C|P arents(C)) = (1 − P (C|pi ))
(6) (7)
(pi ∈P arents(C))∧(pi =T rue)
where P arents(C) represents the parent nodes of C and pi one of these nodes. Node pi can be a synset or a relation node, and P (C|pi ) is given by: P (C|pi ) =
1 Occurrences(pi )
(8)
where Occurrences(pi ) returns the number of occurrences of pi in library cases. Relation nodes have exactly two parent nodes, the synsets participating in the relation. Considering a relation node R having two parents S1 and S2 , the CPT for R is defined in table 2. S1 False False True True
S2 P(R) P(¬R) False 0 1 True 0 1 False 0 1 True P (R|S1 , S2 ) 1 − P (R|S1 , S2 )
Table 2. The CPT for a relation node.
The probability P (R|S1 , S2 ) is given by: P (R|S1 , S2 ) =
Relations(S1 , S2 ) Relations(S1 ) + Relations(S2 )
(9)
where Relations(S1 , S2 ) returns the number of relations in the case library with both S1 and S2 , and Relations(S1 ) returns the number of relations in the library with S1 . Using the BN example of figure 6, the CPT for node Entity is 0.33, since there are three top nodes in the network. As an example of a CPT for a synset node, table 3 shows the CPT for node Adult, notice that α is 0.5 since there are two children nodes for Human. Human P (Adult) P (¬Adult) True 0.5 0.5 False 0 1 Table 3. The CPT for the Adult node.
The CPT for node Case1 is computed based on the conditional probabilities for each of the node’s parents, which are given by: 1 = 0.5 2 1 P (Case1|School = T rue) = = 0.5 2 1 P (Case1|T eacher = T rue) = = 1 1 1 P (Case1|StudentSchool = T rue) = = 0.5 2 1 P (Case1|SchoolT eacher = T rue) = = 1 1 P (Case1|Student = T rue) =
Just to illustrate the computation of the CPT, the probability of the node Case1 having Student and School as true is: P (¬Case1|Student = T rue, School = T rue) = (1 − 0.5) · (1 − 0.5) = 0.25 P (Case1|Student = T rue, School = T rue) = 1 − 0.25 = 0.75 P (¬Case1|Student = T rue, School = T rue, StudentSchool = T rue) = (1 − 0.5) · (1 − 0.5) · (1 − 0.5) = 0.125 P (Case1|Student = T rue, School = T rue, StudentSchool = T rue) = 1 − 0.125 = 0.875
Table 4 presents the CPT for relation node StudentSchool. Notice that the P (StudentSchool|Student = T rue, School = T rue) is: P (StudentSchool|Student = T rue, School = T rue) =
Student False False True True
2 = 0.29 3+4
School P (StudentSchool) P (¬StudentSchool) False 0 1 True 0 1 False 0 1 True 0.29 0.71
Table 4. The CPT for the StudentSchool node.
If a new case is added to the case library, the BN must be rebuilt, adding all the cases and updating the CPTs. 5.2
Retrieval Process
The retrieval process starts with a query, which is a class diagram (query diagram). Then the BN nodes corresponding to the synsets of the query diagram objects, are set to true. The same happens with the nodes corresponding to query diagram relations. If there isn’t a corresponding node in the network for an object or relation, then a node representing the missing object/relation is added to the BN, along with edges and parent nodes. After the evidence nodes are set to true, the goal of the retrieval process is to assess the probability of the case nodes. These probabilities are used to retrieve and to rank the corresponding cases. In REBUILDER, we use the Bayesian Network tools in Java (BNJ1 ), which is an open-source implementation of BNs inference algorithms for research and development. This package provides several reasoning algorithms, both for exact inference and for approximate inference. These algorithms are used for assessing the case node’s probabilities. 1
http://bndev.sourceforge.net/
Using the example from the previous subsections, suppose that the user query comprises the software objects School and Teacher, and a relation between the two objects. Using the clustering algorithm developed by Lauritzen and Spiegelhalter [16], the probability for Case1 is 1, and for Case2 is 0.503289. This makes sense, since Case1 comprises the query, and Case2 only comprises the object School. These probability values are used for ranking retrieved cases. Other examples of queries and the respective node probabilities (for Case1 and Case2 ) are presented in table 5. Query Probability for Case1 Probability for Case2 Student, School, Student-School 0.875 0.875107 Student, School 0.78625 0.786433 School, Course, School-Course 0.5 1 School, Teacher, School-Teacher 1 0.503289 Course, Teacher 1 1 Course, Teacher, School 1 1 Educator, Course 0.0448002 1 Human, Institution 0.0159545 0.0167973 Table 5. Table with the probabilities associated with case nodes for several retrieval examples (queries comprise objects and relations between objects).
6
Related Work
There are several research works combining CBR and BNs, with different purposes and ways of integration. This section compares these works to our approach, focusing in the relevant differences and similarities. Aamodt and Langseth [17] describe an approach for integration of BNs with CBR. The BN is used for indexing cases using binary features, with this network built from a semantic network. Retrieval is a two step process: first the BN is used for retrieving a relevant set of cases and then the BN is used for selecting what observable nodes (evidence nodes) are best for discriminating between plausible cases. This approach implies that nodes are classified as observable or not, which in our approach would correspond to any synset or relation node. Despite the similarities with our approach in the network construction, the retrieval process is rather different, with our approach having only one pass, yielding a ranked set of cases. Another approach to the integration of CBR and BNs is presented by Rodr´ıguez et. al. [18], in which two BNs are used: one for indexing and another for retrieval. They also use cases for building both networks, updating them each time a new case is added to the case library. The indexing network ranks the order in which categories can be searched for similar exemplars. Then
each category, in the retrieval network, is searched to find cases that are similar to the target case. As in our approach, similarity is interpreted as the probability associated with a case. Both the network structure and retrieval process are different from our approach, having the limitation of depending on an initial case base to reason. The approach presented by Dingsoyr [19] uses a BN for computing similarity metrics. This approach uses the case base to build a BN, which will then be used for assessing the similarity between the query and the cases. As in other described approaches, this approach has the limitation of depending of an initial case base. There is an important difference with our approach, the level of abstraction in the representation is shallow, since it only uses the case features for indexing, while the BNs in REBUILDER allow deeper inferences using is-a arcs. Tirri et. al. [20] present a Bayesian framework for CBR in data-intensive domains. In their approach, cases are used to provide the approximate model for the underlying joint probability distribution of attributes, allowing two major operations: retrieval and adaptation. Comparing with our approach, we only use the BN for indexing and retrieval, though adaptation based on the BN is possible, but is a future issue in our approach. One limitation of their approach is the need of a good representative initial case base that can be used to generate the BN. This can be a problem in some application domains, due to the lack of experience in the form of cases. Lazkano and Sierra [21] describe an approach that combines Nearest Neighbour algorithm with a BN for case classification. The main idea of this work can be presented in two steps: given a query case, first retrieve the most similar case using the Nearest Neighbour algorithm; and then use a BN to identify the case’s classification. This approach has a different purpose from our’s combining CBR and BNs in a different way. Aha and Chang [22] describe an approach for multiagent planning using BNs and CBR. BNs are used to provide contextual information to the case-based reasoner, assisting in the feature selection. Then the case-based reasoner is used to determine how to implement the agent’s actions. Their approach is rather different from ours, with one BN for each possible agent action. The agent will select the action corresponding to the BN with highest probability. As in our approach, an agent learns new knowledge in the form of BN update when new experience is acquired. Breese and Heckerman [23] present an approach for diagnostic and troubleshooting applications using BNs and CBR. In a diagnosis session, a subnetwork is extracted from a BN database describing a large number of diagnostic interactions and cases. This network is used to make suggestions of possible repairs and additional observations. The network structure comprises three layers representing: causes, issues and symptoms. Though this approach has some similarities with our approach, the reasoning model and main goal is different from our approach. Schiaffino and Amandi [24] present an approach for learning user profiles using CBR and BNs. As in our approach, cases are used for the network construc-
tion. User profiles have two parts: one built from CBR using the classification of queries by similarity and the other part by using the BN to infer attribute values. In the end of this parallel reasoning process, a set of suggested queries is shown to the user. This is another way of integration of CBR and BNs, in which cases constitute the probabilistic model used for network construction. In our approach, we also use cases as part of the probabilistic model, but the retrieval process is different. Wiebe et. al. [25] presented an approach for the construction of BNs using WordNet for word-sense disambiguation. Their use of WordNet for network construction is similar to our approach, presenting two alternative ways of mapping nodes. One where a node represents a synset and another where a node represents a word. In our approach, we use the first alternative with the difference that we also have two other types of nodes, representing cases and diagram relations. As in our approach, they also use the WordNet is-a arcs to build the network. Besides the difference of using the BN for word-sense disambiguation, in our approach the CPTs are defined in a different way, they are built from data in cases and in Wiebe’s approach they are built from tagged training data. There are several research works that explore case retrieval and similarity mechanisms for software design. Gonzlez et. al. [26] presented a CBR approach to software reuse and design at the code level. The work developed is based on the reuse and design of object-oriented code. Using the object description they use two retrieval algorithms, a lexical retrieval using a natural language query, and a conceptual retrieval using an entity and slot similarity measures. Dj vu [27] is a CBR system for code reuse and generation using hierarchical CBR. Like the case representation of Gonzlez, Dj Vu uses a hierarchical case representation, indexing cases using functional features. Althoff and Tautz [28] have a different approach to software reuse and design. Instead of reusing code, they reuse system requirements and associated software development knowledge.
7
Conclusions and Future Work
This paper presents an approach to the retrieval of class diagrams integrating BN, CBR and WordNet. We describe how the BN is built from WordNet and from the case library, and a detailed example of network retrieval is given. One advantage of our approach, is the capability of assessing not only the similarity between diagram objects, but also the structure similarity of diagrams, through the use of network nodes representing diagram relations. This enables the BN to compute structural similarity, which is important for assessing diagram similarity. Another advantage is the leaning of new cases through the network updating. In relation, to other systems using BN for retrieval, our approach has the advantage of not depending entirely on cases for building the BN. An initial BN can be built using only WordNet and the query, which will then be updated with new cases. One of the limitations of our approach is the updating algorithm (used to rebuild the BNs when a new case is added to the case base), which implies the
rebuilding of the entire BN. Although the network construction is fast, it is not the most efficient. We are looking into ways of making it more efficient. Synset CPTs are only defined based on the WordNet structure. This is not the most accurate way to compute the associated probabilities, because a synset may depend in different degrees from their parents. One way to deal with this issue is to use text corpus to compute the CPTs, as in Wiebe’s approach. There are several issues that we intend to address, namely the representation of attributes and methods in the BN. This is not an easy issue, because the network complexity will affect the retrieval performance. Other future issues are related with the integration of user preferences in the BN, so that retrieval would take into account user preferences. This topic follows the development guidelines of REBUILDER, trying to adapt the system to the user and not the opposite.
References 1. Boehm, B.: A Spiral Model of Software Development and Enhancement. IEEE Press (1988) 2. Prieto-Diaz, R., Jones, G.: Breathing new life into old software. In Tracz, W., ed.: Software Reuse: Emerging Technology, Washigton, USA, Computer Society Press (1988) 3. Coulange, B.: Software Reuse. Springer Verlag, London (1997) 4. Pearl, J.: Probabilistic Reasoning in Intelligent Systems. Morgan-Kaufman (1988) 5. Kolodner, J.: Case-Based Reasoning. Morgan Kaufman (1993) 6. Maher, M.L., Balachandran, M., Zhang, D.: Case-Based Reasoning in Design. Lawrence Erlbaum Associates (1995) 7. Russel, S., Norvig, P.: Artificial Intelligence: A Modern Approach. Prentice Hall, New Jersey (1995) 8. Aamodt, A., Plaza, E.: Case–based reasoning: Foundational issues, methodological variations, and system approaches. AI Communications 7 (1994) 39–59 9. Gomes, P., Pereira, F.C., Paiva, P., Seco, N., Carreiro, P., Ferreira, J.L., Bento, C.: Case retrieval of software designs using wordnet. In Harmelen, F.v., ed.: European Conference on Artificial Intelligence (ECAI’02), Lyon, France, IOS Press, Amsterdam (2002) 10. Gomes, P., Pereira, F.C., Paiva, P., Seco, N., Carreiro, P., Ferreira, J.L., Bento, C.: Solution verification in software design: A CBR approach. In Bridge, D., Ashley, K., eds.: Fifth International Conference on Case-Based Reasoning (ICCBR’03), Trondheim, Norway, Springer (2003) 11. Miller, G., Beckwith, R., Fellbaum, C., Gross, D., Miller, K.J.: Introduction to wordnet: an on-line lexical database. International Journal of Lexicography 3 (1990) 235 – 244 12. Cooper, G.F.: The computational complexity of probabilistic inference using Bayesian belief networks. Artificial Intelligence 42 (1990) 393–405 13. Ide, N., Veronis, J.: Introduction to the special issue on word sense disambiguation: The state of the art. Computational Linguistics 24 (1998) 1–40 14. Gamma, E., Helm, R., Johnson, R., Vlissides, J.: Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley, Reading (1995) 15. D´ıez, F.J.: Parameter adjustment in bayes networks. the generalized noisy ORgate. In Heckerman, D., Mamdani, A., eds.: Proceedings of the 9th Conference
16.
17. 18.
19. 20.
21.
22.
23. 24.
25.
26.
27.
28.
on Uncertainty in Artificial Intelligence, San Mateo, CA, USA, Morgan Kaufmann Publishers (1993) 99–105 Lauritzen, S.L., Spiegelhalter, D.J.: Local computations with probabilities on graphical structures and their applications to expert systems. The Journal of the Royal Statistical Society 50 (1988) 157–224 Aamodt, A., Langseth, H.: Integrating bayesian networks into knowledge-intensive cbr. In: AAAI Workshop on Case-Based Reasoning Integrations. (1998) Rodr´ıguez, A.F., Vadera, S., Sucar, L.E.: A probabilistic model for case-based reasoning. In Leake, D.B., Plaza, E., eds.: Proceedings of the 2nd International Conference on Case-Based Reasoning (ICCBR-97). Volume 1266 of LNAI., Berlin, Springer (1997) 623–632 Dingsoyr, T.: Retrieval of cases by using a bayesian network. In: AAAI Workshop on Case-Based Reasoning Integrations. (1998) Tirri, H., Kontkanen, P., Myllym¨ aki, P.: A bayesian framework for case-based reasoning. In Smith, I., Faltings, B., eds.: Proceedings of the Third European Workshop on Case-Based Reasoning. Volume 1168 of LNAI., Berlin, Springer (1996) 413–427 Lazkano, E., Sierra, B.: BAYES–NEAREST: A new hybrid classifier combining bayesian network and distance based algorithms. In: Progress in Artificial Intelligence (EPIA–03). Volume 2902 of LNCS., Berlin, Springer (2003) 171–183 Aha, D., Chang, L.: Cooperative bayesian and case-based reasoning for solving multiagent planning tasks. Technical Report AIC-96-005, Navy Center for Applied Research in Artificial Intelligence (1996) Breese, J., Heckerman, D.: Decision-theoretic case-based reasoning. Technical Report MSR-TR-95-03, Microsoft Research (1995) Schiaffino, S., Amandi, A.: User profiling with case-based reasoning and bayesian networks. In: Open Discussion Track - International Joint Conference IBERAMIA– SBIA 2000. (2000) 12–21 Wiebe, J., O’Hara, T., Bruce, R.: Constructing Bayesian networks from WordNet for word-sense disambiguation: Representational and processing issues. In Harabagiu, S., ed.: Use of WordNet in Natural Language Processing Systems: Proceedings of the Conference, Somerset, New Jersey, Association for Computational Linguistics (1998) 23–30 Gonz´ alez, P.A., Fern´ andez, C.: A knowledge-based approach to support software reuse in object-oriented libraries. In: 9th International Conference on Software Engineering and Knowledge Engineering, SEKE’97, Madrid, Spain, Knowledge Systems Institute, Illinois (1997) 520–527 Smyth, B., Cunningham, P.: Deja vu: A hierarchical case-based reasoning system for software design. In Neumann, B., ed.: 10th European Conference on Artificial Intelligence (ECAI’92), Vienna, Austria, John Wiley and Sons (1992) Tautz, C., Althoff, K.D.: Using case-based reasoning for reusing software knowledge. In Leake, D., Plaza, E., eds.: International Conference on Case-Based Reasoning (ICCBR’97), Providence, RI, USA, Springer-Verlag (1997) 156–165
