Some Thoughts to Consider 2

• Aside from what AI is or isn’t, it is possible to build competent software by accurate knowledge representation and the capability for automated reasoning using that knowledge.

• An intelligent piece of software is one that surprises its designers occasionally.

• Once AI techniques have been incorporated into standard software practice, they are no longer considered part of AI.

• There are several interesting polarities (continua?) present in AI culture. Consider the following:

Weak AI ----------------------------------- Strong AI

Neat ----------------------------------- Scruffy

Symbolic ----------------------------------- Emergent

Web Svc ----------------------------------- Sem Web

• How do you react to:• Eliza

• Ramona

• Alice

Four Approaches to AI

• Acting Humanly• The Turing Test Approach

• Emulating what humans do

• Thinking Humanly• The Cognitive Modeling Approach

• Cognitive Science

• Thinking Rationally• The “Laws of Thought” Approach

• Represent everything in terms of logic

• Acting Rationally• The Rational Agent Approach

• Agents are designed software and hardware artifacts that ‘do the right thing’

The textbook concentrates on the fourth approach: the general principles of rational agents and the components for constructing them.

Skills Required for an Agent to Pass the Turing Test

• Natural Language Processing

• Knowledge Representation

• Automated Reasoning

• Machine Learning

And for the ‘Total Turing Test’:

• Computer Vision

• Robotics

These areas of endeavor cover most of AI tradition and practice for the past 50 years.

A Practical Inferencing Excursion

• It is important to start engaging with examples that illustrate AI concepts. This provides context for the textbook learning.

• To this end, consider a simple knowledge system (agent) that recommends how to get to the theater on time.

• Consider several variations on how to represent the knowledge and how to reason to the advice:

• Hardcoded programming language

• Decision tables

• Rule based inferencing

• Backward chaining

• Forward chaining

• Reasoning over semantic network representation

• Logic and resolution theorem proving

Modus Ponens

• If A is known to be true,

• And if a rule states: If A, then B,

• It is valid to conclude that B is true.

• When B is known to be false,

• And if a rule states: If A, then B,

• It is valid to conclude that A is false.

Modus Tollens

Most expert systems use Modus Ponens.

Rules for Getting to the Theater on Time

1. If Distance > 5 miles then Means is drive

2. If Distance > 1 mile and Time < 15 minutes then Means is drive

3. If Distance > 1 mile and Time > 15 minutes then Means is walk

4. If Means is drive and Location is downtown then Action is take a cab

5. If Means is drive and Location is not downtown then Action is drive your car

6. If Means is walk and Weather is bad then Action is take a coat and walk

7. If Means is walk and Weather is good then Action is walk

Getting to the Theater on Time in Code

/** * TheaterDecision - a class to provide decision support * for getting to the theater on time. */public class TheaterDecision {

static int distance; static int time; static String location; static String means; static String weather; static String action;

/** * Four arguments are anticipated: * args[0] distance in miles to theater * args[1] time in minutes before performance * args[2] location of theater (downtown or notdowntown) * args[3] weather conditions (bad or good) */ public static void main (String[] args) { distance = Integer.parseInt(args[0]); time = Integer.parseInt(args[1]); location = args[2]; weather = args[3];

if (distance > 5) means = "drive"; else if (distance > 1) { if (time < 15) means = "drive"; else means = "walk"; } if ("drive".equals(means)) { if ("downtown".equals(location)) action = "Take cab."; else action = "Drive."; } else if ("walk".equals(means)) { if ("bad".equals(weather)) action = "Take coat and walk."; else if ("good".equals(weather)) action = "Walk."; } if (action == null) action = "No decision available."; System.out.println("Decision: " + action); }

} // End of TheaterDecision class

GTTTOT via Decision Tables

Distance Time Means Location Weather Action

Table to conclude meansgt 5 miles drivegt 1 mile lt 15 drivegt 1 mile gt 15 walk

Table to conclude actiondrive downtown take cabdrive not downtown drive carwalk bad walk with coatwalk good walk

Composite table with 'don't care' conditionsgt 1 mile lt 15 drive downtown take cabgt 1 mile lt 15 drive not downtown drive cargt 1 mile gt 15 walk bad walk with coatgt 1 mile gt 15 walk good walkgt 5 miles drive downtown take cabgt 5 miles drive not downtown drive car

