Improving Robot Success Detection using Static Object Data

TL;DR

This paper demonstrates that incorporating static object data, such as images and descriptions, significantly enhances a robot's success detection accuracy in stacking and nesting tasks, especially with unseen objects.

Contribution

The authors introduce a method that leverages static object information to improve success detection in robotic manipulation, achieving substantial accuracy gains over baseline models.

Findings

Up to 57% improvement in success detection accuracy on unseen objects.

Static object data reduces ambiguity caused by visual perception issues.

Model trained on egocentric manipulation data generalizes well to new objects.

Abstract

We use static object data to improve success detection for stacking objects on and nesting objects in one another. Such actions are necessary for certain robotics tasks, e.g., clearing a dining table or packing a warehouse bin. However, using an RGB-D camera to detect success can be insufficient: same-colored objects can be difficult to differentiate, and reflective silverware cause noisy depth camera perception. We show that adding static data about the objects themselves improves the performance of an end-to-end pipeline for classifying action outcomes. Images of the objects, and language expressions describing them, encode prior geometry, shape, and size information that refine classification accuracy. We collect over 13 hours of egocentric manipulation data for training a model to reason about whether a robot successfully placed unseen objects in or on one another. The model achieves up to a 57% absolute gain over the task baseline on pairs of previously unseen objects.

Tables

Table 1. TABLE I: Dataset folds sizes.

	Objects		Robot Pairs		All Pairs
Fold	$Y$	$C$	in	on	in	on
Train	$51$	$17$	$191$	$191$	$800$	$2500$
Dev	$20$	$5$	$47$	$58$	$100$	$400$
Test	$19$	$6$	$60$	$60$	$114$	$361$

Table 2. TABLE II: Model performance on both Development and Test Robot Pairs .

	Model ($M$)		Detection Correct $\uparrow$
	Ego	Object	in	on
Dev Fold	✓		$.69\pm .08$	$.55\pm .11$
	✓	✓	$.70\pm .09$	$.59\pm .07$
	✓	pre	$.73\pm .09$	$.62\pm .07$
	Baseline (MC)		$.32\pm .00$	$.36\pm .00$
	Baseline (Rand)		$.49\pm .06$	$.50\pm .06$
Test Fold	✓		$.77\pm .05$	$.53\pm .10$
	✓	✓	$.74\pm .07$	$.59\pm .08$
	✓	pre	$.77\pm .05$	$.59\pm .06$
	Baseline (MC)		$.20\pm .00$	$.32\pm .00$
	Baseline (Rand)		$.52\pm .05$	$.51\pm .07$
✓indicates signal was included, while “pre” indicates models with object features pretrained from All Pairs data.

Table 3. TABLE III: Egocentric M ego superscript 𝑀 ego M^{\mathrm{ego}} model and augmented M ego + pre superscript 𝑀 ego pre M^{\mathrm{ego+pre}} model predictions. We display only the post-manipulation frame for R Δ subscript 𝑅 Δ R_{\Delta} .

Egocentric $\Rightarrow$	Pred	Egocentric + Pretrained Object    $\Rightarrow$		Pred	Truth	Reason
	✗In		small black sphere, round black item, small marble, the blue object, round object, tiny object, tiny dot, blue round object, little ball	✓In	✓In	With egocentric vision alone, it is difficult to see the small marble. After adding object data, the model classifies the tiny marble in the cup container.
			red cup, orange cup, small round container, object that holds drinks, small red cup, red cup, medium size cup without handles, red plastic thing, red cylinder
	✗In		screwdriver, thing with the fat handle and metal prong on the end, tool used for tightening screws, screw driver with long tip, screwdriver, plastic handle screw driver, non phillips screw driver, tool, black screwdriver	✓In	✓In	The reflective screwdriver and its tag spill over the edge of the cup, creating a misleading egocentric depth scan. After adding object data, the model classifies the screwdriver as being in the cup container.
			red cup, orange cup, small round container, object that holds drinks, small red cup, red cup, medium size cup without handles, red plastic thing, red cylinder
	✗On		blue thing, blue plastic rectangle, blue plastic block, blue cube, lego piece, blue plastic thing, blue block, small square block, little blue block	✓On	✓On	The block rests partially nested in the cup, exhibiting a rare hybrid of both on modalities (resting on top versus nested inside). After adding object data, the small block is classified as resting on the cup container.
			red cup, orange cup, small round container, object that holds drinks, small red cup, red cup, medium size cup without handles, red plastic thing, red cylinder
	✗On		yellow thing, long yellow item, soft yellow thing, yellow curved cylinder, yellow fruit, the object that is mostly yellow with slight green at one of the tips, yellow long fruit, yellow banana, banana	✓On	✗On	Given object data predictions pretrained on crowdsourced labels, the model predicts that fruit is balanced on the can, consistent with human ability. In reality, the robot manipulator lacks the dexterity to reliably balance the banana.
			spam, canned meat, metal can, can of spam, aluminum cube, blue and gold cube, rectangular can, square, glass circle

