Robert Zubek describes how his program takes advantage of the
tropes of breakup conversations. These generic norms allow The
Breakup Conversation to assess players' textual entries
categorically rather than semantically and thereby convincingly
simulates an IM-based interaction.
The Breakup Conversation is a satirical simulation of the conversation at the end of a romantic relationship. The player is expected to perform a breakup over instant messenger, while the computer, playing the role of the soon-to-be-ex, will attempt to guilt and emotionally manipulate the player to give in and fail to break up. The title is a Windows-executable program, available for download at robert.zubek.net.
The player begins the interaction by selecting some personal information for the simulated soon-to-be-ex, after which an instant messenger window opens. The interaction mimics standard IM chat - it happens in real time via typed natural English text and emoticons.
The system does not attempt strong semantic processing of the player's utterances. Rather, it works by categorizing the utterances as situation-sensitive "moves" in an interaction space, whose significance depends not just on the text of the utterance, but also on the current position in the space. This was a deliberate design choice - after all, in situations such as a breakup, the context becomes pregnant with meaning: whether you address or ignore the developing issues, how strongly and quickly you respond to accusations, whether and how you play along with blame and guilt maneuvers - these are the kinds of pragmatic effects that become particularly meaningful.
To manage the complexity of such a conversation, the interaction space is actually decomposed into a large collection of small protocols - some are responsible for general conversational skills, while others are directly relevant to the breakup situation. In particular, the engine includes knowledge of numerous "guilt games" that could take place during a breakup, and some ways of getting through them - for example, the "it's not you, it's me" ritual, the "why are you doing this to me" blame, the refusals to discuss issues, and other ways in which people panic, reason, plead, lay guilt, and so on. These rituals are treated informally, and meant to be exaggerated and entertaining, rather than psychologically felicitous - they were inspired by sitcoms, personal anecdotes, and popular self-help books on relationships.
Internally, the different components of the interaction are represented explicitly as small hidden Markov models, which are probabilistic finite-state representations, particularly good at estimating the state of the model from noisy and uncertain evidence information. The models are arranged in a tree-like control hierarchy, from general long-term models to specialized handlers: top-level elements influence the long-term development of the situation by enabling specialized situation controllers based on how the situation is going; those mid-level elements then drive the situation locally, by enabling and manipulating a number of specialized handlers, such as those responsible for very particular guilt-laying mini-games. The following presents a detail of the hierarchy:
Breakup Conversation excerpt
(Computer's utterances in boldface.)
Alice: hey there
Bob: how are you
Alice: not bad 🙂
Alice: and you?
Bob: what was that you said
Bob: that we should talk about the relationship?
Alice: yeah about that
Bob: what did i do
Bob: look why wouldn't you just talk to me
Alice: no it's not you
Bob: oh really? then what?
Bob: what does that even mean?
Alice: it's me
Bob: i know it's me
Bob: why wouldn't you just talk to me about what's going on
Alice: i was thinking about us
Bob: it's because i stay at home
Bob: you loathe that i'm lazy
Bob: don't you
Alice: no i don't loathe you
Bob: it's not because of that?
Bob: how can you do this to me
Bob: then what is it?
Alice: i don't know
Bob: i suppose i'm a naive loser
Alice: i'm feeling, well, like i'm suffocating
Bob: you're just messing with me
Alice: i need space
Bob: i can't believe that
Bob: you can't seriously be doing this
Bob: don't you love me?
Alice: i thought i did
Bob: but no longer?
Alice: i don't know
Bob: well then
Bob: do you hate me
Alice: you do things
Bob: do you despise me
Bob: did you really make up your mind?
In addition to the breakup-specific elements, the system also contains a number of more general models, responsible for broader conversational competence; these include handlers for general greetings and pleasantries, dealing with requests, opinions, and especially insults (since players seem to really enjoy insulting computer agents). The following is a list of the different elements of the system - first, general conversational elements shared among systems, second, elements specific to the Breakup Conversation, and third, elements used in Xenos the Innkeeper, a character for a fantasy game, also built using this technology.
Low level monitors:
Topic recognized but not the form
Question recognized but not topic
Question about object
Question about health
Allude to breakup
Giving in monitor
"You must hate me"
"Why are you mean"
"Will you help me"
"I thought you loved me"
"I thought you cared"
"I don't deserve this"
"How can you do this"
Beg for second chance
"But I love you"
Guess at reason
Treat as excuse
Perform quest injection
Deal with agreement
Deal with rejection
Rush the player
Barter for object
Even though arranged in a control hierarchy, all of the active elements run in parallel, at the same time, monitoring the conversation for some evidence of whether they should try to do something about the situation. In effect, each element tries to process every utterance, and they all get a chance at updating themselves and producing a response.
First, the utterance is roughly preprocessed, translated into a probability distribution over the space of communicative acts (e.g., what is the probability that the utterance was a request, an insult, a compliment, etc.), and quick pattern matching is performed to pull out likely role bindings for the acts.
Second, the evidence distribution is passed to each of the active elements, which update themselves based on the evidence distribution, model parameters, and last known state probabilities. Each model's state is calculated by matching what was observed against what was expected given the situation, for every state in every model; this separation of observation and expectation simplified the task of knowledge representation, and improved the system's robustness.
Finally, all elements can propose responses, out of which one is selected and sent to the output production layer.
The resulting system is, at heart, a collection of numerous finite-state models, arranged in a control hierarchy but running in parallel. Each of them is only competent at a small fragment of the interaction, but their aggregate and overlapping engagement result in a fluid overall interaction. The system works without being able to understand much language - but it is able to recognize the kinds of speech acts and utterance types it cares about, and match them against its multi-faceted representation of the evolving situation.
Zubek, Robert. (2005). "Hierarchical Parallel Markov Models for Interactive Social Agents." Ph.D. Dissertation, Computer Science Department, Northwestern University.
---. (2004). "Character Participation in Social Interaction." Challenges in Game AI Workshop, AAAI-04. (AAAI Technical Report WS-04-04.).