Table of all possibilitiesgt 1 mile lt 15 drive downtown bad take cabgt 1 mile lt 15 drive downtown good take cabgt 1 mile lt 15 drive not downtown bad drive cargt 1 mile lt 15 drive not downtown good drive cargt 1 mile gt 15 walk downtown bad walk with coatgt 1 mile gt 15 walk downtown good walkgt 1 mile gt 15 walk not downtown bad walk with coatgt 1 mile gt 15 walk not downtown good walkgt 5 miles lt 15 drive downtown bad take cabgt 5 miles lt 15 drive downtown good take cabgt 5 miles lt 15 drive not downtown bad drive cargt 5 miles lt 15 drive not downtown good drive cargt 5 miles gt 15 drive downtown bad take cabgt 5 miles gt 15 drive downtown good take cabgt 5 miles gt 15 drive not downtown bad drive cargt 5 miles gt 15 drive not downtown good drive car

GTTTOT Using a Semantic Network

import java.util.Vector;import org.narl.*;

/** * TheaterDecision2 - a class to provide decision support * for getting to the theater on time. */public class TheaterDecision2 {

static NodeTag[] paramNames = {NodeTag.intern("distance"), NodeTag.intern("time"), NodeTag.intern("location"), NodeTag.intern("weather")};

/** * Four arguments are anticipated: * args[0] distance in miles to theater * args[1] time in minutes before performance * args[2] location of theater (downtown or notdowntown) * args[3] weather conditions (bad or good) */ public static void main (String[] args) throws Exception { if (!Narl.isPresent()) Narl.newEnv(); Narl.nread("TheaterOnTime.narl");

Vector predList = new Vector(); Vector pred;

for (int i = 0; i < paramNames.length; i++) { if (i < 2) pred = NarlC.makeVector3(paramNames[i], NarlC.VALUE, new Integer(args[i])); else pred = NarlC.makeVector3(paramNames[i], NarlC.VALUE, args[i]); predList.addElement(pred); }

NodeTag[] contexts = Node.ngetIntersectNode(predList); if (contexts == null) System.out.println("No decision."); else for (int j = 0; j < contexts.length; j++) System.out.println("Action: " + Node.ngetName(contexts[j])); }

} // End of TheaterDecision2 class

GTTTOT Rules in Nodes

;=========================================================

; Model to handle rules for Getting to the Theater on Time

;---------------------------------------------------------

; Rules in English:

; 1. If Distance > 5 miles

; then Means is drive

; 2. If Distance > 1 mile and Time < 15 minutes

; then Means is drive

; 3. If Distance > 1 mile and Time > 15 minutes

; then Means is walk

; 4. If Means is drive and Location is downtown

; then Action is take a cab

; 5. If Means is drive and Location is not downtown

; then Action is drive your car

; 6. If Means is walk and Weather is bad

; then Action is take a coat and walk

; 7. If Means is walk and Weather is good

; then Action is walk

;============================================

(rule-model-root

(a-kind-of (value model-root))

)

;--------------------------------------------

(rule-node

(a-kind-of (value rule-model-root))

)

(theater-rule

(instance-of (value rule-node))

(goal (value action))

(multivalued (value action))

(parameter (distance 3)

(time 20)

(location "downtown")

(weather "good"))

)

GTTTOT Rules in Nodes (cont.)

(rule_1

(instance-of (value theater-rule))

(rule (value

{if {distance > 5}

{then {set {theater-rule parameter means} "drive"}}}))

)

(rule_2

(instance-of (value theater-rule))

(rule (value

{if {distance > 1} {time < 15}

{then {set {theater-rule parameter means} "drive"}}}))

)

(rule_3

(instance-of (value theater-rule))

(rule (value

{if {distance > 1} {time > 15}

{then {set {theater-rule parameter means} "walk"}}}))

)

(rule_4

(instance-of (value theater-rule))

(rule (value

{if {means = "drive"} {location = "downtown"}

{then {set {theater-rule parameter action} "Take a cab"}}}))

)

(rule_5

(instance-of (value theater-rule))

(rule (value

{if {means = "drive"} {location != "downtown"}

{then {set {theater-rule parameter action} "Drive car"}}}))

)

(rule_6

(instance-of (value theater-rule))

(rule (value

{if {means = "walk"} {weather = "bad"}

{then {set {theater-rule parameter action} "Walk with coat"}}}))

)