Table 4. TABLE A1: Object-only model ablations for the All Pairs task.

	Model ($M$)		Prediction Correct $\uparrow$
	Object Data
	Lang	Vis	in	on
Dev Fold	✓	$\overrightarrow{0}$	$.86\pm .02$	$.76\pm .01$
	$\overrightarrow{0}$	✓	$.94\pm .01$	$.79\pm .01$
	✓	✓	$.86\pm .04$	$.78\pm .01$
	Baseline (MC)		$.87\pm .00$	$.73\pm .00$
	Baseline (Rand)		$.49\pm .07$	$.50\pm .03$
Test Fold	✓	$\overrightarrow{0}$	$.86\pm .01$	$.83\pm .01$
	$\overrightarrow{0}$	✓	$.88\pm .02$	$.82\pm .01$
	✓	✓	$.87\pm .02$	$.83\pm .01$
	Baseline (MC)		$.84\pm .00$	$.83\pm .00$
	Baseline (Rand)		$.51\pm .06$	$.51\pm .03$
✓indicates signal was included.

Table 5. TABLE A2: M ego + obj superscript 𝑀 ego obj M^{\mathrm{ego+obj}} and M ego + pre superscript 𝑀 ego pre M^{\mathrm{ego+pre}} model ablations on Robot Pairs .

	Model ($M$)			Detection Correct $\uparrow$
	Ego	Object Data
		Lang	Vis	in	on
Dev Fold	$\overrightarrow{0}$	✓	$\overrightarrow{0}$	$.70\pm .03$	$.56\pm .10$
	$\overrightarrow{0}$	pre	$\overrightarrow{0}$	$.72\pm .04$	$.57\pm .09$
	$\overrightarrow{0}$	$\overrightarrow{0}$	✓	$.71\pm .08$	$.50\pm .06$
	$\overrightarrow{0}$	$\overrightarrow{0}$	pre	$.72\pm .07$	$.53\pm .05$
	$\overrightarrow{0}$	✓	✓	$.76\pm .08$	$.58\pm .05$
	$\overrightarrow{0}$	pre	pre	$.78\pm .08$	$.60\pm .04$
	✓	✓	$\overrightarrow{0}$	$.67\pm .08$	$.60\pm .08$
	✓	pre	$\overrightarrow{0}$	$.68\pm .08$	$.62\pm .08$
	✓	$\overrightarrow{0}$	✓	$.70\pm .10$	$.58\pm .11$
	✓	$\overrightarrow{0}$	pre	$.72\pm .08$	$.59\pm .13$
	✓	✓	✓	$.70\pm .09$	$.59\pm .07$
	✓	pre	pre	$.73\pm .09$	$.62\pm .07$
	Baseline (MC)			$.32\pm .00$	$.36\pm .00$
	Baseline (Rand)			$.49\pm .06$	$.50\pm .06$
