HAMLET: Human-Machine Co-Learning

• HAMLET is an interpretable human and machine co-learning technique that integrates neural embeddings, memory modules, and classification layers to refine noisy labels in complex datasets.
• It employs a multi-stage process including confidence assessment, exemplar-based feedback, and iterative relabeling to boost both machine accuracy and human annotation consistency.
• Benchmarks in ICU cEEG labeling show significant performance gains with expert-guided corrections, raising accuracy from ~7% to over 40% in challenging diagnostic tasks.

HAMLET is a general acronym used by multiple research groups to name highly technical frameworks in domains spanning interpretable co-learning, multimodal attention, Bayesian cosmography, domain adaptation, and neural-operator modeling. The following article focuses on the "Interpretable Human And Machine co-LEarning Technique" HAMLET framework as introduced in "HAMLET: Interpretable Human And Machine co-LEarning Technique" (Deiss et al., 2018).

1. Problem Motivation and Conceptual Rationale

HAMLET addresses the persistent challenge of robust supervised classifier training in domains where explicit label acquisition is expensive and the ground-truth itself is noisy or contested (e.g., continuous EEG monitoring in the ICU). Expert annotators often disagree on ambiguous samples near class boundaries, which leads to structural labeling noise and low inter-rater reliability. Previous active learning protocols presuppose infallible human oracles; in practice, this assumption is untenable for complex tasks, especially in biomedical signal labeling.

HAMLET was created with three interlocking objectives:

• To improve machine classifier reliability by systematically identifying and suggesting corrections for low-confidence or likely-mislabeled training examples.
• To iteratively enhance the consistency and accuracy of human annotators via explainable, exemplar-based feedback.
• To close the human–machine learning loop, driving mutual improvement through expert-guided re-labeling informed by interpretable model outputs.

2. Architecture and Principal Components

HAMLET consists of three main architectural modules:

2.1 Neural Embedding Function ($f$)

• Input: A pre-processed data segment (e.g., a 16 s window of 16 bipolar EEG montages).
• Output: $e = f(x) \in \mathbb{R}^d$, a $d$-dimensional embedding.
• Variants:
  • Supervised CNN: Temporal CNN with depthwise separable convolutions, batch-norm, ELU, max-pooling, dropout. The final dense layer is discarded for embedding extraction.
  • Unsupervised CAE: Symmetric convolutional auto-encoder. Embeddings are extracted from the encoder after training on unlabeled data.

2.2 Memory Module ($M$)

• Construction: $M = \{ r_j \in \mathbb{R}^d : j=1\ldots N \}$. Reference embeddings are obtained by applying $k$-means clustering to $f(x)$ over each class, ensuring class-balance ($N_c \approx N / |C|$).
• Retrieval: For given input $x$, compute $s_j = \frac{e \cdot r_j}{\|e\| \|r_j\|}$ for $j=1\ldots N$. Similarity vector $s(x) = [s_1, \ldots, s_N]^\top$ is concatenated to $e$ for downstream classification.

2.3 Classification Layer ($g$)

• Input: $[e; s] \in \mathbb{R}^{d+N}$.
• Architecture: Multilayer perceptron (typically 1024 ELU units, dropout), ending in softmax across $C$ classes.
• Output: $p(y|x) \in \Delta^{C-1}$, class probabilities.

3. Formalization, Training Objectives, and Memory Update

• Embedding Map: $f : X \rightarrow \mathbb{R}^d$.
• Classifier: $p(y = c | x) = \mathrm{softmax}_c(g([e; s(x)]))$.
• Losses:
  • Classification loss: $$L_{\text{cls}} = - \sum_{i=1}^m \sum_{c=1}^C \mathbb{1}[y_i = c] \log p(y = c | x_i)$$.
  • Human–machine agreement (co-learning regularizer): $$L_{\text{co}} = \sum_{i=1}^m \| p(\cdot | x_i) - h_i \|^2$$, where $h_i$ is the expert input (one-hot or soft label).
  • Combined objective: $$L_{\text{total}} = L_{\text{cls}} + \lambda L_{\text{co}}$$.
