A key bottleneck in widespread deployment of robots in human-centric environments is the ability for non-expert users to communicate with robots. Natural language is one of the most popular communication modalities due to the familiarity and comfort it affords a majority of users. However, training a robot to understand open-ended natural language commands is challenging since humans will inevitably produce words that were never seen in the robot’s training data. These unknown words can come from paraphrasing such as using “saucer” instead of “plate,” or from novel object classes in the robot’s environments, for example a kitchen with a “rolling pin” when the robot has never seen a rolling pin before.
We aim to develop a model that can handle open-ended commands with unknown words and object classes. As a first step in solving this challenging problem, we focus on the natural language object retrieval task — selecting the correct object based on an indirect natural language command with constraints on the functionality of the object. More specifically, our work focuses on fulfilling commands requesting an object for a task specified by a verb such as “Hand me a box cutter to cut.” Being able to handle these types of commands is highly useful for a robot agent in human-centric environments, as people usually ask for an object with a specific usage in mind. The robot would be able to correctly fetch the desired object for the given task, such as cut, without needing to have seen the object, a box cutter for example, or the word representing the object, such as the noun “box cutter.” In addition, the robot has the freedom to substitute objects as long as the selected object satisfies the specified task. This is particularly useful in cases where the robot cannot locate the specific object the human asked for but found another object that can satisfy the given task, such as a knife instead of a box cutter to cut.
Our work demonstrates that an object’s appearance provides sufficient signals to predict whether the object is suitable for a specific task, without needing to explicitly classify the object class and visual attributes. Our model takes in RGB images of objects and a natural language command containing a verb, generates embeddings of the input language command and images, and selects the image most similar to the given command in embedding space. The selected image should represent the object that best satisfies the task specified by the verb in the command. We train our model on natural language command-RGB image pairs. The evaluation task for the model is to retrieve the correct object from a set of five images, given a natural language command. We use ILSVRC2012 images and language commands generated from verb-object pairs extracted from Wikipedia for training and evaluation of our model. Our model achieves an average retrieval accuracy of 62.3% on a held-out test set of unseen ILSVRC2012 object classes and 53.0% on unseen object classes and unknown nouns. Our model also achieves an average accuracy of 54.7% on unseen YCB object classes. We also demonstrate our model on a KUKA LBR iiwa robot arm, enabling the robot to retrieve objects based on natural language commands, and present a new dataset of 655 verb-object pairs denoting object usage over 50 verbs and 216 object classes.
Ii Related Work
Natural language object retrieval refers to the task of finding and recovering an object specified by a human user using natural language. The computer vision and natural language grounding communities attempt to solve object retrieval by locating orgrounding the object specified in an image using natural language [13, 11]. Krishnamurthy and Kollar  use a dataset of RGB images with segmented objects and their natural language descriptions to learn the grounding of words to objects in the image by exploiting repeated occurrences of segmented objects within images, along with their descriptions in natural language. Hu et al. 
use a similar approach albeit using deep neural networks to avoid parsing and feature construction by hand.Chen et al.  learn joint embeddings of language descriptions and colored 3D objects for text-to-shape retrieval and generation of colored 3D shapes from natural language. Cohen et al.  learn joint embeddings of language descriptions and segmented depth images of objects for object retrieval within instances of the same object class. Our work, in contrast, learns an embedding across object classes based on their suitability for a given task specified using natural language. Our object embeddings are not conditioned on the output class of objects, but on the relevancy of the object for the specified task. This, therefore, allows us to retrieve objects based on descriptions of their usage and importantly allows handling of unknown nouns and unseen object classes.
Another relevant line of work is image captioning and image retrieval, which also aims to jointly model a natural language sequence and image content. The SUN scene attribute dataset 
maps images to attributes such as “hills,” “houses,” “bicycle racks,” “sun,” etc. Such understanding of image attributes provides scene category predictions and high level scene descriptions, for example “human hiking in a rainy field.” Methods based on recurrent neural networks (RNNs)[16, 24, 26]
trained to directly model the probability distribution of generating a word given previous words and an image have shown to be effective in image caption generation, natural language image retrieval, and image caption retrieval. Our work is most similar to earlier attribute based image retrieval work. However, these models are trained on attributes that are directly specified and not inferred from indirect task based queries. Implicit task-based object attributes are harder to learn but are also more general than directly specifiable object visual attributes, and are useful for a natural language object retrieval system to have in its toolbox.
Also related to our work are methods on interactive object retrieval  and language grounding [22, 7]. These methods perform inference over dialogue to deduce the right object based on the specifications provided by the human user. They specifically use known object copra and directly specify the object attributes. Our work, in contrast, retrieve objects based on contextual information about the task being specified by the natural language command. We are not performing inference over dialogue, but it is a natural next step for our work where our joint embedding can prove useful in the case of novel objects.
Similar to previous work, our work aims to learn joint object representations from visual and language information using RNNs. However, previous work primarily focuses on natural language commands specifying the object type and visual attributes, such as “scissors,” “red,” “curved,” “has handle.” In contrast, our work focuses on fulfilling commands requesting an object for a task specified by a verb, for example “Hand me something to cut.” To handle such commands, a possible approach is to rely on accurate classification of the object type and visual attributes and an external knowledge base to query for valid verb-object or verb-attribute pairings. However, that approach would be limited to known objects and words. Our work, on the other hand, bypasses explicit classification of object type and attributes, and directly maps object use that is specified by the verb to object appearance that is captured by the image. Our work uses the context of the verb to implicitly infer object attributes that are required for the task, and can generalize to unseen object classes and unknown nouns in the language commands.
To fulfill natural language commands requesting an object for a task specified by a verb, our model generates embeddings for the language command and candidate objects and selects the object that is closest to the command in embedding space. Our model is trained using pairs of natural language object requests containing verbs and ground truth objects that satisfy the requests. We describe our model and data collection process in detail in Sections III-A and III-B.
Given a natural language command and images of candidate objects, we want our model to correctly select the object that best satisfies the command. Our model does this by generating embeddings for the input natural language command and images, calculating the cosine similarities between the image embeddings and the language embedding, and selecting the image most similar to the command in embedding space. A diagram of our model is shown in Figure 2. Our model consists of separate image and language encoders, each in charge of generating embeddings for the input natural language commands and RGB images, respectively. During training, our model minimizes the cosine embedding loss between the embeddings of language command-RGB image pairs, thus maximizing the likelihood of the target image given the command. We describe the component image and language encoders and our model training process below.
Iii-A1 Image Encoder
To encode each RGB image, we use the average pooling layer of a pretrained ResNet101 . We chose ResNet101 due to ResNet’s good performance on robots . The use of deep pretrained representations enables our model to leverage prior information of complex image features to allow for better encoding of the visual information from the images. We, therefore, get an embedding of size 2048 from the pretrained ResNet model for each RGB image.
Iii-A2 Language Encoder
To encode each natural language command, our language encoder consists of a recurrent neural network (RNN) 
followed by a fully connected layer. We randomly initialize word embeddings for each language command that are then trained from scratch. The model, therefore, produces an embedding vector that is the same size of the embedding produced by the image encoder.
Iii-A3 Training Process
We train our model to optimize an objective function that attempts to bring the corresponding language and image embeddings closer to each other in embedding space. We achieve this by reducing the cosine embedding loss between the low-dimensional embeddings produced by the image encoder, which takes in an RGB image of the object, and the embedding produced by the language encoder, which takes in the referring natural language command, during training.
We describe the training data in Section III-B3. Positive training samples consist of pairs of natural language commands, each containing one verb, and RGB images of objects that can be paired with that verb. We obtain negative samples by randomly sampling an image of a different object that does not correspond with the verb and pairing the image with the language command, resulting in a dataset of equally balanced positive and negative samples. We use Adam 
as an optimiser with a learning rate of 0.0001 and train for 50 epochs until convergence.
Iii-B Data Collection
To train and evaluate our model, we require pairs of natural language commands containing verbs and RGB images of objects. To obtain these command-image pairs, we need verb-object pairs denoting valid object usage such as “cut” for a “knife.” We also require RGB images for the objects. Since we are interested in testing our model’s generalization capability on unseen object classes and nouns, we require a large number of object classes that can be paired with the verbs for a sufficient number of held-out object classes.
To the best of our knowledge, no existing datasets of verb-object pairs met our requirements. Chao et al.  mine the web for the knowledge of semantic affordance — given an object, determining whether an action can be performed on it — resulting in a dataset of verb-noun combinations. However, their dataset is only on 20 object classes, and focuses on verbs denoting actions that can be performed on the objects, such as “hunt” a “bird,” rather than the objects’ usage. Other works on semantic affordances [18, 5] also provide datasets of objects labeled with their affordances. However, these datasets are on fewer than 20 object classes and fewer than 10 affordances.
We, therefore, decided to collect our own dataset of valid verb-object pairs and use it to generate natural language commands paired with RGB images for our model. We describe our data below.
|contain – bucket||hit – hammer||wear – necklace|
|contain – wardrobe||hit – racket||wear – suit|
|cut – cleaver||play – baseball||wrap – cloak|
|cut – hatchet||play – violin||wrap – handkerchief|
|eat – banana||serve – plate||write – notebook|
|eat – pizza||serve – tray||write – quill|
Iii-B1 Vision Data
We use RGB images and object classes from the ILSVRC2012 validation set . We choose this dataset as it has 1000 object classes and a variety of images per object class, and we want our model to work on many different object classes and object instances. The ImageNet object classes such as “violin,” “suit,” and “quill” are usually nouns that occur frequently in textual data in correspondence with other verbs such as “play,” “wear,” “write.”
Iii-B2 Language Data
We extracted sentences from Wikipedia containing the ImageNet object classes and used spaCy  to parse the sentences and extract corresponding verb-object pairs. We originally sought out to extract verb-object pairs from the common-sense knowledge base ConceptNet , which ended up being too small and was missing many valid verb-object pairings. We then decided to use Wikipedia instead for its large text corpus. However, the resulting dataset was highly noisy with 20,198 verb-object pairs, containing many abstract verbs such as “name,” “feature,” “use,” or nouns in the wrong word sense such as “suit” in “follow suit” and “file suit” that were not relevant for the natural language object retrieval task we were interested in. Therefore, we manually annotated the verb-object pairs to retain only pairs that contain concrete verbs paired with nouns in the correct sense. This resulted in a dataset with 655 verb-object pairs over 50 verbs and 216 object classes. Example verb-object pairs from our dataset are shown in Table LABEL:tab:verb-obj.
|contain – cup||Give me an item that can contain|
|I need something to contain|
|play – drum||Hand me something to play|
|I want an object to play|
|wear – kimono||An item to wear|
|Give me something to wear|
Iii-B3 Training and Testing Data
We use 80% of the 216 object classes and their corresponding verb-object pairs to generate our training data. The training data consist of natural language command-RGB image pairs. For each verb-object pair, language commands are generated from the pair using templates, such as <Hand me something to> <verb>, and then paired with different image instances of the object class. Examples of the training data are shown in Table LABEL:tab:train-data. Rather than using only the verbs and/or nouns from the verb-object pairs as language data for our model, we generate and give our model natural language sentences so that it can handle more realistic language commands, as most people do not ask for objects with one or two-word commands such as “knife” or “knife cut.”
We hold out 20% of the object classes for testing. Test examples consisting of language command-set of five images pairs are randomly generated from objects in the test set and their corresponding verb-object pairs. The evaluation task is to select the correct object from a set of five images given a natural language command.
Average retrieval accuracies (with unseen object classes from the held-out object set) of models trained on different data sizes, represented by the solid lines, with vertical bars denoting standard errors. Models trained on larger data sizes usually perform better. All our models significantly outperform a random model, represented by the dashed lines. The dotted line represents the human object retrieval baseline.
Iv Experiments and Results
The aim of our evaluation is to test our model’s ability to accurately select objects based on natural language descriptions of their usage specified by verbs, given unseen object classes and unknown nouns in the language commands. Generalization to unseen object classes is much more difficult than just to unseen instances of known object classes, as different instances of the same object class such as two bottles would usually look more alike than instances from different object classes such as a bottle and a bowl, even if those object classes can be used for similar tasks such as “contain.”
The trained model is tested on natural language object retrieval tasks: retrieving the correct object from a set of five images of different objects, given a natural language command containing a verb that can only be paired with the correct object. The evaluation task is modeling a typical retrieval task in the wild where there are a few objects on a table and the robot has to pick the correct one. Retrieval examples consisting of a language command paired with a set of five images are randomly generated from objects in the test set and their corresponding verb-object pairs. We test our models on several different test sets and report average top-1 and top-2 retrieval accuracies. Top-1 accuracy means that the model’s top choice is the correct answer, and top-2 accuracy means that the correct answer is among the model’s top-2 choices.
|Model||Top-1 (Std. Error)||Top-2 (Std. Error)|
|Data size 535||51.0 (4.50)||71.0 (2.84)|
|Data size 1070||53.7 (0.86)||74.0 (1.60)|
|Data size 1605||58.7 (3.85)||77.0 (2.13)|
|Data size 2140||58.8 (3.31)||77.0 (2.50)|
|Data size 2675||59.0 (1.68)||76.9 (3.55)|
|Data size 3210||58.2 (1.70)||77.8 (2.30)|
|Data size 3745||62.3 (2.48)||79.8 (1.94)|
|Data size 4280||61.5 (2.25)||77.4 (2.44)|
|Data size 4815||61.5 (1.71)||77.7 (1.43)|
|Data size 5350||62.3 (2.18)||80.2 (1.23)|
|Human baseline||78.0 (1.72)|
Iv-a Held-out Object Set
We first test our model on object sets held out from our dataset, which have a similar image distribution to that of the training set, as the images all come from the ILSVRC2012 validation set. We evaluate our model on 2 different test splits representing increasingly difficult scenarios. We describe the test splits and our model’s performance in each case below. For both cases, the test objects are held-out, meaning our model has never seen any instances belonging to the test object classes during training.
Iv-A1 Unseen Object Classes
We first train and test our model on natural language commands containing only the verbs from the verb-object pairs, such as “Hand me something to <verb>.” This simplified setting where the test commands look like those in the training data, for example “Give me something to contain,” helps us look at how well the model has learned to generalize the concepts associated with the verbs, such as “contain” requires objects with convexity. It removes the additional challenges that might arise with seeing unseen nouns in the commands, such as the fact that the embeddings for these nouns would be untrained. However, this is still a challenging problem because the object classes in the test set have never been seen by the model before.
With 20% of the objects and corresponding verb-object pairs in our dataset held out for testing, the training set contains 535 verb-object pairs. We trained separate models on increasing sizes of training data generated from the 535 verb-object pairs. Training data was augmented by generating different natural language commands containing the verbs, and pairing the commands with different images of the objects from the verb-object pairs in the training set. Examples of the training data are shown in Table LABEL:tab:train-data. The test set with 43 held-out objects and 120 corresponding verb-object pairs and retrieval examples are fixed for all models.
We tested each model trained on different data sizes 5 times and report their average top-1 and top-2 retrieval accuracies and standard errors in Table LABEL:tab:heldout and Figure 3. Model performance generally increases with larger training size. All our models significantly outperform a random model (which has 20% top-1 and 45% top-2 retrieval accuracy) and achieve accuracies in the 50% – 62% range for top-1, and 70% – 80% for top-2. Our best average retrieval accuracy is 62.3% for top-1 and 80.2% for top-2 with standard errors of 2.18% and 1.23%, respectively. Our models were able to generalize to unseen object classes.
Our models were able to select the correct object to satisfy the task specified by most verbs in our dataset such as “contain,” “write,” “don,” “rotate,” “hit,” etc. The objects paired with these verbs usually have similar visual appearances and attributes, for example a gown and a suit can both be paired with “don” and are both made of fabric. However, our models performed imperfectly on more abstract verbs such as “play” and “protect” as it is less obvious which object attributes are required for the tasks specified by these verbs, and the objects that can satisfy the tasks come in a larger variety of visual appearances, for example a harp and a volleyball can both be paired with “play.”
Example success and failure cases for our best model are shown in Figures 4(a) and 4(b). Our model correctly selected images of screws and goblets to satisfy natural language commands “Hand me something to rotate” and ”Give me something with which I can serve,” respectively. The model failed to select the swing given the command “I want something to play,” and did not select the shield in response to “An object with which I can protect.” However, the instance of a shield in the object retrieval task shown in Figure 4(b)
does not look like a shield but more like a plate, and such object instance outliers can definitely throw the model off.
Iv-A2 Unseen Object Classes and Unknown Nouns
Next, we train and test our model on natural language commands containing both verbs and objects, for example “Give me the <object> to <verb>.” The model is tested on object retrieval tasks with both unseen object classes and unknown nouns. Testing our model in this setting is necessary because when a deep net such as our model is dealing with an unknown word, it will map the word to a random, untrained embedding. That random embedding could completely throw off the model’s understanding, for example the model might pick the image for whatever noun the random embedding happens to be closest to. We need to know how our model would behave with truly unknown words in the input to get a sense of how it would work in the real world.
An example task in this setting is the model getting the command “Give me the dax to cut” with “dax” being an unknown word to the model, while also being shown objects it has never seen before. This task is more difficult than object retrieval with only unseen object classes, as the model has to figure out that unknown words such as “dax” adds no information and avoid being affected by the noise added by the unknown words.
Other than the inclusion of nouns in the natural language commands, the setup for this experiment is the same as that with only unseen object classes, as described in Section IV-A1. Each model trained on different data sizes was tested 5 times. Our best average retrieval accuracy is 53.0% for top-1 and 72.8% for top-2 with standard errors of 1.33% and 3.11%, respectively. Our models were indeed negatively affected by the unknown words in the language commands. However, decline in performance is to be expected as this is a more difficult task. Furthermore, our models’ performance still demonstrate at least some generalization to unseen object classes and unknown nouns. A way to better handle unknown words and boost model performance in this setting would be to use pretrained word embeddings such as Word2vec  or GloVe  instead of random untrained embeddings.
Example success and failure cases for our best model are shown in Figures 4(c) and 4(d). Our model was able to correctly select the paintbrush when asked to “Bring me the paintbrush to write,” and picked the hammer to satisfy the command “Get me the hammer to hit.” Unfortunately, the model incorrectly selected the canoe and hammer given the commands “Pass me the puck to play,” and “I need the screw to insert,” respectively. However, from the given image, canoeing does seem like a fun activity and maybe even something to “play.” In addition, the image representing the hammer also includes a screwdriver, an object that can be used to “insert.”
Iv-B Human Retrieval Baseline
We also compare our models’ performance to a human baseline for the retrieval task. Humans are experts in natural language understanding and object grounding. The experiment was done on Amazon Mechanical Turk (AMT). We showed AMT workers five images and one language command such as “Give me something to <verb>,” and asked them to select the image with the object that best satisfies the command. The AMT interface and an example task for the experiment is shown in Figure 5. We collected 5 answers for each of the 120 retrieval tasks. The average top-1 human retrieval accuracy is 78.0% with standard error of 1.72%, shown in Table LABEL:tab:heldout and Figure 3(a). Even human users are not perfect at this task, as the given images of objects are not segmented and thus sometimes it can be confusing as to what object the image is supposed to be capturing, or the image only shows an partial/low-quality view of the object. In addition, the object usage being asked for in the language command can occasionally be unconventional such as using a “spoon” to “cut,” and thus might not be obvious to the average AMT worker who is spending very little time on each task. Our models’ performances are not as good as the human baseline but not far apart. Furthermore, the imperfect human performance proves how difficult of a task this is and how impressive our models’ results are.
Iv-C YCB Object Set
Finally, we run an evaluation to test whether the proposed model can perform natural language object retrieval on objects commonly seen and interacted with by real robots. For this evaluation, we test our best model on images of objects from the YCB Object and Model Set . The YCB object set is designed for benchmarking robotic manipulation and consists of objects of daily life with different shapes, sizes, textures, etc. We did not use the YCB object set as our training image set because it has a much smaller number of object classes and only 1 instance per object class in comparison to ImageNet’s 1000 object classes and 50 images per class.
|construct – power drill||eat – apple||play – tennis ball|
|contain – chips can||grow – pear||rotate – adjustable wrench|
|contain – windex bottle||hit – spoon||serve – bowl|
|cut – scissors||open – padlock||write – large marker|
Of the 65 object classes with corresponding RGB images in the YCB dataset, we select 33 object classes to test our model on, excluding classes our model has seen during training and picking only one class in the case of identical objects of differing sizes such as “S clamp,” “M clamp,” “L clamp,” “XL clamp.” Each object class in the YCB dataset is represented by one object instance, with corresponding RGB images of the object instance from multiple camera angles. We represent each selected object class by a single front-facing image of the object, taken from the YCB dataset. From the 50 verbs our model was trained on, we select 11 verbs (shown in Table LABEL:tab:ycb) that are most compatible with the 33 YCB objects and annotated valid verb-object pairings among the selected objects and verbs, resulting in 64 verb-object pairs. Examples of the annotated verb-object pairs are shown in Table LABEL:tab:ycb-vo. Natural language commands containing only the verbs were generated from the verb-object pairs using templates, and retrieval examples consisting of sets of five images paired with language commands were randomly generated from the annotated verb-object pairs.
Our model, without being retrained on images from the YCB dataset, was tested 5 times and achieved average retrieval accuracies of 54.7% and 71.9% with standard errors of 1.99% and 2.40% for top-1 and top-2, respectively. Although these results are far from perfect, they still demonstrate generalization on a dataset with a different distribution from the model’s training data. In addition, these results would enable the robot to significantly reduce its search space from all the candidate objects, and can employ strategies such as question asking to further disambiguate and retrieve the correct object.
Notably, our model correctly identified a fork, a spoon, and scissors as objects that can be used to cut, while only having seen knife-like object classes such as cleavers and hatchets paired with the verb “cut” in its training data. In addition, our model selected a chips can and mustard bottle when asked for something to “eat,” which in retrospect are very reasonable pairings that we mistakenly left out of our verb-object pair annotations.
Iv-D Robot Demonstrations
We implement our trained model on a KUKA LBR iiwa robot arm with a Robotiq 3-finger adaptive gripper. We pass a natural language command into our model along with manually segmented RGB images of objects in the scene, captured by an Intel RealSense camera. The robot then grasps the observed object with the highest cosine similarity in embedding space with the language command. We use object classes that our model has not seen during training for the demonstrations.
We tested our robot on four object retrieval tasks. Images capturing the tasks are shown in Figure 6. The robot correctly selected the T-shirt for the task of “Give me something to wear.” When asked to “Give me an item that can write,” it was able to pick out the marker from other distracting objects that are also partly red and have slim bodies. Next, it accurately identified the pear and chips can as the top two items that would satisfy “Hand me something to eat.” This is the only test case with more than one possible correct answer. Finally, when asked for “An object to contain,” the robot selected the empty Minion-shaped bottle. Video recordings of the robot demonstrations can be found online333https://youtu.be/WMAdGhMmXEQ.
We mostly use YCB objects for the demonstrations with the exception of the Minion-shaped bottle in the last case, which was to test our model on an odd-looking object. While most of these are common objects we see in our daily life, not all of them belong to the COCO dataset of common objects in context. The objects that are not part of the 91 object types in COCO are the T-shirt, marker, pear, clamp, lock, and of course Minion bottle. As it was trained on the COCO dataset, Mask R-CNN , the state-of-the-art method for object segmentation and classification, was unable to correctly segment and classify these six objects. With such classification results, relying on accurate classification of objects and querying of an external knowledge base for valid verb-object pairs to select the object that satisfies the language command does not work in these cases. In contrast, our model was able to select the correct object based on the command without needing to explicitly classify the candidate objects or having seen the object classes.
Understanding open-ended natural language commands is a challenging but important problem. We address a sliver of the problem by focusing on object retrieval based on descriptions of the object’s usage. We propose an object retrieval model that learns from contextual information from both language and vision to generalize to unseen object classes and unknown nouns. Given natural language commands, our model correctly selects objects out of sets of five candidates, and achieves an average accuracy of 62.3% on a held-out set of unseen ImageNet object classes and 53.0% on unseen object classes and unknown nouns. Our model also achieves an accuracy of 54.7% on unseen YCB object classes. We demonstrate our model on a KUKA LBR iiwa robot arm, enabling the robot to retrieve objects based on natural language descriptions of their usage. Along with our model, we also present a newly created dataset of 655 verb-object pairs denoting object usage over 50 verbs and 216 object classes, as well as the methods used to create this dataset. To the best of our knowledge, this is the first dataset built to perform this task, and could potentially be used for a range of object retrieval tasks.
Our model currently allows us to reduce the problem of task based object retrieval to an attribute classification problem. However, a much richer model would perform explicit inference to determine the desired object from oblique natural language. Incorporating dialogue into this framework to perform inference can be a way to incorporate human preference more directly and provide a more intuitive interface.
The authors would like to thank Prof. James Tompkin for advice on selecting the image dataset and encoder, and Eric Rosen for help with video editing. This work is supported by the National Science Foundation under award numbers IIS-1652561 and IIS-1717569, NASA under award number NNX16AR61G, and with support from the Hyundai NGV under the Hyundai-Brown Idea Incubation award and the Alfred P. Sloan Foundation.
-  (2015) The YCB object and Model set: Towards common benchmarks for manipulation research. In Proceedings of the IEEE International Conference on Advanced Robotics, pp. 510–517. Cited by: §IV-C.
Mining Semantic Affordances of Visual Object Categories.
Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4259–4267. Cited by: §III-B.
-  (2018) Text2Shape: Generating Shapes from Natural Language by Learning Joint Embeddings. In Asian Conference on Computer Vision, pp. 100–116. Cited by: §I, §II.
-  (2019) Grounding Language Attributes to Objects using Bayesian Eigenobjects. In Proceedings of the IEEE International Conference on Intelligent Robots and Systems, Cited by: §I, §II.
AffordanceNet: An End-to-End Deep Learning Approach for Object Affordance Detection. In Proceedings of the IEEE International Conference on Robotics and Automation, pp. 1–5. Cited by: §III-B.
-  (1990) Finding Structure in Time. Cognitive Science 14 (2), pp. 179–211. External Links: Cited by: §III-A2.
-  (2018) Interactively Picking Real-World Objects with Unconstrained Spoken Language Instructions. In Proceedings of the IEEE International Conference on Robotics and Automation, pp. 3774–3781. Cited by: §II.
-  (2017) Mask R-CNN. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2961–2969. Cited by: §IV-D.
-  (2016) Deep Residual Learning for Image Recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778. Cited by: §III-A1.
spaCy 2: natural language understanding with Bloom embeddings, convolutional neural networks and incremental parsing. Note: To appear Cited by: §III-B2.
-  (2016) Natural Language Object Retrieval. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4555–4564. Cited by: §I, §II.
-  (2014) Adam: a method for stochastic optimization. arXiv preprint arXiv:1412.6980. Cited by: §III-A3.
-  (2013) Jointly Learning to Parse and Perceive: Connecting Natural Language to the Physical World. Transactions of the Association for Computational Linguistics 1, pp. 193–206. Cited by: §I, §II.
-  (2014) Microsoft COCO: Common Objects in Context. In European Conference on Computer Vision, pp. 740–755. Cited by: §IV-D.
-  (2018) Deep Learning based Object Recognition for Robot picking task. In Proceedings of the 12th International Conference on Ubiquitous Information Management and Communication, pp. 1–9. Cited by: §III-A1.
-  (2014) Deep Captioning with Multimodal Recurrent Neural Networks (m-RNN). arXiv preprint arXiv:1412.6632. Cited by: §I, §II.
Efficient Estimation of Word Representations in Vector Space. arXiv preprint arXiv:1301.3781. Cited by: §IV-A2.
-  (2015) Affordance Detection of Tool Parts from Geometric Features. In Proceedings of the IEEE International Conference on Robotics and Automation, pp. 1374–1381. Cited by: §III-B.
-  (2012) SUN Attribute Database: Discovering, Annotating, and Recognizing Scene Attributes. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2751–2758. Cited by: §I, §II.
GloVe: Global Vectors for Word Representation.
Proceedings of the Conference on Empirical Methods in Natural Language Processing, pp. 1532–1543. Cited by: §IV-A2.
-  (2015) ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision 115 (3), pp. 211–252. External Links: Cited by: §I, §III-B1.
-  (2018) Interactive Visual Grounding of Referring Expressions for Human-Robot Interaction. arXiv preprint arXiv:1806.03831. Cited by: §II.
ConceptNet 5.5: An Open Multilingual Graph of General Knowledge.
Thirty-First AAAI Conference on Artificial Intelligence, Cited by: §III-B2.
-  (2015) Show and Tell: A Neural Image Caption Generator. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3156–3164. Cited by: §I, §II.
-  (2017) Reducing Errors in Object-Fetching Interactions through Social Feedback. In Proceedings of the IEEE International Conference on Robotics and Automation, pp. 1006–1013. Cited by: §II.
Show, Attend and Tell: Neural Image Caption Generation with Visual Attention.
International Conference on Machine Learning, pp. 2048–2057. Cited by: §I, §II.