Test Fold	$\overrightarrow{0}$	✓	$\overrightarrow{0}$	$.79\pm .02$	$.45\pm .05$
	$\overrightarrow{0}$	pre	$\overrightarrow{0}$	$.79\pm .02$	$.48\pm .07$
	$\overrightarrow{0}$	$\overrightarrow{0}$	✓	$.80\pm .04$	$.46\pm .09$
	$\overrightarrow{0}$	$\overrightarrow{0}$	pre	$.81\pm .04$	$.48\pm .06$
	$\overrightarrow{0}$	✓	✓	$.80\pm .03$	$.55\pm .04$
	$\overrightarrow{0}$	pre	pre	$.79\pm .04$	$.55\pm .04$
	✓	✓	$\overrightarrow{0}$	$.75\pm .06$	$.54\pm .10$
	✓	pre	$\overrightarrow{0}$	$.80\pm .02$	$.57\pm .07$
	✓	$\overrightarrow{0}$	✓	$.75\pm .11$	$.57\pm .10$
	✓	$\overrightarrow{0}$	pre	$.80\pm .05$	$.56\pm .10$
	✓	✓	✓	$.74\pm .07$	$.59\pm .08$
	✓	pre	pre	$.77\pm .05$	$.59\pm .06$
	Baseline (MC)			$.20\pm .00$	$.32\pm .00$
	Baseline (Rand)			$.52\pm .05$	$.51\pm .07$
✓indicates signal was included, while “pre” indicates models with object features pretrained from All Pairs data.

Full text

I Introduction

We show that static vision and language data about the objects a robot manipulates can improve action outcome detection compared to a robot’s egocentric camera data alone. We consider the task of determining whether a robot’s stacking action resulted in successfully placing an object in or on another object given egocentric scene information from a manipulator-mounted camera111http://rosarioscalise.com/IROS19 (Fig. 1) and static vision and language data about the objects themselves in the form of images and referring expressions.

Consider a robot clearing a table of a plate, two cups, and two forks. Rather than clear each item one by one, a more efficient plan is to nest the cups in one another, place the forks in the cups, and put that collection on the plate. Accomplishing this plan requires the robot to detect success after nesting and stacking actions. Before the robot stacks the cups on the plate, it must know that it has successfully nested the cups in one another.

This problem is non-trivial for unseen objects with a wide range of geometries. In the first row of Fig. 1, the spoon is in the cup, but the robot’s RGB signal is shallow because the handle and the cup are both red, and the depth signal is noisy because of the reflective surface of the spoon that hangs outside of the cup.

For such applications, the objects in a robot’s workspace have properties—such as geometry, size, and shape—that provide a prior for action success. These properties are reflected in static visual and language data about workspace objects. Pictures taken from multiple viewpoints can reveal an object’s geometry, while language descriptions can reveal an object’s category (e.g., cup) and shape (e.g., long).

Our insight is to augment RGB-D workspace signals with vision and language priors about the objects themselves to improve classification accuracy of containment relationship after a robot stacking action on unseen objects.222All code and data for reproducing our results are available at

https://github.com/thomason-jesse/YCBLanguage In Fig. 1, static images show that the cup has a hollow center, so objects can go in it, while language referring expressions (e.g., silver spoon with a long handle) reveal a long shape that is easy to rest on other objects.

We examine whether a grasped object ($O_{G}$) lands in or on a target object ($O_{T}$) when a robot performs a simple stacking action. We gather egocentric RGB-D camera streams of stacking pairs of objects from the Yale-CMU-Berkeley (YCB) Object and Model set [1], which reflect over 50 hours of robot operation by a researcher. We propose end-to-end CNN-based models to detect whether object $O_{G}$ is in or on object $O_{T}$ after manipulation given this egocentric data (Fig. 2). We improve performance by adding static object images and referring expressions.

Contributions:

• •

We show that vision and language data about objects improves detection success for robot action outcomes;

• •

we provide an end-to-end model for detecting successful placement of one object in or on another; and

• •

we create a dataset of over 13 hours of robot stacking sensor streams, more than 4000 human annotations of whether object pairs can be in and on one another, and over 800 natural language object referring expressions.

We assume oracle-level object grasping (grasp selected by the researcher), and motion planning that results in object $O_{G}$ being held within 3cm of the target $O_{T}$ before being dropped. We assume a fixed vantage point from which to survey the scene pre- and post-manipulation, ameliorating one difficulty of manipulator-mounted cameras. We consider pairwise interactions between objects, limiting our task to two objects at a time. We consider nesting objects in and stacking them on one another as a starting point for a wider class of object containment relations.

II Related Work

Our task is to detect action success in terms of physical relationships between two objects using a manipulator-mounted camera. This task relates to work in object relations, grasping and stacking, and egocentric vision. We demonstrate improvements by using static data about the objects involved, including human annotations, related to other work in utilizing human judgements for robotics applications.