• Memory Update Rule: After each iteration, recompute all embeddings using the latest $f$, re-run $k$-means within each class for the reference set, and optionally replace low-utility references.

4. Iterative Co-Learning Workflow

HAMLET operates an iterative feedback loop:

1. Training: Classifier $g$ is optimized on the current labeled set $D_t$ (and possibly $U$, unlabeled/weakly labeled).
2. Confidence Assessment: For each sample, calculate confidence ($c(x)$), margin ($m(x)$), and entropy ($e(x)$).
3. Error Selection: Identify high-confidence misclassifications or low-entropy uncertain samples.
4. Expert Feedback: Present selected $x$ to human annotators alongside top-$k$ reference exemplars (highest $s_j$, class-matched), visualizing both candidate and reference waveforms.
5. Relabeling: Expert revises labels as appropriate; new dataset $D_{t+1}$ is created.
6. Model Update: Embedding and memory are refreshed, and the process repeats.

Pseudocode:

for t in range(T): train g on [e; s] using L_total for x in D_t ∪ U: compute p(y|x), confidence, margin, entropy select K misclassified or uncertain samples for each x: show x and top-k reference r_j to expert expert relabels x update D_{t+1} fine-tune f, reselect M_{t+1}

5. Interpretability via Reference Embeddings

HAMLET enhances classifier explainability by coupling predictions with concrete exemplars:

• Similarity retrieval: For test input $x$ assigned class $c^*$, retrieve $$r^* = \arg\max_{r_j:\text{label}(r_j)=c^*} \cos(f(x), r_j)$$.
• Visualization: Display $x$ and $r^*$ side by side. This facilitates expert understanding of the classifier's rationale, grounding decisions in example-based similarity.

Interpretability scores from clinical review (top-16 references matching each class):

Class	LRDA	GRDA	LPD	Seizure	GPD
Match %	75	68.75	62.5	37.5	25

Experts confirmed that this approach aids faster, reproducible relabeling.

6. Case Study: cEEG Labeling and Performance Comparison

In a challenging application to ICU cEEG, HAMLET was benchmarked as follows:

• Data: 155 patient EEGs, five event classes (Seizure, LPD, GPD, GRDA, LRDA), 390k windows, heavily imbalanced and noisy labels.
• Baseline accuracy: Unseen test windows: HAMLET-CNN 39.36%, HAMLET-CAE 38.46%, plain CNN 38.89%, MLP 21.04%.
• Co-learning impact: Expert relabeling of 837 windows (~4.2%) raised subset accuracy from 7.03% to 68.75% (HAMLET-CNN) and overall test accuracy to ~40.75%. Confusion matrix analysis showed improved LRDA/LPD discrimination.

7. Advantages, Limitations, and Extensions

Benefits:

• Substantially improved label quality via model-guided expert corrections.
• Elevation of both classifier accuracy and human consistency through co-learning.
• Exemplars in memory underpin interpretability and assist in expert retraining.

Limitations:

• Requires human expert input at each iteration, incurring cost.
• Memory selection via $k$-means is an offline process and may lack adaptability.
• Unsupervised variant (HAMLET-CAE) offers lower interpretability.

Potential Extensions:

• Dynamic memory updates (least-used or error-driven policies).
• End-to-end memory differentiability.
• Application to other high-noise human annotation domains.
• Incorporation of richer feedback (textual, bounding-box, etc.).

8. Summary and Research Significance

HAMLET implements an end-to-end human–machine co-learning workflow where deep neural models and domain experts iteratively refine both classifier and label reliability. Machine guidance identifies human errors, interpretable reference embeddings validate suggestions, and expert relabeling improves ground truth. Empirical evidence supports significant accuracy gains and enhanced interpretability in complex, error-prone annotation regimes (Deiss et al., 2018). The framework is extensible to other domains characterized by noisy human annotation.