Knowledge-based systems

For the academic journal, see Knowledge-Based Systems (journal).

A knowledge-based system (KBS) is a computer program that reasons and uses a knowledge base to solve complex problems. The term is broad and refers to many different kinds of systems. The one common theme that unites all knowledge based systems is an attempt to represent knowledge explicitly and a reasoning system that allows it to derive new knowledge. Thus, a knowledge-based system has two distinguishing features: a knowledge base and an inference engine.

The first part, the knowledge base, contains domain-specific facts and rules^[1] about a problem domain (rather than knowledge implicitly embedded in procedural code, as in a conventional computer program). In addition, the knowledge maybe structured by means of a subsumption ontology, frames, conceptual graph, or logical assertions.^[2]

The second part, the inference engine, uses general-purpose reasoning methods to infer new knowledge and to solve problems in the problem domain. Most commonly, it employs forward chaining or backward chaining. Other approaches include the use of automated theorem proving, logic programming, blackboard systems, and term rewriting systems such as Constraint Handling Rules (CHR). These more formal approaches are covered in detail in the Wikipedia article on knowledge representation and reasoning.

Overview

Knowledge-based systems were first developed by artificial intelligence researchers^{[citation needed]}. These early knowledge-based systems were primarily expert systems – in fact, the term is often used interchangeably with expert systems, although there is a difference. The difference is in the view taken to describe the system^{[citation needed]}:

• "expert system" refers to the type of task the system is trying to assist with – to replace or aid a human expert in a complex task typically viewed as requiring expert knowledge
• "knowledge-based system" refers to the architecture of the system – that it represents knowledge explicitly, rather than as procedural code.

While the earliest knowledge-based systems were almost all expert systems, the same tools and architectures can and have since been used for a whole host of other types of systems. Virtually all expert systems are knowledge-based systems, but many knowledge-based systems are not expert systems.

The first knowledge-based systems were rule based expert systems. One of the most famous was Mycin, a program for medical diagnosis. These early expert systems represented facts about the world as simple assertions in a flat database, and used rules to reason about (and as a result add to) these assertions. Representing knowledge explicitly via rules had several advantages:

1. Acquisition and maintenance. Using rules meant that domain experts could often define and maintain the rules themselves rather than via a programmer.
2. Explanation. Representing knowledge explicitly allowed systems to reason about how they came to a conclusion and use this information to explain results to users. For example, to follow the chain of inferences that led to a diagnosis and use these facts to explain the diagnosis.
3. Reasoning. Decoupling the knowledge from the processing of that knowledge enabled general purpose inference engines to be developed. These systems could develop conclusions that followed from a data set that the initial developers may not have even been aware of.^[3]

Later architectures for knowledge-based reasoning, such as the BB1 blackboard architecture (a blackboard system),^[4] allowed the reasoning process itself to be affected by new inferences, providing meta-level reasoning. BB1 allowed the problem-solving process itself to be monitored. Different kinds of problem-solving (e.g., top-down, bottom-up, and opportunistic problem-solving) could be selectively mixed based on the current state of problem solving. Essentially, the problem-solver was being used both to solve a domain-level problem along with its own control problem, which could depend on the former. Other examples of knowledge-based system architectures supporting meta-level reasoning are MRS^[5] and SOAR.

In addition to expert systems, other applications of knowledge-based systems include real-time process control,^[6] intelligent tutoring systems,^[7] and problem-solvers for specific domains such as protein structure analysis,^[8] construction-site layout,^[9] and computer system fault diagnosis.^[10]

As knowledge-based systems became more complex, the techniques used to represent the knowledge base became more sophisticated and included logic, term-rewriting systems, conceptual graphs, and frames. Consider frames as an example. Rather than representing facts as assertions about data, the knowledge-base has become more structured. Frames can be thought of as representing world knowledge using analogous techniques to object-oriented programming, specifically the use of hierarchies of classes and subclasses, relations between classes, and behavior of objects. As the knowledge base became more structured, reasoning could occur both by independent rules, logical inference, and by interactions within the knowledge base itself. For example, procedures stored as daemons on objects could fire and could replicate the chaining behavior of rules.^[11]