Object Relations

Beyond a functional understanding of which object it can interact with [2], a robot can reason about relationships between objects. Single models that take in information about two objects can reason about multiple relationships between them [3], but this requires large, annotated training data for all inter-object relations. Some work targets relationships between tools and target objects [4]. Other work considers stacking to be a category of high-level activity within a dataset [5], or learns object-level attributes for stackable and containment [6]. Still others learn to ground multi-object concepts, like rows and columns [7]. We use static object information as a prior to improve egocentric detection of whether a robot successfully stacked one object on or contained one object in another.

Grasping and Stacking

Current robot systems are increasingly proficient at robustly grasping objects [8, 9, 10] and subsequently dropping, placing, and balancing them [11, 12]. The outcomes of these actions vary based on the dexterity of the robot manipulator [13]. Longer-horizon tasks, like stacking multiple objects, require awareness of intermediate action success. Research has addressed: reasoning about visual stability of objects in simulation [14, 15, 16] and in a robot workspace [17]; detecting intermediate task success [18, 19]; and predicting whether a task will succeed before executing it [20]. We define success in terms of two object relationships: in and on, and we assume oracle-level grasping and localization during action execution.

Egocentric Vision

Existing work detects action outcomes using extrinsic camera viewpoints [21]. However, as robots move from research labs to homes, static cameras become impractical and intrusive. Instead, egocentric cameras can be mounted to the robot chassis [22, 23] or manipulator [24, 25]. Most egocentric vision research centers on identifying human [26, 27] and robot activities [28] or ego-driven scene prediction [29]. These perspectives are often obtained through head- or body-mounted cameras [30, 31, 32]. We use a manipulator-mounted camera, which may become the norm for future robot platforms (e.g., Kinova Jaco 3). This setup restricts the robot to a single viewpoint at a time.

Human Judgement

Attempting to model or utilize human manipulation abilities is a long-studied problem in robotics [33]. Researchers have used crowdsourcing platforms to source data for grasping novel objects [34] and translating natural language commands to actions [35, 36]. Natural language descriptions of objects from humans can help robots learn visual (red) [37, 38, 39] or multi-modal (heavy) [40, 41] classifiers between words and workspace objects, as well as inter-object relations [42]. While embeddings learned by language modeling (e.g., [43]) place words like fork, plate, and cup as neighbors in the embedding space despite their referents having different physical properties, language vectors informed by physical properties [41] encode some differences in geometry. However, such vocabularies are noisy and sparse, making them insufficient for an open-vocabulary (unrestricted word choice) domain. We crowdsource open-vocabulary referring expressions (e.g., “yellow long fruit”) for objects, and annotations for whether humans think objects can be placed in or on one another.

III Task and Data

Our task is to determine whether a robot stacking action successfully placed object $O_{G}$ in or on object $O_{T}$ given egocentric scans from a manipulator-mounted camera.

Data Folds

We chose the YCB Object and Model set [1], a standardized collection of physical objects designed for benchmarking robot manipulation, for two reasons. First, this object set is widely used among robotics labs, making the data we collect useful to other researchers. Second, its constituent objects span a diverse space of geometries and potential physical interactions, making the detection of simple physical relations like in and on after a stacking attempt more challenging.

Among the full set of 90 YCB objects, $Y$, we designate a subset of 28 containers as $C$ (e.g., cups, boxes, and cans). We split $Y$ into Train, Development, and Test data folds. Pairs of objects considered in each fold are considered for the task (e.g., all Train object pairs ($O_{G}$, $O_{T}$) comprise two Train objects). Consequently, not all object pairs are included in the data folds since pair $i,j$ cannot be included in any fold if individual objects $i$ and $j$ are assigned to different folds. This split also means that all objects are unseen at inference time. For testing $O_{G}$ in $O_{T}$, we consider pairs where ($$O_{G},O_{T}$$)\in Y\times~{}C, all objects paired with all containers; for $O_{G}$ on $O_{T}$, we consider pairs where ($$O_{G},O_{T}$$)\in Y\times~{}Y, all objects paired with all objects. We evaluate on the subset of object pairs in those splits for which we collect egocentric, RGB-D data from robot trials (Robot Pairs), and we define an auxiliary task over all pairs in these splits (All Pairs). Table I gives the number of pairs per data fold.