(rule_7

(instance-of (value theater-rule))

(rule (value

{if {means = "walk"} {weather = "good"}

{then {set {theater-rule parameter action} "Walk"}}}))

)

GTTTOT Code to Utilize Rule Engine

import java.util.Enumeration;import com.mckesson.narl.*;

/** * TheaterDecision3 - a class to provide decision support * for getting to the theater on time using rules compatible * with NarlRuleMgr. */public class TheaterDecision3 {

static NodeTag RULEROOT = NodeTag.intern("rule-node"); static NodeTag TSTATE = NodeTag.intern("theater-rule"); static NodeTag PARAM = NodeTag.intern("parameter"); static NodeTag ACTION = NodeTag.intern("action");

/** * Four arguments are anticipated: * args[0] distance in miles to theater * args[1] time in minutes before performance * args[2] location of theater (downtown or notdowntown) * args[3] weather conditions (bad or good) */ public static void main (String[] args) throws Exception { if (!Narl.isPresent()) Narl.newEnv(); Narl.nread("TheaterRules.narl");

if (args.length > 0) { Node.nrplAll(TSTATE, PARAM, NodeTag.intern("distance"), new Integer(args[0])); Node.nrplAll(TSTATE, PARAM, NodeTag.intern("time"), new Integer(args[1])); Node.nrplAll(TSTATE, PARAM, NodeTag.intern("location"), args[2]); Node.nrplAll(TSTATE, PARAM, NodeTag.intern("weather"), args[3]); }

NarlRuleMgr rm = new NarlRuleMgr(); NarlQueue2 actions = new NarlQueue2();

while (true) { System.out.println(Narl.ngetNode(TSTATE).toStringPp()); boolean moreToDo = false; Enumeration rules = Node.ngetAllInstances(RULEROOT);

while (rules != null && rules.hasMoreElements()) { NodeTag rule = (NodeTag) rules.nextElement(); rm.doRules(rule);

Enumeration acts = Node.ngetSomeIEnum(RULEROOT, PARAM, ACTION, NarlC.kindInvArcs);

while (acts != null && acts.hasMoreElements()) { String act = (String) acts.nextElement(); if (!actions.contains(act)) { actions.addRearMaybe(act); moreToDo = true; } } } if (!moreToDo) break; } System.out.println(actions); }

} // End of TheaterDecision3 class

Resolution Theorem Proving

• A way to discover whether a new fact is valid, given a set of logical statements.

• Based on the fact that the following two statements are logically equivalent:

• If A, Then B.

• Not (A) or B.

• One can show this by a truth table:

A B Not (A) If A then B Not (A) or B

T T F T T

T F F F F

F T T T T

F F T T T

GTTTOT By Logical Inference (Resolution)

• Given:• If distance > 5 miles, Then means = drive.

• If means = drive, Then action = take a cab.

• Fact: distance > 5 miles.

• Step 1: Rewrite the IF-THEN statements as OR statements:• Not (distance > 5 miles) or means = drive.

• Not (means = drive) or action = take a cab.

• Distance > 5 miles

• Step 2: Assert the negation of the thesis in question and add it to the list:• Not (action = take a cab).

• Step 3: Resolve pairs of facts with the following rule:Not (X) or Y

Not (Y) or Z

Not (X) or Z

• Using the example, inference 1:

Not (distance > 5) or means = drive

Not (means = drive) or action = take a cab

Not (distance > 5) or action = take a cab

• Inference 2:

Not (distance > 5) or action = take a cab

Distance > 5

Action = take a cab

• Inference 3:

action = take a cab

Not (action = take a cab)

Contradiction!

• Step 4: Accept that the thesis is true if a contradiction is encountered. This means that we should believe that ‘action = take a cab’ is correct.

GTTTOT in First Order Logic (Prolog)

case(8, 8, downtown, good).

distance(D) :- case(D, _, _, _).

time(T) :- case(_, T, _, _).

location(L) :- case(_, _, L, _).

weather(W) :- case(_, _, _, W).

means(X) :- distance(D), D > 5, X = drive.

means(X) :- distance(D), D > 1, time(T), T < 15, X = drive.

means(X) :- distance(D), D > 1, time(T), T > 15, X = walk.

action(X) :- means(drive), location(downtown), X = takecab.

action(X) :- means(drive), not location(downtown), X = drivecar.

action(X) :- means(walk), weather(good), X = walk.

action(X) :- means(walk), weather(bad), X = walkwithcoat.