On <em>The Breakup Conversation</em>

On The Breakup Conversation

2008-02-21

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: :P

Alice: look

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: :(

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.

Shared Spaces

Low level monitors:

Conversation timer

Silence monitor

Monologue monitor

Ambient movement:

Fidget machine

Turn enforcement

Ambient emote

Stock response

Turn monitor

Topic monitor

Insult management:

Direct insult

Indirect insult

Insult accumulation

General routines:

Topic recognized but not the form

Question recognized but not topic

Question about object

Question about health

Request general

Request item

Disagreement

Player evaluation

Agent evaluation

Condemnation monitor

Conversation structure:

Greeting

Intro conversation

Outro conversation

Breakup Specific

Breakup intro:

Allude to breakup

Giving in monitor

Guilting coordinator

Guilting: Self-pity

Self-criticize

Reject compliment

“You must hate me”

“Why are you mean”

“Will you help me”

Guilting: Indignation

“I thought you loved me”

“I thought you cared”

“I don’t deserve this”

“How can you do this”

Guilting: Pleading

Beg for second chance

Promise change

“But I love you”

Guilting: Reasoning

Guess at reason

Demand reason

Evaluate reason

Treat as excuse

Deny reason

Panicking:

Silence

Impatience monitor

Resignation monitor

Rejection monitor

Start panic

Xenos Specific

Quests:

Quest monitor

Perform quest injection

Deal with agreement

Deal with rejection

Rush the player

Special routines:

Job request

What question

Where question

Payment question

Evaluate object

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.

References

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.).