Robot Pairs

For a subset of All Pairs, we collect RGB-D directly from the robot’s egocentric viewpoint. For each such Robot Pair, five trials were gathered, resulting in $191\times 5=955$ training examples. Our robot is the widely used Kinova Jaco$2$[44]. We use an Intel Realsense D415 RGB-D camera[45] mounted on the end-effector.

To collect egocentric camera data for each pair ($O_{G}$, $O_{T}$), object $O_{T}$ is first set on an origin position on the table. Then, the robot moves to a designated survey position and captures a pre-manipulation RGB-D frame. An operator manually places object $O_{G}$ within the robot’s gripper, and the gripper is closed. Then, the robot gripper moves to a height of 3cm above $O_{T}$ and opens. Finally, the robot returns to the survey position and captures a post-manipulation RGB-D frame.

We collect 5 such trials per object pair. For each pair, the operator provides an annotation in {Yes, No} of the outcome, noting whether object $O_{G}$ was in or on object $O_{T}$ for all five trials.333For cases where the trials had different annotated outcomes (e.g., on 2 times and not 3 times), the label was decided as No. Similarly, annotator disagreement from Mechanical Turk was rounded to No. This data collection is expensive to conduct because it uses operator-selected oracle grasping.

Data Augmentation

To augment expensive robot pair data collection, we gather complementary data about objects and object pairs via crowdsourcing through Amazon Mechanical Turk (AMT)444https://www.mturk.com/ conditioned only on static images of the objects. The YCB dataset provides standardized images of each object from multiple angles. For each object, we choose the 0$\degree$ yaw, 30$\degree$ pitch viewpoint as a representative image to show AMT workers (examples in Figure 3).

Each AMT worker annotates 35 pairs of side-by-side object images. For 9 of these pairs, we ask annotators whether object $O_{G}$ could be put in object $O_{T}$. For the remaining 26 pairs, we ask annotators if object $O_{G}$ could be placed on object $O_{T}$. For each object pair, we collect at least three annotations for each of in and on and assign labels {Yes, No} based on them.

Subsequently, for each YCB object from $Y$, we collect three referring expressions from three different annotators (nine in total per object). These expressions, for example small black sphere in the first row of Table III, provide linguistic clues about object size and shape properties.

IV Models

We introduce an end-to-end model that uses egocentric camera inputs to determine whether a stacking action resulted in an in or on relationship between two objects (Fig. 2). We then add additional object data inputs: images and natural language referring expressions of the objects.

Egocentric Model $M^{\mathrm{ego}}$

During a robot execution trial, the robot’s egocentric camera provides pre-manipulation and post-manipulation RGB-D inputs: $R_{pre}$ and $R_{post}$ of size $640\times 480$. These images are downsampled once via an average pooling layer to size $64\times 48$. We use the difference between the images ($R_{\Delta}$) as input to the model.

We learn two egocentric classification models, $M^{\mathrm{ego}}_{in}$ and $M^{\mathrm{ego}}_{on}$, that independently learn whether in and on hold between pairs of objects. These models consist of two 3-layer convolutional nets, one for processing RGB and one for processing D inputs, with max-pooling followed by a singular fully connected layer. Specifically, these models take $48\times 64$ RGB (3 color channels + 1 $L_{2}$ channel) and depth image (1 depth channel) differences as input and output a label $c\in\{Yes,No\}$. To capture changes in RGB space, we include the $L_{2}$ distance between $R_{post}$ and $R_{pre}$. $L_{2}$ lets us capture change across all three dimensions, while subtraction assumes the color channels are independent. Fig. 2 depicts the egocentric model architecture.

Egocentric plus Object Data Model $M^{\mathrm{ego+obj}}$

We augment the Egocentric Model with two additional inputs. First, we add five images of each object ($O_{G}$ and $O_{T}$), independently representing front, back, left, right, and top-down views.555Extracted from given YCB object metadata. Accuracy is slightly lower when considering only the front image. These static images provide multiple vantage points from which to extract the objects’ geometry features. Second, we add natural language referring expressions for each object, which provide linguistic clues about physical properties (e.g., “small” and “long”).

