---
title: 'InitERC: One-Stage Emotion Recognition'
url: https://www.emergentmind.com/topics/initerc
type: topic
---

# InitERC: One-Stage Emotion Recognition

Searching arXiv for the cited InitERC paper and closely related ERC instruction-tuning work.
InitERC is a one-stage in-context instruction tuning framework for emotion recognition in conversation (ERC) that adapts large language models (LLMs) to learn speaker–context–emotion alignment from context examples via in-context instruction tuning [2508.11889]. The framework is motivated by a limitation identified in existing multi-stage ERC methods: approaches such as InstructERC and LaERC-S first tune an LLM to “know” speaker characteristics and then conduct context-aware instruction tuning, a pipelined design that breaks the natural coupling between speaker traits and evolving dialogue context, constrains the model’s capacity to jointly learn how a given speaker’s personal style interacts with the immediate conversational flow, and leads to suboptimal alignment among speaker identity, context cues, and emotion labels [2508.11889]. InitERC addresses this by using a single, unified tuning stage in which the model simultaneously sees examples that bundle “who spoke,” “what was said before,” and “how it was labeled emotionally,” thereby allowing the LLM to internalize speaker–context–emotion patterns end to end [2508.11889].

## 1. Conceptual motivation and problem setting

Emotion recognition in conversation aims to identify the emotion of each utterance in a conversation and is framed in InitERC as a setting where speaker identity, conversational history, and emotion labeling must be modeled jointly rather than sequentially [2508.11889]. The central claim of the framework is that multi-stage instruction tuning inherently constrains joint modeling because speaker characteristics and contextual cues are learned in separate phases, whereas a one-stage design can expose the model to their interaction during the same optimization process [2508.11889].

Within this formulation, each utterance is treated as an instance whose emotion depends not only on its lexical content but also on the speaker-tagged dialogue prefix. This suggests that the framework is designed to make the supervision signal structurally closer to the downstream inference scenario: the model is trained and queried through prompts that already combine history, speaker tags, and labels in a single context window [2508.11889].

InitERC is explicitly defined as comprising four main components: demonstration pool construction, in-context example selection, prompt template design, and in-context instruction tuning [2508.11889]. These components collectively instantiate the one-stage paradigm and determine how examples are represented, retrieved, formatted, and used for parameter adaptation.

## 2. Formal representation and demonstration pool construction

The framework begins from a training set of conversations in which each utterance $u_i$ is represented as a triple $(c_i, x_i, y_i)$ [2508.11889]. In this representation, $c_i = [(s_{u_1}, u_1), \ldots, (s_{u_{i-1}}, u_{i-1})]$ is the speaker-tagged conversational history, $x_i = (s_{u_i}, u_i)$ indicates “who said what” at the current turn, and $y_i \in \{e_1,\ldots,e_M\}$ is the gold emotion label [2508.11889]. This formalization is central because it ensures that both dialogue context and speaker cues are embedded directly in each candidate demonstration.

All such triples are collected into a demonstration pool $P = \{(c_i, x_i, y_i)\}_{i=1}^K$ [2508.11889]. The paper states that each candidate example is guaranteed to carry both context and speaker cues, which distinguishes the pool from simpler retrieval corpora built only from isolated utterances or label annotations [2508.11889]. In practical terms, the demonstration pool functions as the memory from which in-context examples are drawn for both training and testing prompts.

A plausible implication is that demonstration pool design determines the granularity of inductive bias available to the LLM: because every item contains the speaker-tagged history and the current turn, retrieved examples can encode not merely semantic similarity but also interactional patterns that align speakers, preceding utterances, and target emotions. That interpretation is consistent with the paper’s emphasis on “speaker-context-emotion alignment” [2508.11889].

## 3. Retrieval, prompt construction, and in-context supervision

For a test turn $(c_t, x_t)$, InitERC retrieves the top-$k$ most relevant examples $P^e$ from the demonstration pool using an off-the-shelf dual-encoder retriever, Contriever-MS MARCO [2508.11889]. The retrieval rule is given as
$$
P^e = \mathrm{Retriever}(c_t \oplus x_t, P),
$$
where similarity is computed by dot product of normalized embeddings,
$$
\mathrm{sim}(q,d) = h_q^\top \cdot h_d.
$$
To avoid label leakage, any example from $P$ that comes from the same dialogue as the query is excluded, and emotion labels $y_i$ are inserted only after retrieval [2508.11889].

