Modeling Audience Group Behavior

Nuria Oliver and Stephen Intille, MIT Media Lab

MIT Media Lab class project, Spring 1996.

Overview

We built a system that models audience behavior with multiple communicating agents. Each agent is a simple model of a person in a grid-like auditorium who listens for clapping or whistling from nearby agents and responds according to assigned rules. We wanted to see whether a simulation could begin chaotically and settle into a shared pattern, such as a synchronized rhythm, without central control. The agents communicate only through the environment by observing what their neighbors have done in the recent past.

Our starting point was a class discussion about involving several thousand people in a graduation speech: instructions placed under seats might let a real crowd turn an initially chaotic response into a coordinated one.

Agent types

Each simulation uses up to ten agent types, each defined by four parameters:

• Action type: The behavior the agent can perform (clap, whistle, or do nothing).
• Listen type: The type(s) of behavior the agent perceives (e.g., clapping only, or both clapping and whistling).
• Desired frequency: The agent's target action rate relative to perceived neighbor frequency (e.g., whistle every four claps heard).
• Connection type: The size of the neighborhood the agent listens to: a configurable grid centered on the agent's position.

Each agent type is also assigned a percentage of the total audience and a display color that flashes when the agent is active.

System

We made a Tcl/Tk interface for setting the seating grid, number of agent types, and simulation parameters. Once the agents are created, their assigned colors flash in the seating grid as the simulation runs.

Agent configuration interface.

Temporal perception

We gave each agent access to the last sixteen time steps so it could estimate the frequency of its neighbors' actions. It identifies the two time steps with the most observed activity and treats the interval between them as the current frequency. This was a simple majority-rule approximation of how people synchronize.

Simulation results

In our simulations, we observed:

• Independent groups: Two groups that do not listen to each other each converge rapidly within their own group but not across groups.
• Inter-related groups, same frequency: Groups listening to each other with the same target frequency converge so that all agents act simultaneously.
• Inter-related groups, different frequencies: Convergence depends on the specific listening relationships. Some configurations converge naturally; others cannot, due to cyclic dependencies.

Key factors affecting convergence:

• Neighborhood size: Larger neighborhoods produce faster convergence. Real audiences converge quickly because people can attend to a wide area.
• Agent distribution: High percentages of converging agent types produce large synchronized clusters, with boundary agents oscillating between two non-converging groups.
• Isolated agents: Agents with no neighbors of the listened-for type remain inactive throughout.

Scope and possible extensions

These findings came from simulated agents, not a study with a real audience. The local, uniformly weighted neighborhoods were also a computational simplification: people in an auditorium can hear distant participants, and distance, tone, and loudness affect whom they attend to.

At the time, we saw several possible extensions:

• More realistic perception models (e.g., distance-weighted listening, loudness effects).
• Real audio output to produce musical behaviors alongside visual ones.
• Alternative temporal frequency detection policies.
• A parallel implementation to support much larger, more realistic simulations.
• Testing a working model with a real audience.

Technical details

We implemented the system in C++ and Tcl/Tk and compiled it on an SGI Indy workstation.