A Tutorial for adding knowledge to your robot
Copyright by Doubly Aimless (aimless@pandorabots.com) - August 18, 2003 - Rev. 6
Japanese translation & editing of the English edition by Seiji Umatani
(umatani@kuis.kyoto-u.ac.jp)
You are reading a short tutorial describing how to create and add knowledge to your Robot.
A successful Robot will appear human. Your goal as the botmaster is simple: build
content that induces the client to carry on conversations with your Robot as long as
possible. Do this by creating a variety of potential answers to various questions, or
re-directing a conversation to new topics that the client finds interesting - always with
the goal of continuing the interactions as long as possible. Examples of
such bots appear in the annual Loebner contest
(http://www.loebner.net/Prizef/loebner-prize.html) and the forthcoming annual chatterbot
beauty contest
(http://www.international-lisp-conference.org/Competitions/Chatterbots/ILC02-chatterbots.html).
Pandorabots allows you to extend the knowledge of your bot via a programming language
called AIML. The goal of this tutorial is to teach you the minimum of AIML necessary to
make your robot "smarter" and better able to carry on a conversation.
After working through the tutorial you will also want to visit the site www.pandorabots.com and use the tool -
Pandorawriter - which automatically converts English text to a subset of AIML, and greatly
eases the task of adding knowledge to your bot.
This Tutorial is a draft - and unfortunately has errors and omissions. Better versions
will be forthcoming. Some of you will argue that it would have been better to postpone
publication - yet the cry for some kind of documentation was just too much. Please accept
my apologies for this draft's roughness.
Please mail comments and problems to the attention of Dr. Doubly Aimless at info@pandorabots.com. The first Discoverer of (for
the first time) an error (reported by e-mail please) shall receive a commemorative check
(suitable for framing) and a listing in ALICE Hall of Fame. More details on
the information in this tutorial can be found in the references listed at the end. In
particular, the latest version of the AIML language contains many of the details omitted
in this document.
The robots discussed in this document, and on www.pandorabots.com, are based on AIML and
spring entirely from the work of Dr. Richard Wallace and the A.L.I.C.E. and AIML free
software community based at http://www.alicebot.org/.
Some of you might find this metaphor helpful for visualizing how knowledge is laid out in
your robot. Imagine a spider web - it has a center with spokes radiating outwards from the
center. Your robot's knowledge is stored in a Knowledge Web, and like the spider, your
robot darts out in response to some sort of tug it senses in the web. Understanding how to
store knowledge is our first task. Because it is too hard to draw the whole web, in the
examples that follow, only a portion of the web will be shown - so please use your
imagination for the rest.
Starting at www.pandorabots.com, if you have not already done so, create an account and
then follow the directions to create a new robot, name it Full (for full of knowledge) and
be sure to check the radio button labeled: -Dr Wallace's A.L.I.C.E March 2002.
For Robots that interact using Japanese characters (and English characters) check the box
annotated with: automatically discover spaces between words (suggested for Japanese).
(Spaces are automatically inserted between words written in Japanese when this option is
checked).
Click on Create Bot, and on the next screen click on "build and run" to begin
interactions with your robot.
Create a second robot, call it Empty (for empty of knowledge) checking the button labeled:
-no initial content, the bot starts with no knowledge
(Footnote 0).
Let's start with the Robot named Full - which already was taught (by Dr. Richard Wallace)
to answer the inquiry:
Human: do you love me?
Full: Yes I love everyone.
Look at Picture 1.0.
The robot knew in advance how to answer this question. How specifically did the Robot
discover the answer? First the robot checked if its knowledge already contained the
question "do you love me?" and second, finding it, had it been taught to respond
with something meaningful.
Categories
The words in the sentence "do you love me?" can be visualized by a series of
lines (or links) and nodes, in the knowledge web. The links are labeled by the words (and
you can think of the nodes as representing the spaces between the words) and form a chain
starting from the center of the web and moving outwards. Finding the question in the
Knowledge Web, the robot replies with the information we taught it (residing in a Response
Template - and referred to as the Template). So, in other words, the specific question
"do you love me" can be visualized as a kind of path - beginning at the center
of the Knowledge Web and built up by a series of links and nodes, and that finally
terminates in a Response Template. The specific path through the Knowledge Web along with
the (Response) Template is called a Category. When you teach the robot to respond with:
"yes, but only when you are good" you only change the Response Template.
More about Categories
Let's start over with a robot that has no knowledge. You should have already created
and named it Empty - and if not, go ahead and build it now. Initially, Picture 1.1 shows
Empty's very simple Knowledge Web. One Category is shown and notice the Response Template
contains the one sentence "I have no answer for that". You will also notice *,
<THAT> and <TOPIC> labeling the links between the nodes. The labels *,
<THAT> and <TOPIC> are special optional variants offering enhancements to
Categories. As we shall see, these special labels extend the matching power of the
Categories.
So what does this one Category do? To begin with the * label allows ANY interaction with
Empty to return the same response:
You: "Hello"
Empty: "I have no answer for that"
You: "abc"
Empty: "I have no answer for that"
More generally, words or sentences provided to the robot are called the Input Pattern. You
can visualize any sentence existing in the Knowledge Web as a path of linked nodes,
terminating with a Response Template. The robot searches for a path of linked nodes that
exactly matches the Input Pattern. When a path is found, we say that the path matches the
Input Pattern.
Default Responses
It happens often that an Input Pattern will not be found in the Knowledge Web - yet we
still want the Robot to respond with something meaningful. We call this the Default
Response Template - and it typically consists of sentences designed to keep the
conversation going. We can visualize the Default Category (a path empty of all words and
it's Response Template) by Picture 1.1(pictured above). The * will match any words. The
<THAT> and <TOPIC> will be explained later.
Teach your bot to say "Hi there!" in response to Hello. (Type "Hello" and then "Hi there!"
in the box labeled Say This Instead.)
Now the Knowledge Web
looks like
Picture 1.2.
The Robot has just two responses now - and is incapable of supporting its side of an
interesting conversation. Let's make some more changes. In response to you typing anything
but Hello (the one input pattern that Empty now knows about) Empty will randomly present
you with three possible responses. Type:
You: "hi"
Empty: "I have no answer for that"
Next, click on "Advanced Alter Response:"
In the box labeled New AIML replace HI with *, which means that anything you type in will
be matched with a response. Now let's add three random possible responses. In the box
labeled Template add:
<random>
<li> What is your name? </li>
<li> What is your favorite movie? </li>
<li> Will you buy me a drink? </li>
</random>
[footnote 2]
The Knowledge Web now looks like Picture 1.3.
We've changed the Default Category by changing the Default Response Template from "I
have no answer to that" to one of three randomly chosen responses. Like a hapless,
but precocious child failing to understand what is being said, yet unwilling to be
abandoned, Empty attempts to prolong the conversation by offering a choice of three
"pick-up" lines hoping to change the subject. Empty proffers pick-up lines
randomly hoping to disguise how little it actually knows. Check this yourself by typing
anything but "Hello". Click on the Ask This Again button enough times to cycle
through the complete set of pick-up lines.
Saving your Work and Starting Over
For reasons will see later, most of the time you want to avoid changing the Ultimate
Default Category. Let's go back to the beginning and start over, And simultaneously learn
how to save files.
Click on "botmaster control", click on "Edit" in the row beginning
with "Empty", click on "update.aiml" and notice this file contains all
the changes we made. On some browsers you may have to click on the browser reload button
to view the latest changes added to this file. You can save this file to your local
computer (a good idea to do every time you make many changes) by clicking on your
browser's file menu item and then your browser's "save as" menu item.
Look at the file for a minute - the first line (of header information) tell us the type of
character set and versions of xml we are using. The next line tells us we are using
aiml version 1.0. (The output below came from IE 5.5 and the hyphens before the AIML tags
are gratuitously added by IE).
<?xml version="1.0"
encoding="UTF-8" ?>
- <aiml version="1.0">
- <category>
<pattern>hello</pattern>
<template>hi there</template>
</category>
- <category>
<pattern>*</pattern>
- <template>
- <random>
<li> What is your name? </li>
<li> What is your favorite movie? </li>
<li> Will you buy me a drink? </li>
</random>
</template>
</category>
</aiml>
Categories are specified by the information between the beginning and ending lines in the
form: <category>..... information ....</category>
Similarly, the input words are specified by: <pattern>...information ...
</pattern>
The output response is specified by the information between <template> and
</template>.
The items between < and > are called AIML tags or elements. Each AIML tag has an
opening tag and a closing tag of the form: <SOME-TAG>
....information....</SOME-TAG>. The "-" is purely notational, and are not
really present in the file and are added (by IE) as a means of improving the readability
of the xml and mark the beginning of a new AIML tag. So, for example, the beginning of the
file is marked with -<aiml version="1.0"> and a closing element
</aiml>.
It sometimes happens that there is no information between the opening and closing tags and
you can use the abbreviation <SOME-TAG/> as a replacement for
<SOME-TAG></SOME-TAG>. Each time you click on Advanced Alter Response (or
click on "say this instead") the effect is to add new information to the file
update.aiml. (Remember to click on your browser's reload button to see it). You can get
the equivalent effect by editing update.aiml with a regular text editor or an xml editor
(on your local machine) and uploading it.
Creating a new version of Empty
Click on "botmaster control" and click on "Delete" in the row
beginning with "Empty".
Click on "Create a new bot", call it "Empty",
check all other boxes as before
and click on "Build and Run this bot". You've now got a fresh empty
robot.
More about Categories
Empty of knowledge the only thing Empty can say is:
Empty: "I have no answer for that"
Let's increase the possibilities for an interesting conversation by giving four possible
random responses to the next inquiry.
You: "You do love me don't you"
Empty: "I have no answer for that"
Click Advanced Alter Response:
In the box labeled Template add:
<random>
<li> I don't know, what have you done for me lately?</li>
<li> Yes, but you have to really try to make me
happier...</li>
<li> Stop your whining!</li>
<li> Yes, but only when you are good to me </li>
</random>
Click on the Ask This Again button enough times to cycle through the complete set of
responses. The Knowledge Web now looks like Picture 1.4.
Contractions like "don't" are expanded to "do not", so: "you do
love me don't you?" is transformed to (the ugly) "you do love me do not
you" (see Footnote 1).
What are <THAT> and <TOPIC>?
Using <THAT> the robot is capable of remembering what it said in the previous
interaction. And conversations can become more meaningful. <THAT> was named and
arose from analyzing a conversational exchanges like:
Empty: Today I love you.
You: That is wonderful.
Empty: But, will I still love you tomorrow?
You: That is what I want to find out.
First we need a category that is useful for working with <THAT> expressions. Enter
this category into Empty by:
You: say *
Empty: I have no answer for that
Click Advanced Alter Response:
Notice the contents of the box labeled "New AIML" are the beginning of a new
category: SAY * (there is a space between SAY and *)
In the box labeled "Template" add: <star/>
Recall that <star/> is a shorter way of writing <star></star> and the
effect of this change is to match anything. Then "Say anything" will always set
<THAT> to "anything." So for example:
You: say I love you
Empty: I love you
We are going to use this category to test our categories that use <THAT>.
Example 1 - Who are you?
At some point your robot might want to know who it is talking to. Here is how to do
this.
You: *
Empty: I have no answer for that
Click Advanced Alter Response:
Check the box labeled: "depends on this That" and replace the box's contents
with:
What is your name?
Notice the box labeled "New AIML" contains:* meaning that any response will be
matched. In the box labeled "Template" add:
Nice to meet you <set
name="name"><person/></set>.
This last bit of AIML code grabs the person's name.
Now ask the bot, "Say what is your name," to generate the state in which the
next input will activate the <THAT> category.
You: say what is your name
Empty: what is your name
You: Mr. Lovejoy
Empty: Nice to meet you Mr. Lovejoy.
Example 2 - YES and NO Questions
Use <THAT> for categories that seek yes and no responses. Here is an example for
"yes" questions.
You: yes
Empty: I have no answer for that
Click Advanced Alter Response:
Check the box labeled: "depends on this That" and replace the box's contents
with:
Are you looking for love?
Notice the box labeled "New AIML" contains: YES
In the box labeled "Template" add four random responses:
<random>
<li> Aren't we all looking for love?</li>
<li> Well you've come to the right place!</li>
<li> And what kind of love are we looking for today?</li>
<li> Well I am overflowing with Love for you today </li>
</random>
You: say are you looking for love?
Empty: are you looking for love
You: yes
Empty: Well you've come to the right place!
Example 3 - Discovering what knowledge to add to a Robot
The AIML tag <THAT> refers to whatever Empty last said. Use <THAT/> and a
default template to add new knowledge:
You: Why
Empty: I have no answer for that
Click on Say This Instead: "<THAT/>"? Why?
One of the default replies to the input "WHY" is "<that/>"? Why?
This default produces the following dialogue fragment:
Robot: Do not ask me any more questions please.
Client: WHY
Robot: "Do not ask me any more questions please"? Why?
The botmaster notices the fragment and creates the new AIML category:
<category>
<pattern>WHY</pattern>
<that>DO NOT ASK ME ANY MORE QUESTIONS PLEASE</that>
<template>Because I would rather talk about you.</template>
</category>
Now the next client who asks "WHY" to the robot's request will active the new
<that> category:
Robot: Do not ask me any more questions please.
Client: WHY
Robot: Because I would rather talk about you.
This style of conversational analysis does not presuppose that we know when the client
will say "WHY"; rather it looks backward to identify cases where the
"WHY" appeared following one of the robot's statements. Having identified the
conversation point, the botmaster creates the new category.
Example 4
Let's look at a slightly convoluted example. Following an earlier example (click on Ask
Again enough times to get the response in the first exchange below):
You: You do love me don't you
Empty: Yes, but you have to really try to make me happier...
You: But I try so hard to please you...
Empty: I have no answer for that.
Click Advanced Alter Response:
Check the box labeled: "depends on this That" which should contain "Yes but
you have to really try to make me happier" Notice the box labeled "New
AIML" contains: "BUT I TRY SO HARD TO PLEASE YOU"
In the box labeled "Template" add (without the quotes): "And sometimes you
succeed, it's just that you could do so much better"
So only when the robot's random response matches the interaction in the next exchange:
You: you do love me don't you?
Empty: Yes, but you have to really try to make me happier...
You can type in:
You: But I try so hard to please you ...
Empty: And sometimes you succeed, it's just that you could do so much
better
Except for the case mentioned above, the robot's response to:
You: But I try so hard to please you ...
will be:
Empty: I have no answer for that
Picture 1.5 shows the situation
So, <THAT> modifies a category - meaning match the category only if the robot said
what follows the <THAT> in the previous utterance. Continuing with this example:
You: You just don't appreciate me, - you take me for
granted and walk all over me...
Empty: I have no answer for that
Click Advanced Alter Response:
Check the box labeled: "depends on this That" (which now contains the contents
of last Response Template): "And sometimes you succeed it is just that you could do
so much better"
Notice the contents of the box labeled "New AIML" are the beginning of a new
category "YOU JUST DO NOT APPRECIATE ME YOU TAKE ME FOR GRANTED AND WALK ALL OVER
ME"
In the box labeled "Template" add: "If you worked harder it will help me to
develop more enthusiasm for appreciating you - what do you want me to do? Fake my
appreciation or really feel it?"
With these changes the following interchanges are possible (click "Ask This
Again" enough times to generate Empty's (random) response in the first exchange
below)
You: you do love me don't you?
Empty: Yes, but you have to really try to make me happier...
You: but I try so hard to please you ...
Empty: And sometimes you succeed, it's just that you could do so much
better
You: You just don't appreciate me, - you take me for granted and walk
all over me...
Empty: If you worked harder I might be able to develop a little more
enthusiasm for appreciating you - what do you want me to do?
Fake my appreciation or really feel it?"
Picture 1.6 shows the current state of knowledge.
The contents of the file update.aiml is as follows. (the red text)
- <category>
<pattern>YOU DO LOVE ME DO NOT YOU</pattern>
- <template>
- <random>
<li>I don't know, what have you done for me lately?</li>
<li>Yes, but you have to really try to make me happier...</li>
<li>Stop your whining!</li>
<li>Yes, but only when you are good to me</li>
</random>
</template>
</category>
- <category>
<pattern>BUT I TRY SO HARD TO PLEASE YOU</pattern>
<that>Yes but you have to really try to make me happier</that>
<template>And sometimes you succeed, it's just that you could do so much better</template>
</category>
- <category>
<pattern>YOU JUST DO NOT APPRECIATE ME YOU TAKE ME FOR GRANTED AND WALK ALL OVER ME</pattern>
<that>And sometimes you succeed it is just that you could do so much better</that>
<template>If you worked harder it will help me to develop more enthusiasm for appreciating you - what do you want me to do? Fake my appreciation or really feel it?</template>
</category>
What about <TOPIC>?
Topic lets you group together Categories. Presented Input patterns are searched for
matching categories within the Robots knowledge web. If more than one matching category is
found, the robot matches the <THAT> patterns next, and if more than one of these
exist, the robot matches <TOPIC> next. Categories are stored in alphabetical order
by pattern. Inputs to be matched to Categories are compared in reverse order. So when the
matches more than one category the last one is taken. Typically we might want to bundle up
a bunch of Categories into one general topic. So lacking an adequate response and knowing
that we have a specific Topic, the robot can generate specific pick-up lines and keep the
conversation going. How do we do this?
Example 1 - Using Topics
You: *
Empty: I have no answer for that
Enter this category into Empty by:
You: *
Empty: I have no answer for that
Click Advanced Alter Response:
Notice the contents of the box labeled "New AIML" contain * - which matches
anything.
In the box labeled "Topic" add: girls.
In the box labeled "Template" add:
<random>
<li> I wonder what about them you like best?</li>
<li> I've been known to like girls too!</li>
<li> Can you distinguish between girls and women?</li>
<li> Is there anything you don't love? </li>
</random>
We've changed the default response category when we are talking about girls. Empty uses
one of four randomly chosen pickup lines to continue the conversation. Before we can test
or use this new category, we have to change the topic. And we can use this to teach a
little more about the interface. Enter the following:
You: topic *
Empty: I have no answer for that
Click Advanced Alter Response:
Notice the contents of the box labeled "New AIML" contains: TOPIC *
In the box labeled "Template" add:
<think>
<set name="topic">
<star/>
</set>
</think>
OK, I've reset the topic to <star/>.
I've now reset the topic to <set name="name"><star/></set>.
We've created a new category and written a little bit of AIML code and used it to change
the <TOPIC>. The <think> tags demarcate a "hidden" sequence of
instructions - hidden in the sense the client will not see them. The <set> tags
demarcate the way we change the topic (which is changed to the input pattern marked by the
singleton tag <star/>. (a list of the AIML Tags is available at the time of this
writing at: http://www.alicebot.org/committees/architecture/resolutions/aiml10.html)
With this new category we can change the <TOPIC> as in:
You: topic girls
Empty: OK, I've reset the topic to girls.
You: I love girls
Empty: Is there anything you don't love?
Use this bit of code to get back to the default state of no topic. Enter the following:
You: notopic
Empty: I've been known to like girls too!
Click Advanced Alter Response:
In the box labeled "Template" add:
<set name="topic"/> done
Resulting in:
You: notopic
Empty: done
Let's first add some more knowledge to Empty.
You: "you do love me?"
Empty: "I have no answer for that".
Teach Empty instead to say "yes, but only when you are good to me".
Changing the input to:
You: "do you love me?"
Empty: "I have no answer for that"
Again, teach Empty instead to say: "yes, but only when you are good to me".
So that either input patterns "you do love me?" or "do you love me?"
prompts the response Empty: "yes, but only when you are good to me".
>From the viewpoint of knowledge content Picture 2.0 describes the current state.
So next:
You: "don't you love me?"
Empty: "I have no answer for that"
Teach it instead to say: "Yes, but only when you are sweet to me".
So we can also have the following interaction:
You: "don't you love me?"
Empty: "Yes, but only when you are sweet to me".
Now we will add a <TOPIC> and describe how to save and upload files.
Click on:
"botmaster control",
"edit this bot",
"make changes", (to add the most recent changes to
update.aiml)
"update.aiml",
Save the file to your local machine. Open the saved file with an editor. Under the line:
<aiml version="1.0"> Add the lines:
<topic name="LOVE">
<category>
<pattern>*</pattern>
<template> <random>
<li> How much do you love me?</li>
<li> Why don't you ever show me you love me?</li>
<li> Why is it so difficult for you to show affection?</li>
<li> Your coldness chills me to the bone</li>
</random>
</template>
</category>
Add the line </topic> at the end of the file, so that last two lines look like:
</topic>
</aiml>
Load your changed file. Click on Make Changes. Click and Build and Run. Your file only
becomes active when the topic is Love. So the robot will respond to anything you type with
"I have no answer for that". To set the topic, type in * and put this line into
the Template box:
<set
name="topic">love</set>
Whenever the topic is "Love" and the robot lacks a response, your robot will
response with one of 4 possible lines.
How about International Languages?
Your robot can handle any international character set. We could have asked the robot a
similar question in Japanese:
[ ] ... translation - Do you love me
Full: I have no answer that
Certain language such as Chinese and Japanese assume no spaces exist between
"words". For Japanese, Pandorabots will automatically accept sentences
lacking spaces from clients and store them internally will spaces inserted between
"words". A similar algorithm can also be used for Chinese and at the time
of this writing remains unimplemented. Using the algorithm for Japanese on Chinese
sentences results in spaces inappropriately inserted. In either case the botmaster's
job of matching input patterns is considerably simplified by the automatic insertion of
such spaces.
How can I display photographs and other Images?
Response templates can do far more than provide responses. They can run arbitrary
programs and serve pages from other web sites. You can, for example ask the Empty to show
a picture of another person - and the picture can be anywhere on the web.
You: Show me what you think love is.
Empty: I have no answer for that
Click on "Say This Instead" and put in the box:
This is one of my many pictures of love: <img
sr.="http://www.pandorabots.com/pandora/pictures/cn.jpg"/>
You can also simplify some of the typing by clicking on the <img> button in the
Advanced Alter Response page next to the Template area.
Making Knowledge Content Changes
When you click on the button "botmaster control" and next on "edit"
your robot you get a page that consists of two parts - a list of files containing AIML
defining the categories of the prize winning robot "A.L.I.C.E." - and a list of
properties which you may use to easily add content to your robot. The Edit Bot Properties
does not create any new AIML categories. The properties set the value of global constants
like <location/> and <favoritemovie/> that are referenced or otherwise used in
categories throughout the AIML knowledge base.
You can add a new bot property on this page, and within the template box modify it. As an
example, we can define a new property - weather, with an initial value of rainy. Template
responses can now refer to the value of weather using text like "the weather is
<bot name="weather"/>"
So many ways to write the same thing....
You can write a sentence with the same meaning in many different ways. Most people
would accept the following sentences as roughly equivalent:
Empty, can you please tell me if you are seeing anyone else right now
Empty, can you please tell me if you are seeing anyone else now
Empty, can you please tell me if you are seeing anyone else
Empty, please tell me if you are seeing anyone else
Empty, tell me if you are seeing anyone else
Empty, tell me are you seeing anyone else
Empty, are you seeing anyone else
Are you seeing anyone else
And this is an example of a general problem - how do you enter all the categories for
inputs with equivalent meanings? Or how do you answer these kinds of questions? No one has
provided a satisfactory mechanism for finding all the similar sentences. Here is what can
be done though. In this example we are going to use a new tag and introduce the
"_" character. Earlier we wrote that "*" matches any pattern.
"_" is another form of "*" and is useful for matching patterns at the
ends of sentences. The category containing " * now" will be matched after the
one containing " _ now".
Lets begin by adding two new categories so that Empty responds as follows:
You: Are you seeing anyone else?
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
You: You are seeing anyone else?
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
Then, adding the
<category>
<pattern>Empty *</pattern>
<template>
<srai><star/></srai>
</template>
</category>
Produces:
You: Empty, are you seeing
anyone else?
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
Adding:
<category>
<pattern>_ tell me *</pattern>
<template>
<srai><star/></srai>
</template>
</category>
Produces:
You: Empty, tell me are you seeing anyone else
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
Adding:
<category>
<pattern>_ tell me if *</pattern>
<template>
<srai><star/></srai>
</template>
</category>
Produces:
You: Empty, tell me if you are seeing anyone else
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
Adding:
<category>
<pattern>_ tell me if *</pattern>
<template>
<srai><star/></srai>
</template>
</category>
Produces:
You: Empty, tell me if you are seeing anyone else
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
Adding:
<category>
<pattern>_ now </pattern>
<template>
<srai><star/></srai>
</template>
</category>
<category>
<pattern>_ right now </pattern>
<template>
<srai><star/></srai>
</template>
</category>
With these categories we can now get the same answer to all the questions:
You: Empty, can you please tell me if you are
seeing anyone else right now
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
You: Empty, can you please tell me if you are seeing anyone else now
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
You: Empty, can you please tell me if you are seeing anyone else
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
You: Empty, please tell me if you are seeing anyone else
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
You: Empty, tell me if you are seeing anyone else
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
You: Empty, tell me are you seeing anyone else
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
You: Empty, are you seeing anyone else
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
So, what has happened here? We've simplified progressively more complex sentences into two
"standard" sentences: (Are you seeing anyone else? and You are seeing anyone
else?)
The general technique is called recursion - and it means applying the same solution - in
this example <srai><star/><srai> over and over again. Recursion is
useful for a variety of tasks. We will just mention a few here. More details can be found
in The Anatomy of Alice.
1. handling multiple sentences - the following exchange is generated with the categories
below. (Your robot can handle multiple sentences - and does it by responding to each one
in turn in separate output lines.)
You: Empty, are you seeing anyone else
Empty: Everyone I run into is either someone I've already seen or
someone I am going to see in the future
You: I see.
Empty: I am glad you see.
You: Why do you think you can get away with that?
Empty: Full disclosure is always best don't you
think?
<category>
<pattern> I see *</pattern>
<template> <srai> I see </srai>
<srai><star/></srai> </template>
</category>
<category>
<pattern> I see </pattern>
<template>I am glad you see</template>
</category>
<category>
<pattern> why do you think you can get away with that?
</pattern>
<template> Full disclosure is always best don't you
think?</template>
</category>
2. Spelling and Grammar corrections: Often we want to correct spelling errors or suggest
alternate forms of grammar - and here is one way to do it:
<category>
<pattern> your a wasting my time </pattern>
<template> you mean you are..? ...<srai>
you are <star/> </srai> </template
</category>
3. Sometimes we want the robot's response to be determined by just one word (a Keyword)
you've typed. Here is an example in which the keyword is "love":
<category>
<pattern> love </pattern><template> tell me more
about what you are seeking.</template>
</category>
<category>
<pattern> _ love </pattern><template><srai>love
</srai></template>
</category>
<category>
<pattern> love _ </pattern><template>
<srai>love </srai></template>
</category>
<category>
<pattern> _ love *</pattern><template>
<srai>love </srai></template>
</category>
The first category matches the single word input of love. The second and third categories
match a sentence ending in love and beginning in love respectively. The final category
matches a sentence in which the word love appears.
Footnote 0.
The options Standard AIML Sept 2001 and Dr Wallace's A.L.I.C.E march 2002 are two sets
of knowledge. The first is organized into separate files and easy to change -and is
suitable for experts. The second is the knowledge Dr. Wallace used to win the 2002 Loebner
prize.
Footnote 1.
Here are more details of the transformation. The inquiry "do you love me", is
transformed, removing any punctuation and converting it to upper case: "DO YOU LOVE
ME". So "do you LOVE me" and "DO YOU love me" are equivalent. For
multiple sentences, finding the sentences is the first part. The inquiry "Do you love
me dr.wallace? ms.mary said you might..." is transformed to "Do you love me
doctor wallace? ms marry said you might". Then each sentence is separately processed.
Apostrophes are removed from contractions so "I'm in love with you" is
transformed to "I am in love with you".
Japanese is written without spaces between the words. So spaces are first inserted. When
the bot has been set up to process Japanese and English, a sentence like "let's see
if you really do" is transformed to "let ' s see if you really do"
Footnote 2.
Words inside brackets < and > like "<random>" are called XML tags
and specify how the answer is to be processed. We've provided only a few such tags.
<li> specifies an element in a list - and this example has a list with 3 elements -
namely the three sentences. Each tag is expected to have a closing tag, typically
specified as in </random>. It sometimes happens that nothing falls between an
opening tag and a closing tag, and so the two tags can be replaced as in this example
<star> </star> = <star/> That is, the two tags on the right can be
replaced by the simpler tag on the left.
Footnote 3.
XML and AIML are programming languages. We implemented AIML (Artificial Intelligence
Markup Language) a non-standard evolving markup language for creating chat robots, created
and supported by the ALICE Foundation and located at www.alicebot.org. The primary design
feature of AIML is brevity and simplicity. The pattern matching language is very simple,
for example permitting only one wild-card ('*') match character per pattern. AIML is an
XML language, meaning that it obeys certain grammatical meta-rules. The choice of XML
syntax. permits integration with other tools such as XML editors.
Glossary
Input Pattern - The input sentence (or sentences) provided to the robot.
Template - an abbreviation for response template
Response Template - The Response Template is either a response or a program to generate a
response.
Category - An Input Pattern (including optional variants of <that> and
<topic>, along with a Response Template
Pattern Matching - A capability of matching input sentences against stored sentences
Knowledge Web (AKA Graph Master) - A representation of the categories in a Pandorabot
Ultimate Default Category - When the input sentence fails to match any category
Default Category - <topics> and <that> can each have a default category
Default Response Template - what is said when nothing is matched.
XML - a markup/programming language
AIML - a markup/programming language implementing knowledge content. AIML is a subset of
XML.
Appendix
Using Advanced Alter Response - the Details
The top 9 boxes contain information about the Category that an input sentence (pattern)
matched.
Input ... shows the input text (pattern) that the robot received
Matched ... shows the pattern (and Category) that matched the input pattern
Action ... shows the reply - the Response Template part of the matching Category.
<that> and <topic> parts of the matching Category are specified in the boxes
too.
New AIML... A pattern - you can either accept or revise it - in effect you are creating a
new category. Text in the first box is automatically surrounded by <pattern> and
</pattern> - so you need not enter them. You may also specify <topic> and
<that> parts of the category. Again the text is surrounded by the <that> and
<topic> aiml tags automatically.
Template ... The Template Response Box - specify the actions for a given Input Pattern.
The buttons <think>, <random>, etc save you from typing in the AIML.
Also, anything in this box is automatically surrounded by <template> and
</template>.
Seven editing buttons provide some shortcuts for writing the template:
<think>: inserts
<think>
<set name="it">
<set name="topic">
<person/>
</set>
</set>
</think>
in the template.
<random>: inserts an AIML template for a three random choices inserted between the
tags
<li> and </li>.
<random>
<li></li>
<li></li>
<li></li>
</random>
<img>: inserts <img src=""></img>
Put a pathname between the double quotes to provide a picture.
<sr/>: inserts <sr/> which is another
abbreviation for <srai><star/></srai>.
<srai>: inserts <srai> </srai>, and you insert text
between these tags.
Reduce: shortens the input sentence (pattern) one word, by removing the last word before
the wildcard. For example, YOU ARE VERY * reduces to <srai>YOU ARE
<star/></srai>. Use this to eliminate adverbs and other logically superfluous
words.
Clear: clears the template.
Exploring Categories
Under "botmaster control" you will find a link labeled "explore".
It is a rudimentary mechanism for exploring the categories that exist in a given knowledge
web. Use this link to find already existing categories that will be matched by input
patterns. The categories found are shown in their internal lisp-based form rather than the
xml-based form.
References
Artificial Intelligence Markup Language (AIML) Version 1.0.1
http://alicebot.org/TR/2001/WD-aiml/
AIML Pattern Matching Simplified - http://alicebot.org/documentation/matching.html
Don't Read Me - http://alicebot.org/articles/wallace/dont.html
AIML 1.0 Tag Sets (July 16, 2001)
http://www.alicebot.org/committees/architecture/resolutions/aiml10.html
AIML Primer - This document is a "work in progress" Last update: 9JAN2002
http://www.alicebot.org/documentation/aiml-primer.html
The Anatomy of ALICE - pending publication - available from Dr. Richard Wallace at
www.alicebot.org