The final prompt fed to the LLM has three parts: a task description $\mathcal{T}$, a sequence of in-context examples $\mathcal{E} = [\mathrm{Example}_1; \ldots; \mathrm{Example}_k]$, and the target input $\mathcal{I}(u_t)$ [2508.11889]. The task description is specified as “You are an expert in emotion recognition … Output exactly one of {Candidate labels}.” Each example is formatted as
- `[History]` $c_i$
- `[Utterance]` $(s_{u_i}, u_i)$
- `[Label]` $y_i$

The examples are ordered in similarity-descending order, denoted “similar-first” [2508.11889]. The target input is formatted as
- `[History]` $c_t$
- `[Utterance]` $x_t$
- `[Label]`

where the model is expected to fill in the label [2508.11889]. The complete prompt therefore has the structure
$\mathcal{T}$, then “Here are some examples:”, then $\mathcal{E}$, then “Now classify:”, followed by $\mathcal{I}(u_t)$ [2508.11889].

This design is significant because the prompt does not separate instruction, demonstration, and prediction into independent subsystems; instead, it exposes the model to a single serialized object in which speaker tags, context, and labels are interleaved. The paper argues that this forces the LLM to learn how these three information sources jointly predict emotion in one pass [2508.11889].

## 4. Optimization objective and model adaptation

InitERC fine-tunes all or part of the LLM parameters $\theta$ using LoRA adapters and minimizes the negative log-likelihood of the correct label $y_t$ at each position [2508.11889]. The training objective is
$$
L(\theta) = - \sum_{(u_t, y_t)\in\mathcal{D}} \log p_\theta \big( y_t \mid \mathcal{T}, \mathcal{E}, \mathcal{I}(u_t) \big).
$$
This objective directly conditions label prediction on the task description, retrieved demonstrations, and target conversational instance, rather than on a separately learned speaker model or context model [2508.11889].

The paper’s explanation of why this matters is explicit: because each prompt already interleaves speaker tags, context, and demonstration labels, the LLM is forced in a single learning pass to internalize how these three kinds of information jointly predict emotion [2508.11889]. The framework therefore treats in-context examples not as an inference-only heuristic but as part of the supervised fine-tuning signal.

This suggests that InitERC occupies a hybrid position between standard instruction tuning and retrieval-augmented prompting. The retrieval component selects demonstrations, but the training objective updates the model parameters under those retrieved contexts, making the demonstrations a component of the adaptation process rather than only a test-time scaffold [2508.11889].

## 5. Empirical evaluation and benchmark results

The experimental study uses three widely used datasets: IEMOCAP, MELD, and EmoryNLP [2508.11889]. IEMOCAP contains 153 dyadic, acted dialogues, 7,433 utterances, and 6 emotions; MELD contains 1,433 multi-party dialogues from *Friends*, 13,708 utterances, and 7 emotions; EmoryNLP contains 897 scenes, 12,606 utterances, and 7 emotions [2508.11889]. The evaluation metric is weighted-F1,
$$
\mathrm{w\text{-}F1} = \frac{1}{N} \sum_{i=1}^M n_i \cdot F1_i,
$$
where $n_i$ is the number of true instances in class $i$ and $N = \sum n_i$ [2508.11889].

The baseline set includes conventional ERC methods—HiTrans, DialogXL, SKAIG, DAG-ERC, DualGATs, SPCL+CL, and BERT-ERC—as well as LLM-based methods—ChatGPT (3-shot), InstructERC, BiosERC, and LaERC-S [2508.11889]. The paper reports that ChatGPT without fine-tuning lags behind conventional methods, which it uses to highlight the need for specialized instruction tuning [2508.11889].

| Dataset | LaERC-S | InitERC (LLaMA2-7B) | InitERC (8B) |
|---|---:|---:|---:|
| IEMOCAP | 72.40 | 80.50 | 92.65 (+20.25) |
| MELD | 69.27 | 76.66 | 78.71 (+9.44) |
| EmoryNLP | 42.08 | 55.11 | 56.50 (+14.42) |

