---
abstract: 'Recognizing when people have false beliefs is crucial for understanding their actions.  We introduce the novel problem of identifying when people in abstract scenes have incorrect beliefs.  We present a dataset of scenes, each visually depicting an 8-frame story in which a character has a mistaken belief.  We then create a representation of characters’ beliefs for two tasks in human action understanding: predicting who is mistaken, and when they are mistaken.  Experiments suggest that our method for identifying mistaken characters performs better on these tasks than simple baselines.  Diagnostics on our model suggest it learns important cues for recognizing mistaken beliefs, such as gaze.  We believe models of people’s beliefs will have many applications in action understanding, robotics, and healthcare.' 
author:
- |
    Benjamin Eysenbach\
    MIT\
    [bce@mit.edu]{}
- |
    Carl Vondrick\
    MIT\
    [vondrick@mit.edu]{}
- |
    Antonio Torralba\
    MIT\
    [torralba@csail.mit.edu]{}
bibliography:
- 'egbib.bib'
title: 'Who is Mistaken?' 
---

(0,0) (0,-430)

![ image](teaser_small.pdf){width="\linewidth"} \[fig:teaser\]

Introduction
============

In Figure \[fig:teaser\], one person has a mistaken belief about their environment.  Can you figure out who is mistaken?  You likely can tell the woman is about to sit down because she incorrectly believes the chair is there.  Although you can see the complete scene, the character inside the scene has an imperfect view of the world, causing an incorrect belief. 

![ image](dataset_small.pdf){width="\textwidth"}

\[fig:grid\]

The ability to recognize when people have incorrect beliefs will enable several key applications in computer vision, such as in action understanding, robotics, and healthcare.  For example, understanding beliefs of human drivers could improve the safety of autonomous vehicles [@sadigh2016information].  Robots that understand human beliefs may have more fluid interactions with humans [@koppula2013learning].  Understanding beliefs may provide clues for anticipating human actions [@kitani2012activity; @vondrickanticipating] and generate better visual humor [@humor].  How do we give machines the capability to understand what a person believes? 

In this paper, we introduce the novel problem of recognizing incorrect beliefs in short visual stories.  We propose two new tasks aimed at understanding which people have false beliefs.  Given a visual story, we aim to recognize **who** is mistaken and **when** they are mistaken.  For example, in Figure \[fig:teaser\], the woman is mistaken in the third frame. 

To study this problem, we present a dataset of abstract scenes [@zitnick2013bringing] that depict visual stories of people in various types of everyday situations.  In each story, one or more people have mistaken beliefs, and we seek to recognize these people.  Abstract scenes are ideal for studying this problem because we can economically create large datasets that focus on the human activities, such as ones influenced by people’s beliefs.  Moreover, while abstract scenes are synthetic, the data models behavior on a high-level and can be applied to natural images with domain adaptation.  The scenarios in our dataset are diverse and characters are mistaken for many reasons, such as occlusion or unexpected actions. 

We investigate models for learning to recognize mistaken characters in short sequences.  Our model uses person-centric representations of scenes and combines information across several timesteps to better recognize mistaken characters.  Experiments show that our model learns to mistaken people beliefs better than baselines, suggesting that it is possible to make progress on inferring people’s beliefs.  Although we only train our model to predict mistaken beliefs, experiments suggest that it internally learns important cues for beliefs, such as human gaze or time’s arrow. 

The first contribution of this paper is introducing two new computer vision tasks for recognizing beliefs in images.  The second contribution is a new dataset for training and evaluating models for recognizing beliefs.  The third contribution is a model for starting to tackle these belief tasks.  Code, data, and models will be available at . 

