Traditional natural language processing often treats events like a simple grocery list: first you do A, then B, then C. However, real-world activities—from the mundane steps of a recipe to the complex unfolding of a geopolitical crisis—rarely follow a single, straight line. They branch, overlap, and occur in parallel. Recent research is shifting away from these rigid linear chains toward graph-based event schemas that capture the inherent non-linearity of human activity.
The Linear Limitation
Most sequence models assume a strict chronological order. As Mehdi Rezaee and Francis Ferraro argue in Event Representation with Sequential, Semi-Supervised Discrete Variables, this ignores the "branching paths" of real-world scripts. If you are modeling a story, a character might choose one of three different actions; a linear model struggles to represent these alternatives simultaneously.
Similarly, Abhilasha Sancheti and Rachel Rudinger found that even powerful Large Language Models (LLMs) struggle with "script knowledge"—the "boring" intermediate steps of everyday tasks. In What do Large Language Models Learn about Scripts?, they demonstrate that standard sequential modeling fails to account for overlapping events or optional steps, which are better represented as a flexible flow rather than a fixed list.
From Chains to Graphs
To capture this complexity, researchers are moving toward graph-based representations. A graph allows a model to represent concurrency (two things happening at once) and conditional logic (if X happens, then Y follows; otherwise, Z).
In the RESIN-11 framework, Heng Ji, Carl Vondrick, and their colleagues propose a "graph-to-graph matching" approach. By treating a scenario like a disease outbreak as a structured blueprint (a schema), the system can match noisy, multi-modal data (news clips, tweets, reports) to a complex graph of events. This allows the model to "fill in the blanks" for missing information that a linear model would simply skip.
Capturing Hierarchy and Flesh
A key intuition in this field is that events have a "skeleton" and "flesh." A high-level event (like "Buying a House") has a structural skeleton of steps, while the specific entities involved (the buyer, the agent, the bank) provide the flesh.
Manling Li and Heng Ji formalized this in Event Schema Induction with Double Graph Autoencoders. Their DoubleGAE model uses two hierarchical graph autoencoders:
- One to learn the event-to-event transitions (the skeleton).
- One to learn the entity-to-entity relations (the flesh).
By separating these layers but training them together, the model captures global dependencies that linear models miss, such as how a specific participant's role in step one constrains what can happen in step five.
Discovering Interpretable Flows
While neural networks are excellent at finding patterns, they are often "black boxes." In industrial or manufacturing contexts, we need to know why a sequence is predicted. Boris Wiegand and Jilles Vreeken addressed this with CONSEQUENCE, an algorithm that uses the Minimum Description Length (MDL) principle to discover "event-flow graphs."
Instead of just predicting the next token, CONSEQUENCE identifies the simplest possible graph that explains the observed data. This results in "white-box" models that are human-readable and can explicitly show parallel execution paths—essential for understanding complex systems where multiple processes run at the same time.
Summary of the Shift
The transition from linear sequences to graph-based schemas represents a fundamental change in how AI understands "what happens next." By prioritizing structural flexibility, these models can finally mirror the non-linear, hierarchical, and concurrent nature of the real world.