On all three datasets, InitERC with LLaMA3.1-8B-Instruct is reported to achieve 92.65 w-F1 on IEMOCAP, 78.71 on MELD, and 56.50 on EmoryNLP, outperforming the two-stage LaERC-S baseline by margins of +20.25, +9.44, and +14.42 respectively [2508.11889]. The paper characterizes these as substantial improvements over state-of-the-art baselines and attributes them to the one-stage alignment of speaker identity, dialogue context, and emotion labels [2508.11889].

## 6. In-context example study

A dedicated study examines three factors affecting in-context learning: retrieval strategy, example ordering, and the number of examples [2508.11889]. All experiments in this part use LLaMA3.1-8B-Instruct, $k=5$ unless otherwise stated, and evaluation on IEMOCAP, MELD, and EmoryNLP [2508.11889].

For retrieval strategy, the compared methods are Random, BM25, SBERT, and Contriever [2508.11889]. The reported w-F1 values are:
- IEMOCAP: Random 92.25; BM25 90.52; SBERT 88.74; Contra 92.65
- MELD: 69.24; 76.41; 75.27; 78.71
- EmoryNLP: 52.09; 56.22; 53.72; 56.50

The paper concludes that the dense retriever, Contriever, yields the best performance and notes that designing or jointly training the retriever is a valuable next step [2508.11889]. This is one of the clearest empirical indications that retrieval quality materially affects ERC performance in the InitERC setup.

For example ordering, three orders are tested: Similar-First, Similar-Last, and Random [2508.11889]. Across all three datasets, the differences are within $\pm 0.3$ w-F1, leading to the conclusion that InitERC is robust to example ordering and that simple “most-similar first” suffices [2508.11889]. This is notable because prompt-order sensitivity is often a concern in in-context learning, yet the reported effect here is small.

For the number of examples $k$, the study varies $k$ from 1 to 6 [2508.11889]. Performance grows rapidly from $k=1$ to $k=4$, then plateaus, and the paper recommends $k \approx 4$–$5$ as a good trade-off between compute and accuracy [2508.11889]. A plausible implication is that retrieval utility saturates once enough demonstrations have been provided to anchor the local speaker–context–emotion pattern, after which extra examples add little information relative to their computational cost.

## 7. Interpretation, limitations, and research directions

The paper’s primary interpretation of InitERC’s gains is that one-stage tuning with in-context examples forces the model to view speaker identity, dialogue history, and emotion labels as a single prediction problem rather than decomposing them into separate stages [2508.11889]. It further argues that in-context demonstrations explicitly ground the LLM in realistic speaker-context–emotion patterns and that dense retrieval ensures the examples most relevant to the current turn are shown, thereby sharpening the model’s inductive biases [2508.11889].

Several limitations are stated directly. InitERC incurs retrieval cost and relies on a static demonstration pool; future work could explore dynamic, jointly-trained retrievers [2508.11889]. All experiments are in English, so extending the framework to multilingual ERC or code-mixed dialogues remains an open challenge [2508.11889]. The current model uses text only, and the paper identifies integration of multimodal cues such as audio and video into the pool and prompts as a potential extension [2508.11889]. It also notes that statistical significance testing, for example paired bootstrap, on the large margins observed would strengthen claims of robustness [2508.11889].

A common misconception would be to treat InitERC merely as an alternative prompt format. The methodological description indicates a broader claim: InitERC is a full training framework in which retrieval, prompt design, and LoRA-based instruction tuning are coupled through a single supervised objective [2508.11889]. Another possible misunderstanding is that the framework depends critically on intricate prompt ordering; the reported ablation suggests instead that ordering effects are minor within the tested range, while retrieval strategy and example count are more consequential [2508.11889].

In the ERC literature described by the paper, InitERC occupies the position of a one-stage alternative to multi-stage LLM adaptation pipelines. Its defining contribution is the unification of speaker information, dialogue context, and emotion supervision within a single in-context instruction tuning procedure, with benchmark evidence on IEMOCAP, MELD, and EmoryNLP supporting the claim that this tighter alignment improves weighted-F1 relative to the reported baselines [2508.11889].

Source: https://www.emergentmind.com/topics/initerc