Another advancement was the development of special purpose automated reasoning systems called classifiers. Rather than statically declare the subsumption relations in a knowledge-base, a classifier allows the developer to simply declare facts about the world and let the classifier deduce the relations. In this way a classifier also can play the role of an inference engine.^[12]

The most recent advancement of knowledge-based systems has been to adopt the technologies, especially a kind of logic called description logic, for the development of systems that use the internet. The internet often has to deal with complex, unstructured data that cannot be relied on to fit a specific data model. The technology of knowledge-based systems, and especially the ability to classify objects on demand, is ideal for such systems. The model for these kinds of knowledge-based Internet systems is known as the Semantic Web.^[13]

See also

• Knowledge representation and reasoning
• Knowledge base
• Knowledge modeling
• Knowledge engine
• Inference engine
• Information retrieval
• Reasoning system
• Case-based reasoning
• Expert system
• Conceptual graph
• Semantic web
• Neural networks
• Rule-based system

References

1. Smith, Reid (May 8, 1985). "Knowledge-Based Systems Concepts, Techniques, Examples" (PDF). reidgsmith.com. Schlumberger-Doll Research. Retrieved 9 November 2013.
2. Sowa, John F. (2000). Knowledge Representation: Logical, Philosophical, and Computational Foundations (1st ed.). Pacific Grove: Brooks / Cole. ISBN 978-0-534-94965-5.
3. Hayes-Roth, Frederick; Donald Waterman; Douglas Lenat (1983). Building Expert Systems. Addison-Wesley. ISBN 0-201-10686-8.
4. Hayes-Roth, Barbara; Department, Stanford University Computer Science (1984). BB1: an Architecture for Blackboard Systems that Control, Explain, and Learn about Their Own Behavior. Department of Computer Science, Stanford University.
5. Genesereth, Michael R. "1983 - An Overview of Meta-Level Architecture": 6. {{cite journal}}: Cite journal requires |journal= (help)
6. Larsson, Jan Eric; Hayes-Roth, Barbara (1998). "Guardian: An Intelligent Autonomous Agent for Medical Monitoring and Diagnosis". IEEE Intelligent Systems. 13 (1). Retrieved 2012-08-11.
7. Clancey, William (1987). Knowledge-Based Tutoring: The GUIDON Program. Cambridge, Massachusetts: The MIT Press.
8. Hayes-Roth, Barbara; Buchanan, Bruce G.; Lichtarge, Olivier; Hewitt, Mike; Altman, Russ B.; Brinkley, James F.; Cornelius, Craig; Duncan, Bruce S.; Jardetzky, Oleg (1986). PROTEAN: Deriving Protein Structure from Constraints. AAAI. pp. 904–909. Retrieved 2012-08-11.
9. Engelmore, Robert; et al; (eds ) (1988). Blackboard Systems. Addison-Wesley Pub (Sd). {{cite book}}: |first= has generic name (help)CS1 maint: multiple names: authors list (link)
10. Bennett, James S. (1981). DART: An Expert System for Computer Fault Diagnosis. IJCAI.
11. Mettrey, William (1987). . AI Magazine. 8 (4). Archived from the original on 2013-11-10. Retrieved 2013-11-10.
12. MacGregor, Robert (June 1991). "Using a description classifier to enhance knowledge representation". IEEE Expert. 6 (3): 41–46. doi:10.1109/64.87683. S2CID 29575443.
13. Berners-Lee, Tim; James Hendler; Ora Lassila (May 17, 2001). . Scientific American. 284: 34–43. doi:10.1038/scientificamerican0501-34. Archived from the original on April 24, 2013.

Further reading

• Rajendra, Akerkar; Sajja, Priti (2009). Knowledge-Based Systems. Jones & Bartlett Learning. ISBN 9780763776473.