We use ResNet-152 [46] and GLoVe vectors [43] (sans fine-tuning) to embed our images666Such models could potentially extract features from egocentric scans, but are trained for ImageNet classification, not task-relevant spatial relations. and language. The embeddings across the five images and across the referring expression words are averaged to compute embeddings for the auxiliary vision and language input, respectively. We compute the differences between embeddings for $O_{G}$ and $O_{T}$ visually and linguistically before projecting them to the same size space and concatenating the output to the penultimate layer of the Egocentric Model for classification. These object pair embedding vectors from egocentric scans and from object data concatenated for classification have the same size. Fig. 3 shows the model architecture. We again learn independent $M^{\mathrm{ego+obj}}_{in}$ and $M^{\mathrm{ego+obj}}_{on}$ models.

Object images can capture geometry, e.g., if $O_{T}$ is wide and flat, $O_{G}$ is more likely to go on it. Referring expressions can reveal how descriptor words like “small” and “large” for $O_{G}$ encode how likely it is to go in $O_{T}$.

Egocentric plus Pretrained Object Data Model $M^{\mathrm{ego+pre}}$

Running the robot through thousands of trials and labeling the outcomes is prohibitively expensive, but object data can be crowdsourced (as described in Section III). Whereas in the previous two models, we trained using the smaller data subset, Robot Pairs, here we make use of the All Pairs data to pretrain relevant layers of the $M^{\mathrm{ego+obj}}$ architecture to obtain the $M^{\mathrm{ego+pre}}$ model.

We pretrain the $M^{\mathrm{ego+obj}}_{in}$ and $M^{\mathrm{ego+obj}}_{on}$ architecture layers that map from input embeddings to hidden projection layers on an auxiliary task: predicting in and on Mechanical Turk annotations given only images and referring expressions for objects $O_{G}$ and $O_{T}$ (e.g., no RGB-D input information). This is a noisy signal because human intuition about these stacks might not align with the robot’s ability, but we can train on the much larger set of All Pairs.

We hypothesize that this pretraining will lead to higher task accuracy. We denote $M^{\mathrm{ego+pre}}_{in}$ and $M^{\mathrm{ego+pre}}_{on}$ models with layers for processing image and referring expression inputs instantiated with pretrained weights from this auxiliary task. We compare these against the randomly initializing the weights before training, as done for the $M^{\mathrm{ego+obj}}$ models.

V Experiments and Results

We evaluate these models by comparing their performance on the Test data fold of Robot Pairs.777We tune all architecture hyperparameters to maximize accuracy on the development data fold. We use an Adam optimizer [47] with learning rate $0.01$, dropout of $0.3$ and ReLu connections between fully connected layers, and a hidden layer size of $64$. For RGB-D, we use a $3\times 3$ kernel, with three layers of alternating convolution and max pooling operations and filters doubling at each. We compare model variants against one another and majority class and random baselines. For evaluation, we train each model for 30 epochs, recording the average maximum test data fold accuracy reached in that time across 10 different seeds.888Random restarts to expose variance in model performance. During training, all 5 trials per object pair serve as individual training examples, while at inference time a majority vote across the 5 trials of the test pair is taken to assign the label. Table II shows model and baseline accuracy and standard deviation on the Development and Test data folds.

All end-to-end models achieve higher accuracy than the baselines, with a 57% absolute gain for the in task between the baseline and $M^{\mathrm{ego}}_{in}$ / $M^{\mathrm{ego+pre}}_{in}$ models. When considering the in and on detection tasks together, models with vision and language processing layers pretrained on an auxiliary task, $M^{\mathrm{ego+pre}}$, score higher accuracy than the others across both the Test and Dev folds.999We also tested models pretrained on the auxiliary task but using only object data (e.g., no Ego input). These are accurate for detecting the more geometry-informed in relation but fall short when classifying on, which is conditioned on robot dexterity (e.g., Table III row 4).

VI Discussion

The proposed models all outperform the baseline at detecting both in and on relationships. Here, we discuss their relative performance on these tasks, and Table III shows examples of model disagreements between the egocentric $M^{\mathrm{ego}}$ models and object data augmented $M^{\mathrm{ego+pre}}$ models.101010Table III shows the best performing model across random restarts.