Related Work {#sec:related-work}
============

**Beliefs and Intentions:** Our paper builds off several works that study beliefs of people.  Shepherd [@psych-gaze] studies humans’ *theory of mind*, their reasoning about beliefs of others.  He notes that gaze-following is important for this reasoning and failing to solve this problem may indicate a disability.  Scassellati [@scassellati2002theory] studies theory of mind in human-robot interaction.  Xie et al.  [@xie2013inferring] explore people’s intentions in real-world surveillance footage.  Baker et al.  [@bayesian-tom] propose a Bayesian model for learning beliefs based on a POMDP.  Zhao et al.  [@tom-hri] propose using probabilistic programming to infer the beliefs and desires of people in RGBD videos.  We focus on learning the beliefs of characters directly from visual scenes. 

[0.28]{} ![ image](character_name.png){width="85.00000%"}

 

[0.11]{} ![ image](character_expression.png){width="85.00000%"}

 

[0.23]{} ![ image](time_hist.png){width="90.00000%"}

 

[0.33]{} ![ image](location_hist.png){width="90.00000%"}

**Common Sense:** Our work complements efforts to learn common sense.  Yatskar et al.  [@yatskarstating] extract common sense from object detection corpora, while Chen et al.  [@chen2013neil] learn visual common sense by browsing the Internet.  Vedantam et al.  [@abstract-commonsense] use abstract images to learn how people, animals and objects are likely to interact.  Recent work [@block-towers; @galileo; @pinto2016curious] has learned physical common sense given videos of colliding objects.  Finally, Alahi et al.  [@alahisocial] explore understanding social interactions in crowded spaces, and Prabhakar et al.  [@prabhakar2010temporal] study causality in unconstrained video to understand social games.  In this work, we study the subset of common sense related to visual beliefs. 

**Activity Understanding:** Our work is related to activity understanding in vision [@caba2015activitynet; @wang2011action; @chao2015hico; @pirsiavash2012detecting; @fathi2012learning].  Systems for understanding human actions typically leverage a variety of cues, such as context, pose, or gaze [@recasens2015they].  Our work complements action understanding in two ways.  First, we study visual beliefs, which may be a useful signal for better understanding people’s activities.  Second, recognizing visual beliefs often requires an understanding of people’s actions. 

**Abstract Images:** We take advantage of abstract images pioneered by Zitnick et al.  [@zitnick2013bringing], which have received wide interest in computer vision for studying high-level vision tasks.  Chandrasekaran et al.  [@humor] use abstract images to detect visual humor.  Zhang et al.  [@zhang2015yin] explore binary question-answering in abstract scenes, and Fouhey et al.  [@fouhey2014predicting] learn to predict object dynamics in clip art.  While these approaches reason about image-level features and semantics, our approach looks at character-level features.  Importantly, two characters in the same scene can have different beliefs about the world, so each character should have a different character-level feature.  Additionally, we extend this previous work to multi-frame scenes depicting visual stories. 

**Transfer:** After we learn to recognize mistaken characters in abstract scenes, one could use domain adaptation [@fouhey2014predicting; @castrejon2016learning] to apply our approach to natural images.  However, this is orthogonal to the goal of this paper.  Additionally, Ganin et al.  [@ganin2014unsupervised] and Tzeng et al.  [@tzeng2015simultaneous] show how to perform unsupervised domain adaptation, which is relevant to our setting because annotating natural videos is costly. 

Dataset {#sec:dataset}
=======

We collected a dataset of abstract scenes to study beliefs of characters.  Each scene in our dataset consists of a sequence of $8$ frames showing an everyday situation.  One or more people believe something incorrectly about their environment in each scene.  A person may have a false belief for many reasons, including occlusion and misinterpreting intentions.  Although the characters inside the scenes do not know if they are mistaken, we designed the dataset so that third-party viewers can clearly recognize who is mistaken. 

Our dataset complements existing abstract scene datasets.  In contrast to the VQA dataset [@vqa], frames in our dataset are grouped into scenes telling stories over several timesteps, and characters in our dataset frequently have mistaken beliefs. 

We believe abstract scenes provide a good benchmark for studying visual beliefs.  We originally tried to collect a dataset of real videos containing people with false beliefs (such as suspense movies), but we encountered significant difficulty scaling up dataset collection.  While many real videos contain characters with mistaken beliefs, these beliefs are very complex.  This complexity made large-scale annotation expensive.  We believe abstract scenes are suitable for understanding visual beliefs today because they allow the field to gradually scale up complexity on this important problem.  To recognize mistaken beliefs in real videos, one could always apply domain transfer (e.g. [@ganin2014unsupervised]) to adapt our abstract scenes model to real videos.  However, we must first recognize false beliefs in abstract scenes.  We use our dataset for both learning and evaluation of models for detecting mistaken characters in scenes.  We show a few examples of our dataset in Figure \[fig:grid\] and summarize statistics in Figure \[fig:data\].  We collected this dataset on Mechanical Turk [@sorokin2008utility].  First, we ask workers to illustrate scenes.  Then, we ask workers to annotate mistaken characters.  In the remainder of this section, we describe how we built this dataset.  The appendix contains additional details. 

Collecting Scenes
-----------------

In the illustration step, workers dragged and dropped clipart people and objects into eight frames to tell a coherent story.  The interface was a modified version of [@vqa].  We told workers that some frame should contain a character who has a mistaken belief about the world.  In addition to illustrating these eight frames, workers also wrote a scene-level description and eight frame-level descriptions.  These descriptions were used during the annotation step, but were not used to train or evaluate our models. 

Annotation
----------

In the annotation step, the goal was to label which characters have mistaken beliefs.  We hired workers to review the previously illustrated scenes and write one yes/no question for each frame.  For each frame, workers wrote the true answer to the question and the answer according to each character.  We labeled a character as mistaken if their answer was different from the true answer. 

In total, we collected 1,496 scenes, 1,213 of which passed our qualification standards.  These scenes were the collective effort of 215 workers.  On average, each frame contains 1.71 characters; characters are mistaken in 23.65% of frames.  A pool of 237 workers annotated each scene twice.  The labels for whether a character was mistaken were consistent between workers 71.98% of the time, indicating that in some scenes it was unclear whether a character was mistaken.  In this paper, we only consider scenes where characters are clearly mistaken or not. 

Quality Control
---------------

We used three methods to ensure we collected realistic and diverse scenes.  First, workers completed qualification quizzes before starting the illustration and annotation steps.  In the illustration quiz, workers identified good and bad scenes.  In annotation quiz, workers filled in characters’ answers for a scene with preselected questions.  These quizzes forced workers to think about the beliefs of characters.  Adding these quizzes significantly increased the quality of our data as compared to a pilot experiment.  Second, the scene background and subset of available people, animals, and objects were randomly selected for each worker, ensuring that workers could not illustrate the same scene twice.  Third, we manually reviewed the first scene illustrated by each worker.  If the scene was incoherent or did not contain a mistaken character, we disallowed the worker from illustrating more scenes. 

What Causes Mistaken Beliefs? 
-----------------------------

Figure \[fig:grid\] shows a few scenes from our dataset that highlight different types of mistaken beliefs.  In the first scene, the woman is mistaken because the dog is **occluded** behind couch, and because she cannot see actions **outside her field of view**.  In the second scene, the woman falsely accuses the boy of breaking the painting because she cannot observe events when she is **not present**.  The girl in the third scene mistakenly assumes the boy can safely get off the teeter totter because of her **faulty reasoning about physics**.  In the fourth scene, the boy wearing a red shirt **misinterprets the intentions** of the other boy.  In the last scene, the woman wearing the red shirt lacks the **common sense** that some mushrooms are poisonous.  Recognizing mistaken characters requires detecting each of these types of beliefs. 

Belief Tasks {#sec:tasks}
============

We study two tasks for recognizing mistaken people:

**Task 1: Who is mistaken?**  Given a scene and a character, the goal is to predict whether the character is mistaken in any frame.  This task has several applications in identifying people who may be confused or unaware of danger. 

**Task 2: When are they mistaken?**  Given a frame, the goal is to predict whether any character is mistaken in this frame.  This task has applications in identifying when people might be confused, but it is not possible to know who is confused, such as in a crowd. 

**Joint Task:** We also explore a joint task where we seek to simultaneously recognize who is mistaken as well as localize when they are mistaken in time. 

Method {#sec:method}
======

We now describe an approach for predicting who is mistaken and when they are mistaken.  Recognizing mistaken characters requires looking beyond a single frame; knowledge of the past or the future can provide important signals for recognizing mistaken beliefs in the present.  For example, in the second scene of Figure \[fig:grid\], a model must see that the woman was not present when the girl broke the painting to understand why she falsely accused the boy.  Our model for detecting mistaken characters will look at the past, present, and future.  The model must also understand what a person may know and what they might not.  To detect a mistaken person, the model should determine that the scene is different from what the person believes. 

Person-Centric Representation
-----------------------------

Before predicting whether a character is mistaken, we must tell our model which character to focus on.  We use a **person-centric** representation of the world, where the model takes the perspective of an outside observer focusing on a specific character.  For each frame in the scene, we center the frame at the head of the specified character.  We also flip the frame so the specified character always faces left.  For example, in Figure \[fig:egocentric\], the frame in the upper left can be viewed from each of the three characters’ perspectives.  Alternative approaches that remove parts of the frame outside the character’s field of view may struggle to reason about what the character cannot see. 

![** Person-Centric Representation:** We use a visual representation that focuses on the character of interest.](egocentric_small.pdf){width="45.00000%"}

\[fig:egocentric\]

Visual Features {#sec:visual-features}
---------------

We use a frame-wise approach by extracting visual features for each frame and concatenating them temporally to create a time-series.  We extract visual features from the person-centric images using the AlexNet convolutional network [@krizhevsky2012imagenet] trained on ImageNet [@deng2009imagenet].  We use activations from POOL5, and further downsample by a factor of two.  The resulting feature has size $(256, 12, 21)$. Moreover, although the features we use are trained on natural images (i.e. ImageNet), we successfully used them for abstract scenes, possibly because the high rendering quality. 

Learning
--------

To learn to predict whether a person is mistaken or not, we can train a regularized convolutional logistic regression model, supervised by annotations from our training set.  Suppose our image sequences are length $T$ and our features are $D$ dimensional.  Let $\phi(x_i, p_j) \in \mathbb{R}^{T\times D}$ represent the features for sequence $x_i$ for person $p_j$ and $y_{ij} \in \{0, 1\}^T$ be our target category binary, indicating whether person $p_j$ is mistaken in each frame of sequence $x_i$. Our vector of predictions is $\widehat{y}_{i, j} \in \mathbb{R}^T$. We optimize the objective: $$\begin{aligned}
%\min_w \; w^Tw + C \sum_i \sum_j \max(0, 1 - y_{ij} w \ast \phi(x_i, p_j))
&\min_w \; \sum_{i, j, t} \left( y_{i,j}^{t} \log(\hat{y}_{i,j}^{t}) + (1-y_{i,j}^{t}) \log(1-\hat{y}_{i,j}^{t}) \right) \\
&\textrm{where} \quad
\hat{y}_{i,j}^{t} = \left( w \ast \phi(x_i, p_j)\right)^{t} + b
\end{aligned}$$ The learned weight vector $w \in \mathbb{R}^{K\times D}$ represents the convolutional kernel, where parameter $K$ specifies the temporal width; $b \in \mathbb{R}$ is the learned bias.  For simplicity, we have omitted the L2 penalty on $w$. The superscript $( \cdot )^{t}$ gives the entry of a vector corresponding to frame $t$ in a scene.  We denote convolution as $\ast$, which is performed temporally.  To handle border effects, we pad these features with zeros.  The convolutional structure of our model encodes our prior that characters’ beliefs are temporally invariant. 

Who and When
------------

We tackle two tasks related to beliefs: predict who is mistaken and when they are mistaken.  We train a single model that can be used for both tasks.  Given a sequence $x_i^t$ centered at time $t$ and a person $p_j$ in the sequence, we train a model to estimate whether person $p_j$ is mistaken at time $t$. To answer the who question, we marginalize the classifier response across time.  Likewise, to answer the when question, we marginalize the classifier response across people. 

Implementation Details
----------------------

We extracted image features using Caffe [@jia2014caffe] and we used Keras with Theano [@bastien2012theano] for learning.  To optimize the weights, we used Adam [@kingma2014adam], with a learning rate $10^{-5}$ and a batch size of 32.  We set the temporal kernel width $K=7$. We added weight decay with parameter 1, and stopped training after the validation accuracy had stopped increasing for 3 consecutive iterations.  Weight decay and downsampling image features helped prevent overfitting. 

Experiments {#sec:experiments}
===========

We analyze several models on our dataset of abstract scenes.  We evaluate each model on the “who” task, the “when” task, and the joint “who + when” task. 

  ------------------- ---------------- ---------------- ----------------
                                                        
  Method                  Who+When           Who              When
  Chance                     50               50               50
  Time                   62.9 (1.9)       52.4 (1.8)       64.3 (2.2)
  Pose                   51.9 (2.1)       50.3 (3.5)       54.8 (1.9)
  Time+Pose              60.6 (2.0)       51.6 (1.2)       61.2 (1.9)
  Facial Expression      50.1 (1.9)       57.4 (5.1)       52.9 (2.4)
  Character ID           54.0 (2.1)       61.1 (5.4)       53.4 (2.4)
  Present                64.5 (2.1)       54.1 (6.7)       66.1 (2.4)
  Single Image           61.1 (1.7)       59.7 (3.3)       62.0 (2.0)
  Multiple Image       **66.6 (1.8)**   **64.1 (2.8)**   **67.5 (1.8)**
  ------------------- ---------------- ---------------- ----------------

  : **Quantitative Evaluation:** We evaluate the accuracy of our model versus various baseline on the who task, the when task, and the joint task.  We report classification accuracy; parenthesis show standard deviations. 

\[table:main\_experiment\]

Experimental Setup
------------------

We trained each model on the joint task: given a character and a frame, classify if this character is mistaken in this frame.  Before training, we balance the dataset by resampling so 50% of training examples have a mistaken character.  We randomly divide the dataset into training/validation/testing splits with sizes 80%/10%/10%.  For the experiments in Table \[table:main\_experiment\], we repeat each experiment 20 times with different splits, and report the mean and standard deviation of the accuracies.  For the numbers in Table \[table:corrupt\], we only repeat each experiment six times due to cost. 

Baselines
---------

We used seven baseline models to study the biases in our dataset, including those shown in Figure \[fig:data\].  We fit a kernelized SVM (RBF kernel) to the three baselines using Time and Pose, use logistic regression for the Single Image model, and use convolutional logistic regression for the Facial Expression, Character ID, and Present baselines. 

**Time:** This model uses only the time of the frame within the scene, represented as a fraction between 0 and 1. ** Pose:** This model uses only the pose of the indicated character.  Pose includes the $(x, y)$ position of the character, as well as a boolean indicator of whether the character is looking left or right.  The $(x, y)$ coordinates are normalized to be in the interval $[0, 1]$.

**Time + Pose:** This model combines the features from the Time model and the Pose model. 

**Facial Expression:** This model is given only the character’s facial expression (encoded as a 1-hot vector). 

**Character ID:** This model is given only the character’s identity (encoded as a 1-hot vector). 

**Present**: Each image is replaced by one bit indicating whether the character of interest is present in this frame.  To handle border cases, we add another bit to the feature to indicate whether it is padded. 

**Single Image:** This model only looks at the present frame.  It is equivalent to our model when $K=1$.

Who is mistaken? 
----------------

In this experiment, each model is given a scene and a character, and must determine whether the character is mistaken in any frame.  The (scene, character) pairs are randomly sampled so 50% of pairs contain a mistaken character.  If our model only recognized unnatural scenes and ignored the character of interest, it would perform at chance. 

We evaluate the model’s decision function on each frame in the scene.  For the SVM-based baseline models, each prediction is the signed distance from the separating hyperplane; for the models that use logistic regression, each prediction is a value in the interval $(0, 1)$. We take the maximum of these frame-level predictions as the model’s scene-level prediction.  To obtain a binary decision, we threshold this scene-level prediction (at 0 for the SVM models, and at 0.5 for the logistic regression models). 

  ---------------- ------------ ------------ ------------
                                             
  Method             Who+When       Who          When
  Chance                50           50           50
  Multiple Image    66.6 (1.8)   64.1 (2.8)   67.5 (1.8)
  Flipped           54.5 (1.8)   52.5 (1.7)   55.8 (2.4)
  Centered          62.4 (2.5)   55.6 (3.0)   63.0 (2.4)
  Rewind            57.4 (2.8)   61.4 (3.6)   57.3 (1.8)
  ---------------- ------------ ------------ ------------

  : **Ablation Analysis**: We study the impact of training on altered data and testing on unaltered data.  During training, we modify data to flip the character’s pose (Flipped), not use the person-centric representation (Centered), and show the frames in reverse order (Rewind).  The decrease in accuracy on each task indicates that pose, the person-centric representation, and the arrow of time are important parts of our model. 

\[table:corrupt\]

![ image](results.pdf){width="90.00000%"}

\[fig:predictions\]

The second column of Figure \[table:main\_experiment\] shows that our Multiple Image model achieves a higher accuracy on the “who” task than the baselines.  The Facial Expression, Character ID, and Single Image baselines perform better than chance, suggesting that information about the character of interest is important.  Our Multiple Image model predicts who is mistaken more accurately than these baselines by also looking at past and future frames. 

When are they mistaken? {# sec:when-experiment}
-----------------------

In this experiment, each model predicts whether any character in a frame is mistaken.  Frames are randomly sampled so 50% contain mistaken characters.  We evaluate the model’s decision function on each character’s person-centric representation of the scene.  As in the “who” experiment, we aggregate predictions across characters by taking the maximum of the model’s decision function. 

The third column of Table \[table:main\_experiment\] shows that the Time and Present baselines achieve high accuracies, indicating that temporal information is an important for the when task.  The Single Image model performs better than the Pose model, suggesting that the characters’ interactions with the scene are important for recognizing mistaken beliefs.  Finally, our Multiple Image model performs better than all baselines. 

Joint Task: Who and When? 
-------------------------

In this experiment, the goal is to predict whether a character is mistaken in a given frame.  Frames are randomly sampled so 50% of (frame, character) pairs contain a mistaken character.  As shown in the first column of Table \[table:main\_experiment\], our model achieves a higher accuracy on the “who” task than the baselines.  Similar to the “when” experiment in Section \[sec:when-experiment\], the Time and Present baselines achieve a high accuracies on the joint task.  The Pose baseline performs poorly, suggesting that the Time+Pose model likely ignores pose.  Although pose is a poor feature for the “who + when” task, other features of a single image are important: the Single Image model performs well without knowing the position of the frame in the sequence.  The Multiple Image model performs better than all baselines. 

![ image](ablative_small.pdf){width="90.00000%"}

\[fig:ablative\]

Qualitative Results
-------------------

Figure \[fig:predictions\] shows our model’s predictions on five scenes. ** Row 1:** Our model correctly detects that the man is mistaken in the third frame when the girl is about to pull his chair from beneath him.  In this scene, the man is mistaken because he cannot see the girl’s actions behind him. 

**Row 2:** Our model correctly predicts that the girl is mistaken in the second and third frames as she can not see the man take her bike.  Our model incorrectly predicts that the man is also mistaken in the third frame.  Perhaps our model has learned that a character is likely to be mistaken when another character is performing actions behind them. 

**Row 3:** Our model correctly identifies the boy wearing a white shirt as mistaken in the third frame. 

**Row 4:** The man plays a prank on the girl by hiding a piece of corn beneath a pillow.  Our model incorrectly predicts that the man is mistaken, likely because he cannot see the actions of the girl behind him.  Our model incorrectly predicts that the girl is not mistaken in the third frame, perhaps because the corn is occluded behind the pillow.  Our model might think that the corn disappeared when it became occluded.  Better models for visual humor could improve our results. 

**Row 5:** We show another failure case in which a man places a basket on the see-saw, leaving the boy stranded.  Here, our model incorrectly predicts that the boy has a misbelief in the first frame, but does not have a misbelief in the third frame.  Understanding this situation requires knowledge of basic physics, which our model currently lacks.  Advances in physical understanding may improve reasoning about visual beliefs. 

What has it learned? 
--------------------

How does our model recognize mistaken characters?  In this section, we study some key questions about what our model has learned. 

*Does it only detect unusual frames?*  Our experiments suggest not.  A model for detecting unusual frames would perform well on the when task, but would be unable to do the who task.  The Time and Present baselines do well on the when task but poorly on the who task, suggesting that these baselines only detect unusual frames.  Our model performs significantly better than chance on the who task, indicating that it does more than detect unusual frames. 

*How important is our person-centric representation?*  We tested the impact of our person-centric representation by training a **Centered** version of our Multiple Image model without using the person-centric representation for each character.  As shown in Table \[table:corrupt\], the Centered model performs well on the when task.  With no indication of the character of interest, the Centered model performs much worse than our model on the who task, suggesting that our person-centric representation is an important piece of our model. 

*Does it do gaze following?*  Given that humans use gaze following to reason about the beliefs of others [@psych-gaze], we analyze whether our model started to learn gaze following cues.  We trained a **Flipped** variation on our Multiple Image model that flipped the character’s pose during training but not during evaluation.[^1]

This Flipped model performs worse than our model on the three tasks, as shown in Table \[table:corrupt\].  This suggests the model is internally learning to use gaze [@psych-gaze] without us supervising it to do so.  In Figure \[fig:ablative\], the top two rows compare predictions made by our original model and the Flipped variation.  The predictions made by the Flipped model are consistent with a world where people see from the back of their heads! 

*How does it combine information across frames?  Does it distinguish between past and future?*  Our Multiple Image model outperforms the Single Image baseline, so it must combine information across multiple frames.  To investigate how it does this, we ran time backwards during training and forwards during testing.  Table \[table:corrupt\] shows that this **Rewind** model performs worse than our model, suggesting that our model treats the past and future differently.  In Figure \[fig:ablative\], the bottom two rows compare predictions made by our original model and the Rewind variation.  The predictions made by the Rewind model are logically consistent if the scene is read backwards (from right to left).  This suggests that our model has learned that the arrow of time [@pickup2014seeing] is important. 

Discussion
==========

We propose a new computer vision task to recognize when people have mistaken beliefs about their environment.  We believe this problem is important because understanding people’s beliefs can enable many applications in action prediction, healthcare, and robotics.  To spur progress, we introduce a new dataset of abstract scenes to study this problem.  We present a model that uses multiple timesteps and a person-centric representation of the scene to recognize mistaken people.  Although we only supervise the model with indicators of which characters are mistaken, our ablation experiments suggest that the model learns important cues for this task, such as gaze or the arrow of time. 

[**Acknowledgements:** We thank workers on Mechanical Turk for their creative scenes.  NVidia donated the GPUs used for this research.  This work was supported by a Samsung grant to AT, a Google PhD fellowship to CV, and MIT UROP funding to BE. ]{} 

Appendix {#appendix .unnumbered}
========

In this appendix, we provide more details on how workers illustrated and annotated our dataset.  We also animate our scenes. 

Illustrating the Dataset {#sec:illustration}
========================

[0.45]{} ![** Illustration quiz:** Two scenes from the illustration quiz.  Workers scrolled left/right to see the 8 frames in each scene.  \[fig:illustration-quiz\]](illustration_quiz2.png "fig:"){width="\textwidth"}

[0.45]{} ![** Illustration quiz:** Two scenes from the illustration quiz.  Workers scrolled left/right to see the 8 frames in each scene.  \[fig:illustration-quiz\]](illustration_quiz4.png "fig:"){width="\textwidth"}

Illustration Quiz
-----------------

The first time workers logged in, they were presented with a quality control quiz.  In this quiz, workers were shown a number of scenes, and were asked “Is this a good scene according to our instructions?  If not, why not?”  Workers chose one of the following options:

-   Yes! 

-   No.  The scene is not realistic. 

-   No.  The description does not match the scene. 

-   No.  The scene cannot be understood without reading the description. 

-   No.  The scene does not contain a character with an incorrect belief. 

Figure \[fig:illustration-quiz\] shows some of the scenes from our quiz.  Note that the workers could scroll left/right to see all eight frames in the scene.  Workers could begin illustrating their own scenes only after correctly completing this quiz. 

The scenes shown in the illustration quiz were chosen to highlight common mistakes we saw in a small pilot experiment we ran prior to collecting the main dataset.  We found that adding the quiz significantly improved the quality of scenes in the main dataset as compared to the pilot experiment. 

Illustration Interface
----------------------

Figure \[fig:illustration-interface\] shows the illustration interface.  There are four tabs to the right of the scene for choosing people, animals, large objects, and small objects to add to the scene.  After illustrating a scene, workers also provided a scene-level description and eight frame-level descriptions.  These descriptions were used to help workers annotate our dataset, but were not used to train our model. 

![** Illustration interface:** This is the tool workers used to illustrate scenes.  The people, animals, and objects available in the right pane were chosen randomly to diversify our dataset.](illustration_interface.png){width="45.00000%"}

\[fig:illustration-interface\]

Annotating the Dataset {#sec:annotation}
======================

[0.45]{} ![ image](annotation_interface1.png){width="\textwidth"}

[0.45]{} ![ image](annotation_interface2.png){width="\textwidth"}

![** Annotation quiz:** One example from the annotation quiz.  Workers saw the entire 8-frame scene when answering questions about this frame.  \[fig:annotation-quiz\]](annotation_quiz1.png){width=".45\textwidth"}

Annotation Quiz
---------------

Before workers could start annotating scenes, they completed a short quiz.  In this quiz, we showed workers a couple scenes and accompanying questions.  The workers were asked how each character in each scene would answer the question.  Figure \[fig:annotation-quiz\] shows two frames from two scenes in the quiz.  Workers saw all 8 frames for each scene.  In the frame on the left, the boy would answer “yes” because the boy knows he (the boy) did take the bike; the man would answer “no” because he thinks the boy did not take the bike. 

Annotation Interface
--------------------

After completing the annotation quiz, workers annotated scenes from our dataset.  First, workers studied the scene, as shown in Figure \[fig:annotation-interface\] (left).  Second, workers wrote a question that some character would answer incorrectly in some frame, as shown in Figure \[fig:annotation-interface\] (right).  Workers also predicted how each character would answer the question in each frame.  Note that these questions and answers were only used to identify mistaken characters.  Their text was not used to train our model. 

We showed the annotators both the scene-level description and the frame-level descriptions.  These helped annotators understand the problem we were studying.  Importantly, the scenes were illustrated so it is possible to understand the scenes without reading these descriptions. 

Animation {#sec:animation}
=========

To provide another way of understanding our dataset, we animated the scenes.  Because we have access to the generative parameters for each scene, it is easy to interpolate between frames.  Note that the interpolated frames were not used to train our model.  Rather, these videos highlight how access to the generative parameters are a unique strength of our dataset.  These videos can be seen on the project webpage: . 

[^1]: We also removed the character of interest from the frame to avoid creating unrealistic images.  For example, if we flipped a character sitting on a chair, his limbs would now extend through the back of the chair.  We also confirmed that removing the character of interest from our model did not degrade its performance.