Artificial Intelligence Building Knowledge Base Chapter 8.

Slides:



Advertisements
Similar presentations
Knowledge Representation using First-Order Logic
Advertisements

First-Order Logic Chapter 8.
Predicate Logic Second Term Fourth Year (10 CS) 1.
Logic Gates.
CS344: Introduction to Artificial Intelligence Pushpak Bhattacharyya CSE Dept., IIT Bombay Lecture 10– Club and Circuit Examples.
Knowledge Representation using First-Order Logic
CSE-221 Digital Logic Design (DLD)
© Franz Kurfess Knowledge-Based Systems CSC 480: Artificial Intelligence Dr. Franz J. Kurfess Computer Science Department Cal Poly.
Chapter 4 Gates and Circuits.
Represent the following sentences in first-order logic, using a consistent vocabulary
Knowledge Representation using First-Order Logic (Part III) This lecture: R&N Chapters 8, 9 Next lecture: Chapter 13; Chapter (Please read lecture.
Building knowledge bases The fundamental problem of understanding intelligence is not the identification of a few powerful techniques, but rather the question.
CE An introduction to Artificial Intelligence CE Chapter 8: First Order Logic Ramin Halavati In which we notice that.
Part 2: DESIGN CIRCUIT. LOGIC CIRCUIT DESIGN x y z F F = x + y’z x y z F Truth Table Boolean Function.
First-Order Logic Knowledge Representation Reading: Chapter 8, , FOL Syntax and Semantics read: FOL Knowledge Engineering read:
Chapter 4 Gates and Circuits. 4–2 Chapter Goals Identify the basic gates and describe the behavior of each Describe how gates are implemented using transistors.
Dr. Samy Abu Nasser Faculty of Engineering & Information Technology Artificial Intelligence.
Binary Addition CSC 103 September 17, 2007.
School of Computing FACULTY OF ENGINEERING Developing a methodology for building small scale domain ontologies: HISO case study Ilaria Corda PhD student.
AIC1 Logic Propositional Logic (Calculus) First Order Logic Based on Russell and Norvig slides.
First-Order Logic Chapter 8.
Lecture 9 Topics: –Combinational circuits Basic concepts Examples of typical combinational circuits –Half-adder –Full-adder –Ripple-Carry adder –Decoder.
First-Order Logic Chapter 8. Outline Why FOL? Syntax and semantics of FOL Using FOL Wumpus world in FOL Knowledge engineering in FOL.
1 First-Order Logic Chapter 8. 2 Why FOL? –How do you say “All students are smart?” –Some students work hard –Hardworking students have good marks –If.
CS344: Artificial Intelligence Pushpak Bhattacharyya CSE Dept., IIT Bombay Lecture 20,21: Application of Predicate Calculus.
© Copyright 2008 STI INNSBRUCK Intelligent Systems Predicate Logic.
First-Order Logic Chapter 8. Outline Why FOL? Syntax and semantics of FOL Using FOL Wumpus world in FOL Knowledge engineering in FOL.
Knowledge Representation using First-Order Logic 부산대학교 전자전기컴퓨터공학과 인공지능연구실 김민호
IT253: Computer Organization Lecture 7: Logic and Gates: Digital Design Tonga Institute of Higher Education.
CS 666 AI P. T. Chung First-Order Logic First-Order Logic Chapter 8.
The electronic circuits domain (and preparations for exercise) The circuit representation in chapter 8 is more detailed than necessary if we care only.
Half-Adder: A combinational circuit which adds two one-bit binary numbers is called a half-adder. The sum column resembles like an output of the XOR gate.
1 Ethics of Computing MONT 113G, Spring 2012 Session 5 Binary Addition.
First-Order Logic Chapter 8. Outline Why FOL? Syntax and semantics of FOL Using FOL Wumpus world in FOL Knowledge engineering in FOL.
Digital Logic Structures: Chapter 3 COMP 2610 Dr. James Money COMP
First-Order Logic Chapter 8. Outline Why FOL? Syntax and semantics of FOL Using FOL Wumpus world in FOL Knowledge engineering in FOL.
5/16/2005EE562 EE562 ARTIFICIAL INTELLIGENCE FOR ENGINEERS Lecture 12, 5/16/2005 University of Washington, Department of Electrical Engineering Spring.
1 CS 4700: Foundations of Artificial Intelligence Carla P. Gomes Module: FOL (Reading R&N: Chapter 8)
LOGIC Heng Ji Feb 19, Logic Knowledge-based agents Knowledge base (KB) = set of sentences in a formal language Declarative approach.
Lecture 8-2CS250: Intro to AI/Lisp What do you mean, “What do I mean?” Lecture 8-2 November 18 th, 1999 CS250.
How does a Computer Add ? Logic Gates within chips: AND Gate A B Output OR Gate A B Output A B A B
Knowledge Representation using First-Order Logic (Part II) Reading: R&N Chapters 8, 9.
Digital electronics 4–1 Gates and Circuits SANJAYBHAI RAJGURU COLLEGE OF ENGG.
CPSC 420 – Artificial Intelligence Texas A & M University Lecture 7 Lecturer: Laurie webster II, M.S.S.E., M.S.E.e., M.S.BME, Ph.D., P.E.
© Copyright 2008 STI INNSBRUCK Intelligent Systems – Predicate Logic Florian Fischer Partially based on CS188,
C OMBINATIONAL L OGIC D ESIGN 1 Eng.Maha AlGubali.
First-Order Logic Knowledge Representation
First-Order Logic Chapter 8.
First-Order Logic.
The electronic circuits domain (and preparations for exercise)
Artificial Intelligence First Order Logic
Notes 8: Predicate logic and inference
First-Order Logic Knowledge Representation
Artificial Intelligence 1: First-Order Logic
CS105 Introduction to Computer Concepts GATES and CIRCUITS
First-Order Logic Knowledge Representation
First-Order Logic Knowledge Representation
First-Order Logic Chapter 8.
Week 7: Gates and Circuits: PART II
Artificial Intelligence: Agents and First-Order Logic
Introduction to Artificial Intelligence
Number Systems and Circuits for Addition
First-Order Logic Chapter 8.
Knowledge Representation using First-Order Logic (Part III)
First-Order Logic Knowledge Representation
XOR Function Logic Symbol  Description  Truth Table 
First-Order Logic Chapter 8.
Representations & Reasoning Systems (RRS) (2.2)
Building knowledge bases
Presentation transcript:

Artificial Intelligence Building Knowledge Base Chapter 8

Outline of this Chapter Knowledge engineering Knowledge Representation The electronic circuits domain

Knowledge engineering The process of building knowledge base Knowledge engineer (KE) –investigates a particular domain. –Determine what concepts are important in that domain –Create a formal representation of the objects & relations in the domain KE is trained in representation but not usually an expert in the domain. KE interview the real expert to become educate about the domain & elicit the required k, in a process called Knowledge acquisition. Choosing a programming language Choosing a logic writing a program Building knowledge base choosing a compiler Implementing the proof theory running a program Inferring new facts

Knowledge Representation Representing a knowledge of a domain goes through several stages: 1.Identify the task –KE must define series of questions that the KB will support 2.Assemble the relevant knowledge. –KE might need to work with real expert to extract what they know. 3.Decide on a vocabulary of –Predicates, functions, constants –Translate the domain level concepts into logic level names.

Knowledge Representation (Cont.) 4. Encode general knowledge of the domain –KE writes down the axioms/logical sentences for all the vocabulary terms 5.Encode description of specific problem instance –Involves writing atomic sentences about instances of concepts. 6.Pose queries to the inference procedure and get answer –Let the inference procedure operate on the axioms & problem- specific facts –Derive the facts that we are interested in knowing 7.Debug the knowledge base –Answers to queries normally not correct on the first try. –If an axiom is missing, some queries will not be answerable from the KB To understand these 7 steps process, we turn to some examples of its use. We will consider the domain of Boolean electronic circuits next.

The electronic circuits domain One-bit full adder A digital circuit C1, with 3 inputs, containing 2 XOR gates, 2 AND gates & 1 OR gate. Input: bit values to be added. Output: 1- sum bit & 2 - carry bit

The electronic circuits domain 1.Identify the task –Does the circuit actually add properly? (circuit verification) –If all inputs are high, what is the output of gate 2 –What are all the gates connected to the first input terminal? 2.Assemble the relevant knowledge –Composed of wires and gates –Signals flow along wires to the input terminals of gates –Each gate produces a signal on the output terminal –There are 4 types of gates: AND, OR, XOR and NOT AND, OR, XOR have 2 inputs terminals NOT has only 1 –Irrelevant: size, shape, color, cost of gates

The electronic circuits domain 3.Decide on a vocabulary after deciding what we want to talk about in the prev slide (circuits, signals, gates & terminals) in this step- choose functions, predicates, & constants. Naming gates : X1,X2,etc (constants) Type of gates: type(X1) = XOR, type(X5) = OR (functions) Note:- type(X1) = XOR can also be represented as type(X1,XOR) 4.Encode general knowledge of the domain  t 1,t 2 Connected(t 1, t 2 )  Signal(t 1 ) = Signal(t 2 )  t Signal(t) = 1  Signal(t) = 0 where 1 ≠ 0  t 1,t 2 Connected(t 1, t 2 )  Connected(t 2, t 1 )  g Type(g) = OR  Signal(Out(1,g)) = 1   n Signal(In(n,g)) = 1  g Type(g) = AND  Signal(Out(1,g)) = 0   n Signal(In(n,g)) = 0  g Type(g) = XOR  Signal(Out(1,g)) = 1  Signal(In(1,g)) ≠ Signal(In(2,g))  g Type(g) = NOT  Signal(Out(1,g)) ≠ Signal(In(1,g))

The electronic circuits domain 5.Encode the specific problem instance We categorize the gates Type(X 1 ) = XOR Type(X 2 ) = XOR Type(A 1 ) = AND Type(A 2 ) = AND Type(O 1 ) = OR Show the connection between them Connected(Out(1,X 1 ),In(1,X 2 ))Connected(In(1,C 1 ),In(1,X 1 )) Connected(Out(1,X 1 ),In(2,A 2 ))Connected(In(1,C 1 ),In(1,A 1 )) Connected(Out(1,A 2 ),In(1,O 1 )) Connected(In(2,C 1 ),In(2,X 1 )) Connected(Out(1,A 1 ),In(2,O 1 )) Connected(In(2,C 1 ),In(2,A 1 )) Connected(Out(1,X 2 ),Out(1,C 1 )) Connected(In(3,C 1 ),In(2,X 2 )) Connected(Out(1,O 1 ),Out(2,C 1 )) Connected(In(3,C 1 ),In(1,A 2 ))

The electronic circuits domain 6.Pose queries to the inference procedure What are the possible sets of values of all the terminals for the adder circuit? 7.Debug the knowledge base

Summary The process of representing Knowledge of a domain goes through several stages. 1.Identify the task 2.Assemble the relevant knowledge. 3.Decide on a vocabulary 4.Encode general knowledge of the domain 5.Encode description of specific problem instance 6.Pose queries to the inference procedure and get answer 7.Debug the knowledge base Good representation eliminate irrelevant detail, capture relevant distinctions, & express K at the most general level possible.

End of Chapter 8