Analysis

The egocentric RGB-D scans are not always sufficient to make an accurate success judgement. The first and second rows of Table III show examples where egocentric data fails to discern that object $O_{G}$ has been successfully placed in object $O_{T}$. In the first row, object $O_{G}$ is a tiny, barely perceptible marble. In the second row, object $O_{G}$ is a screwdriver with a shiny tip, resulting in a misleading depth scan (similar to the first row of Fig. 1).

In general, our models have more limited accuracy when detecting on than in relationships: the on relationship is semantically more general than in. Specifically, consider that any object $O_{G}$ in a container $O_{T}$ is also implicitly on that container, while the converse does not hold. This leads to at least two distinct modalities for on: object $O_{G}$ on top of object $O_{T}$, and $O_{G}$ is inside of $O_{T}$. Each presents differently in depth scans. The third row of Table III shows an object pair exhibiting a hybrid of these two on modalities. Generalizing from the Train to Test data pairs is challenging, especially for the wider on relation.111111By contrast, on the Train data fold, all models (except the baselines) for both in and on perform at or above 85% accuracy when measured at the epoch achieving the best Test/Dev generalization accuracy reported in Table II.

Human intuitions of what relationships can hold between objects are not perfectly consistent with the robot’s capabilities. The fourth row of Table III shows that while humans annotate that a banana can balance on a spam can, the robot manipulator lacks the dexterity to reliably balance the cylindrical banana. This is reflected in the egocentric $M^{\mathrm{ego}}_{on}$ model making the correct decision, while the object data augmented model is mislead by pretraining from human judgement that fruits can be balanced on cans.

Limitations and Future Work

To explore the containment detection task, we make several data collection and modeling assumptions (listed in Section I). Relaxing these assumptions is beyond the scope of this work, but we discuss future research towards doing so.

Collecting egocentric camera stream information from a robot performing manipulation tasks is expensive in terms of operator hours, but running data collection in a self-supervised fashion is difficult in practice when dealing with unseen objects. Future work towards automatically selecting robust grasps, and planning for correct object placement on the target object, may allow the robot to gather egocentric data autonomously for subsequent experimenter annotation.

We simplify the manipulator-mounted vision input to our model by assuming a fixed vantage point to capture pre- and post-manipulation RGB-D scans. While our data processing makes the model robust to different table heights between pair samples (because we subtract pre- and post- scans), it may be brittle against lighting and axial changes. Standard computer vision techniques (e.g., cropping, translating, color shifting) can increase model robustness, while future autonomous data collection could use the manipulator-mounted camera to capture scans from multiple vantage points.

We consider pairwise interactions between objects when both pre- and post-manipulation scans are available. In many applications contexts (e.g., table clearing), multiple objects interact, and some may already be interacting when the robot arrives. After nesting two cups in one another, a robot may need to determine whether they can rest on a plate. Similarly, a cup with a fork already in it cannot have a cup nested in it. Static object data generalizes to the multiple object domain in some cases. Using referring expressions, we can infer that nested cups still behave like a cup, while a cup and fork may not. Another approach would be to simulate the multiple objects involved, but that requires high-fidelity object models and physics interactions in simulation.

Nesting objects in and stacking them on one another exemplify two simple actions. Object manipulation in industrial [48] or home furniture assembly [49, 50] involves additional relationships, like fastening one object to another (e.g., by tightening a screw or hammering a nail). We provide a starting point for detecting when manipulation leads to containment, and hypothesize that prior information about the objects themselves will improve success detection accuracy for other, nuanced physical containment relationships.

VII Conclusion

We provide a means by which a robot equipped with an egocentric, manipulator-mounted RGB-D camera can determine whether object placement actions result in one object being placed in or on another. We propose a model solely trained on a robot’s observations of outcomes, and then we show that task accuracy can be improved using prior visual and linguistic information about the objects involved. We find that pretraining with crowdsourced annotations of whether objects can be placed in or on one another bootstraps useful feature extraction from this prior information.

Acknowledgements

This work was funded by the National Institute of Health (#R01EB019335), NSF (CPS #1544797, NRI #1637748, #IIS-1524371 & #1703166), the Office of Naval Research, the RCTA, Amazon, Honda, and DARPA’s CwC program through ARO (W911NF-15-1-0543).

Appendix

VII-A Model Ablations

To examine the contribution of each modality among egocentric camera images, object language referring expressions, and object static images, we perform a unimodal ablation analysis [51]. Under this ablation framework, the model architecture under examination remains unchanged, but ablated input modalities are set to zero tensors ({\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\vec{0}}) at both training and inference time.

Performance of the $M^{\mathrm{obj}}$ models on the auxiliary task of predicting Mechanical Turk workers’ annotations for whether objects can be stacked in or on one another given object images and referring expressions is given in Table A1 for the Test and Development data folds on All Pairs. In most cases, the prediction model using both language and vision signals achieves matching or higher accuracy than majority class, with the exception of losing about 1% on the Development fold on the in annotation prediction task. The language-only and vision-only ablations reveal that either modality is competitive for predicting in and on annotations, with vision-only having the edge in most cases.

This auxiliary task facilitates pretraining the $M^{\mathrm{ego+pre}}$ model based on the $M^{\mathrm{ego+obj}}$ architecture. Table A2 examines the performance of these models when ablating all three of egocentric, object language, and object vision modalities for detecting the results of actions on the Robot Pairs. Note that models with no egocentric input are essentially predicting what happens to pairs of objects, as opposed to detecting it from available egocentric scene information.

There are three high-level takeaways from these ablations. First, In almost all cases, pretraining improves detection accuracy. Where performance does not improve, it remains the same. Second, performance on the prediction task for in, that is, when ablating the egocentric modality out, is competitive with the detection task of actually surveying the scene. For the more complex on relationship, which can take different forms (as discussed in Section VI), using the egocentric camera information improves performance over object priors alone. Finally, as in the All Pairs prediction experiments, both the language-only and vision-only ablations of object data perform well, suggesting that either alone may be enough to augment a detection model if the other is unavailable at inference time in practice.

VII-B YCB Object Details

We make a number of small changes and omissions from the full YCB Object Set when establishing our included objects $Y$ (Section III). In particular, we:

• •

exclude objects lacking camera image data used as vision information to the augmented model (Fig. 3);

• •

exclude 072-*_toy_airplane parts b-k;

• •

do not split the two similar, medium-most-sized 063-f_cups and 063-e_cups objects into different folds, to evaluate more conservatively; and

• •

for 063-j_cups, we sometimes use a same-sized cup that is light blue instead of yellow during robot trials.

VII-C Language Analysis

Our language annotations range up to 14 words in length (Figure 4) and the importance of using pretrained vectors becomes clear as we see a large number of rare words (matching the expected Zipfian distribution of lexical tokens) in Figure 5. First we analyze the description lengths and find that most responses contain fewer than five words.

Short sentences can take the form of a single entity (e.g. “apple”) or have a single adjective (e.g. “blue cylinder”). In contrast, long descriptions may deviate from descriptions of form to function:

thing you use to see how many spaces you move during a board game

Understanding this requires much richer textual representations about the world. Relatedly, precise descriptions which avoid using the name of an object also result in long descriptions. Here we have a description of physical characteristics of the same die:

white cube with different number of black dots on each side.

A similar pattern emerges when looking at the most and least frequent lexical types. The most common are common adjectives and types:

black, red, blue, yellow, cup, ball, box, plastic, …

while the least common contain nuanced textures, world references, typos and counting:

bumps, bloch, fleshy, eight, cleaning, avocado, …

In this work, we use GloVe vectors as our pretrained world representations. We leave the question of building better language representations that account for properties of the physical world to future work [52].

VII-D Annotation Details

For on and in labels across the five trials gathered for each Robot Pair, the outcome label was annotated in {Yes, No, Maybe}. The Maybe annotation denotes that there was mixed success across the five trials. Similarly, for the Mechanical Turk annotations used during the auxiliary task for data augmentation, when annotators disagreed about the annotation in {Yes, No}, Maybe was assigned. Throughout our experiments, we round Maybe annotations to the No label for both robot trial and Mechanical Turk annotations.

For Mechanical Turk, annotators answer “yes”, “no”, or “yes, but only if object A is rotated.” We rounded this final option down to “no” for our task, but the original label may be useful for other manipulation tasks.