instruction
stringlengths 999
2.35k
| input
stringlengths 341
562
| output
dict |
|---|---|---|
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_salt', 'microwave', 'freezer', 'walllamp', 'bathroom', 'cpuscreen', 'bathroom_counter', 'ceiling', 'keyboard', 'computer', 'food_bacon', 'table_cloth', 'ceilinglamp', 'faucet', 'picture', 'clothes_socks', 'towel', 'dining_room', 'wall', 'pasta', 'bed', 'centerpiece', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'light', 'table', 'colander']
Task:Clean screen
response:
{
"thoughts": Use a soft rag to wipe the screen until there are no marks on it.,
"actions": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <computer>', '[WIPE] <computer>', '[PUTOBJBACK] <rag>']
}
|
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'fork', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'character', 'alcohol', 'faucet', 'mousepad', 'dustpan', 'wall', 'nightstand', 'oven', 'cup', 'photoframe', 'coffe_maker', 'razor', 'after_shave', 'cards', 'dishrack', 'sink', 'spoon', 'bathroom_cabinet', 'clothes_skirt', 'vase', 'clothes_shirt', 'dirt']
Task:Shut off alarm
response:
| {
"thoughts": "Shutting of the alarm clock",
"actions": [
"[WALK] <bedroom>",
"[WALK] <alarm_clock>",
"[FIND] <alarm_clock>",
"[GRAB] <alarm_clock>",
"[SWITCHOFF] <alarm_clock>",
"[PUTOBJBACK] <alarm_clock>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'walllamp', 'bathroom', 'trashcan', 'dough', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'faucet', 'window', 'food_noodles', 'mousepad', 'pillow', 'dining_room', 'wall', 'bed', 'food_food', 'razor', 'rag', 'console', 'mouse', 'towel_rack', 'kitchen_counter', 'door', 'sink', 'bathtub', 'bathroom_cabinet']
Task:Clean sink
response:
{
"thoughts": Take a premoistened cleaning wipe and wipe down top of sink and faucet. Next clean the sink bowl. Let air dry.,
"actions": ['[WALK] <bathroom>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[WIPE] <faucet>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>']
}
|
Scene_Objects:['chair', 'walllamp', 'bills', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'television', 'toothbrush_holder', 'wine', 'doorjamb', 'mouse', 'dresser', 'hairbrush', 'controller', 'clothes_dress', 'home_office', 'light', 'table']
Task:Turn on computer
response:
| {
"thoughts": "Press the power button on the computer to turn it on",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[SWITCHON] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'scissors', 'tablelamp', 'crayon', 'microwave', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'longboard', 'shampoo', 'dvd_player', 'folder', 'mail', 'bookmark', 'toaster', 'shower', 'homework', 'couch', 'bed', 'clothes_gloves', 'towel_rack', 'mouse', 'pencil', 'cupboard', 'maindoor', 'table', 'laser_pointer']
Task:Pet cat
response:
{
"thoughts": I walk into the living room and I pet the cat,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['pot', 'jelly', 'chair', 'phone', 'ceiling', 'desk', 'bedroom', 'table_cloth', 'bookmark', 'stovefan', 'mat', 'tvstand', 'stereo', 'shoe-shine_kit', 'faucet', 'toaster', 'mousepad', 'powersocket', 'cutting_board', 'shelf', 'food_cheese', 'television', 'wooden_spoon', 'after_shave', 'food_onion', 'doorjamb', 'shoes', 'dishrack', 'vase', 'electrical_outlet']
Task:Turn on radio
response:
| {
"thoughts": "Go to the radio. Switch on the power button. Tune the station. Set the volume. Listen to the music.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[FIND] <electrical_outlet>",
"[TURNTO] <electrical_outlet>",
"[PLUGIN] <stereo>",
"[SWITCHON] <electrical_outlet>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'cat', 'food_carrot', 'toothbrush', 'drawing', 'orchid', 'floor', 'mail', 'stovefan', 'ceilinglamp', 'window', 'mousepad', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'photoframe', 'mouthwash', 'tray', 'curtain', 'coffee_pot', 'pajamas', 'door', 'sink', 'bathroom_cabinet', 'table', 'light', 'tooth_paste']
Task:Relax
response:
{
"thoughts": Lie down on the couch.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['toilet', 'walllamp', 'bathroom', 'drawing', 'knife', 'laptop', 'tvstand', 'faucet', 'shower', 'window', 'mat', 'clothes_socks', 'closetdrawer', 'pillow', 'photoframe', 'standingmirror', 'newspaper', 'toothbrush_holder', 'lighter', 'centerpiece', 'kitchen_counter', 'shoes', 'cd', 'hair', 'conditioner', 'maindoor', 'bathtub', 'sink', 'table', 'vase']
Task:Leave home
response:
| {
"thoughts": "Put on shoes. Put on coat. Open door and exit through it. Lock door behind you.",
"actions": [
"[WALK] <home_office>",
"[WALK] <shoes>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PUTON] <shoes>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bookshelf', 'computer', 'stovefan', 'toaster', 'food_noodles', 'wall', 'oven', 'toy', 'food_vegetable', 'food_food', 'video_game_controller', 'water', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'dishwasher', 'scrabble']
Task:Cook some food
response:
{
"thoughts": walk to kicthen , find stove , find cooking pot , find vegetables , find water ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove,
"actions": ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[FIND] <pot>', '[FIND] <food_vegetable>', '[FIND] <water>', '[GRAB] <water>', '[WASH] <food_vegetable>', '[POUR] <water> <pot>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <oven>', '[SWITCHON] <oven>']
}
|
Scene_Objects:['pot', 'food_pizza', 'filing_cabinet', 'microwave', 'chair', 'bathroom', 'orchid', 'character', 'desk', 'bedroom', 'thread', 'computer', 'brush', 'ceilinglamp', 'faucet', 'stereo', 'closetdrawer', 'dining_room', 'wall', 'pasta', 'toy', 'cup', 'standingmirror', 'television', 'wine', 'doorjamb', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'clothes_shirt']
Task:Open door
response:
| {
"thoughts": "Open the door when leaving or coming in.",
"actions": [
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'tea_bag', 'mat', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'photoframe', 'check', 'mouthwash', 'food_food', 'food_donut', 'wine', 'curtain', 'doorjamb', 'console', 'dresser', 'door', 'light']
Task:Pick up toys
response:
{
"thoughts": Bend down and pick up the toys off of the floor.,
"actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>']
}
|
Scene_Objects:['drawing', 'hanger', 'floor', 'ceiling', 'computer', 'brush', 'mat', 'ceilinglamp', 'faucet', 'stovefan', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cutting_board', 'shelf', 'toy', 'standingmirror', 'television', 'curtain', 'doorjamb', 'towel_rack', 'controller', 'home_office', 'table', 'soap', 'shoe_rack']
Task:Turn off TV
response:
| {
"thoughts": "Walk over to tv and press power button",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[SWITCHOFF] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Browse internet
response:
{
"thoughts": I go to the living room, where my computer is. I locate it, switch it on and type desired URL adress in the web browser.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Scene_Objects:['food_bread', 'microwave', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'alcohol', 'piano_bench', 'stovefan', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'oil', 'food_peanut_butter', 'creditcard', 'form', 'wall', 'nightstand', 'oven', 'cutting_board', 'toy', 'newspaper', 'coffe_maker', 'tray', 'kitchen_counter', 'dresser', 'sink', 'electrical_outlet']
Task:Toast bread
response:
| {
"thoughts": "Place two slices of bread in the toaster. Select medium toast on toaster. Push down button to begin toasting.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_bread>",
"[GRAB] <food_bread>",
"[CLOSE] <freezer>",
"[WALK] <electrical_outlet>",
"[FIND] <toaster>",
"[PLUGIN] <toaster>",
"[PUTBACK] <food_bread> <toaster>",
"[SWITCHON] <electrical_outlet>",
"[TURNTO] <toaster>",
"[LOOKAT] <toaster>",
"[SWITCHON] <toaster>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'tablelamp', 'juice', 'scissors', 'beer', 'chair', 'freezer', 'bathroom', 'ceilingfan', 'hanger', 'floor', 'computer', 'food_bacon', 'mat', 'couch', 'creditcard', 'dining_room', 'oven', 'tape', 'bed', 'light_bulb', 'novel', 'food_food', 'mouse', 'cupboard', 'conditioner', 'home_office', 'table', 'scrabble', 'shoe_rack']
Task:Pet dog
response:
{
"thoughts": Pet my dog in hall,
"actions": ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']
}
|
Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'laptop', 'faucet', 'mat', 'closetdrawer', 'teeth', 'dining_room', 'wall', 'pasta', 'toy', 'shelf', 'standingmirror', 'novel', 'check', 'television', 'curtain', 'console', 'dresser', 'napkin', 'table', 'light', 'scrabble', 'coffee']
Task:Look at painting
response:
| {
"thoughts": "Walk to the painting. Look up at the painting. Admire it on the wall.",
"actions": [
"[WALK] <home_office>",
"[WALK] <drawing>",
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'photoframe', 'novel', 'television', 'mouse', 'kitchen_counter', 'door', 'sink', 'clothes_skirt', 'clothes_shirt']
Task:Read book
response:
{
"thoughts": Go to home office, find the book. Sit in the chair and read the book.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}
|
Scene_Objects:['spectacles', 'measuring_cup', 'blow_dryer', 'ground_coffee', 'bathroom', 'cat', 'phone', 'ceiling', 'character', 'man', 'keyboard', 'computer', 'mat', 'window', 'mousepad', 'clothes_pants', 'powersocket', 'cutting_board', 'cup', 'standingmirror', 'bed', 'coffe_maker', 'television', 'food_rice', 'wine', 'controller', 'sink', 'napkin', 'laser_pointer', 'shoe_rack']
Task:Answer door
response:
| {
"thoughts": "Walk up to the door. Open the door and greet whomever is out side",
"actions": [
"[WALK] <home_office>",
"[WALK] <man>",
"[FIND] <man>",
"[GREET] <man>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'beer', 'chair', 'bills', 'knife', 'hanger', 'bathroom_counter', 'floor', 'computer', 'stovefan', 'mat', 'tvstand', 'window', 'couch', 'pillow', 'towel', 'dining_room', 'food_kiwi', 'wall', 'toy', 'photoframe', 'novel', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'bag', 'table']
Task:Read book
response:
{
"thoughts": Sit on couch. Grab book. Open book. Read book.,
"actions": ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['fork', 'beer', 'microwave', 'freezer', 'walllamp', 'dough', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'oven', 'cutting_board', 'shelf', 'coffe_maker', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'kitchen_counter', 'maindoor', 'bathtub', 'table']
Task:Drink
response:
| {
"thoughts": "Get a can of beer, open it, sit on couch, relax",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <beer>",
"[GRAB] <beer>",
"[CLOSE] <freezer>",
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[DRINK] <beer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'orchid', 'hanger', 'phone', 'computer', 'piano_bench', 'nightstand', 'pasta', 'wall_clock', 'powersocket', 'toy', 'food_cheese', 'clothes_gloves', 'check', 'toilet_paper', 'television', 'after_shave', 'doorjamb', 'door', 'hairdryer', 'sink', 'home_office', 'light', 'table', 'clothes_scarf', 'soap']
Task:Read book
response:
{
"thoughts": go to bedroom, sit down, pick up book, read,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['sponge', 'scissors', 'tablelamp', 'measuring_cup', 'microwave', 'chair', 'band-aids', 'bathroom', 'milk', 'wallshelf', 'phone', 'character', 'computer', 'mail', 'button', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'standingmirror', 'centerpiece', 'kitchen_counter', 'shoes', 'maindoor', 'sink', 'bathtub', 'bathroom_cabinet', 'table']
Task:Turn off light
response:
| {
"thoughts": "Walk to the lamp. Find the switch. Click the switch off.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <floor_lamp>",
"[SWITCHOFF] <floor_lamp>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'band-aids', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'homework', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'keys', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'light', 'soap']
Task:Change TV channels
response:
{
"thoughts": Take remote. Change to desired channel by you.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['food_bread', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'needle', 'floor', 'phone', 'mail', 'mat', 'plate', 'faucet', 'stereo', 'couch', 'dustpan', 'dining_room', 'wall', 'bench', 'oven', 'toy', 'cup', 'newspaper', 'standingmirror', 'food_food', 'razor', 'console', 'towel_rack', 'bathtub', 'table']
Task:Set up table
response:
| {
"thoughts": "Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <plate>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <plate> <table>",
"[WALK] <dining_room>",
"[WALK] <plate>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <plate> <table>",
"[WALK] <dining_room>",
"[WALK] <plate>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <plate> <table>",
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <food_food> <table>",
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <food_food> <table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'toaster', 'plate', 'faucet', 'stereo', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bathtub', 'dishwasher', 'clothes_skirt', 'laser_pointer']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Take a dish and put it in the dishwasher to be washed,
"actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['blow_dryer', 'bathroom', 'food_carrot', 'toothbrush', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'mousepad', 'closetdrawer', 'clothes_pants', 'wall', 'powersocket', 'bench', 'cutting_board', 'bed', 'photoframe', 'television', 'food_onion', 'mouse', 'dresser', 'hairbrush', 'controller', 'light', 'clothes_shirt']
Task:Organize closet
response:
| {
"thoughts": "Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[PULL] <clothes_pants>",
"[PUTIN] <clothes_pants> <dresser>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[PULL] <clothes_pants>",
"[PUTIN] <clothes_pants> <dresser>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUSH] <clothes_shirt>",
"[PUTIN] <clothes_shirt> <dresser>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUSH] <clothes_shirt>",
"[PUTIN] <clothes_shirt> <dresser>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[CLOSE] <dresser>",
"[WALK] <basket_for_clothes>",
"[PUTBACK] <clothes_shirt> <basket_for_clothes>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'freezer', 'drawing', 'needle', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'dustpan', 'dining_room', 'wall', 'nightstand', 'powersocket', 'food_food', 'toilet_paper', 'doorjamb', 'coffee_pot', 'mouse', 'kettle', 'dresser', 'light']
Task:Turn on light
response:
{
"thoughts": walk into living room, walk to light, turn on light switch.,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['tablelamp', 'microwave', 'freezer', 'walllamp', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'mail', 'stovefan', 'laptop', 'window', 'towel', 'dining_room', 'food_kiwi', 'wall', 'oven', 'cutting_board', 'bed', 'coffe_maker', 'food_food', 'check', 'tray', 'kitchen_counter', 'dishrack', 'conditioner', 'food_steak', 'bathtub', 'table', 'vase']
Task:Look in refrigerator
response:
| {
"thoughts": "Approach the refrigerator. Use the handle to open the refrigerator door. Look at each shelf of the refrigerator. Look in each refrigerator drawer. Close the refrigerator door.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[TURNTO] <freezer>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[TURNTO] <freezer>",
"[LOOKAT] <freezer>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <food_food>",
"[CLOSE] <kitchen_cabinet>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'detergent', 'milk', 'knifeblock', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'faucet', 'iron', 'couch', 'wall', 'oven', 'food_food', 'television', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'laser_pointer', 'scrabble']
Task:Cook some food
response:
{
"thoughts": Cooking a meal,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[CLOSE] <kitchen_cabinet>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <pot> <sink>', '[GRAB] <pot>', '[SWITCHOFF] <faucet>', '[WALK] <oven>', '[PUTBACK] <pot> <oven>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[CLOSE] <freezer>', '[WALK] <oven>', '[PUTBACK] <food_food> <pot>', '[SWITCHON] <oven>']
}
|
Scene_Objects:['pot', 'crayon', 'chair', 'bathroom', 'food_butter', 'phone', 'ceiling', 'bedroom', 'tea_bag', 'laptop', 'ceilinglamp', 'shower', 'iron', 'clothes_socks', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'standingmirror', 'photoframe', 'toothbrush_holder', 'food_donut', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'controller', 'door', 'table']
Task:Switch on lamp
response:
| {
"thoughts": "Press the button so the light comes on.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <floor_lamp>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'filing_cabinet', 'mop', 'microwave', 'dog', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'form', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'centerpiece', 'sink', 'scrabble']
Task:Relax on sofa
response:
{
"thoughts": I walk into the living room. I bend down. I sit on the sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'window', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'nightstand', 'cutting_board', 'shelf', 'clothes_gloves', 'food_food', 'coffe_maker', 'wooden_spoon', 'tray', 'kitchen_counter', 'sink', 'bathroom_cabinet']
Task:Keep an eye on stove as something is cooking
response:
| {
"thoughts": "Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done",
"actions": [
"[WALK] <dining_room>",
"[WALK] <oven>",
"[FIND] <pot>",
"[TURNTO] <pot>",
"[LOOKAT] <pot>",
"[FIND] <wall_clock>",
"[TURNTO] <wall_clock>",
"[LOOKAT] <wall_clock>",
"[SWITCHOFF] <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'chair', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'toaster', 'mat', 'ceilinglamp', 'plate', 'stovefan', 'dish_soap', 'broom', 'wall', 'bench', 'food_food', 'coffe_maker', 'tray', 'wooden_spoon', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'table', 'dishwasher', 'instrument_violin']
Task:Wash dishes with dishwasher
response:
{
"thoughts": I go the in kitchen then grab the plate on the table. I put the plate and dish soap in the dishwasher. Finally, I turn on the dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'freezer', 'blow_dryer', 'walllamp', 'nail_polish', 'bathroom', 'toothbrush', 'drawing', 'hanger', 'floor', 'shampoo', 'character', 'desk', 'bookshelf', 'purse', 'envelope', 'mat', 'ceilinglamp', 'window', 'towel', 'wall', 'powersocket', 'toy', 'cup', 'food_food', 'coffe_maker', 'sink', 'duster']
Task:Dust
response:
| {
"thoughts": "Apply duster to shelves and clean them until dust is gone",
"actions": [
"[WALK] <home_office>",
"[WALK] <duster>",
"[FIND] <duster>",
"[GRAB] <duster>",
"[FIND] <filing_cabinet>",
"[WIPE] <filing_cabinet>",
"[PUTOBJBACK] <duster>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'microwave', 'trashcan', 'hanger', 'floor', 'bedroom', 'computer', 'button', 'brush', 'mat', 'shower', 'faucet', 'window', 'clothes_hat', 'wall', 'child', 'oven', 'bed', 'newspaper', 'novel', 'curtain', 'centerpiece', 'doorjamb', 'mouse', 'cd', 'dresser', 'hairdryer', 'clothes_scarf', 'vase', 'board_game']
Task:Story reading time
response:
{
"thoughts": Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures,
"actions": ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[TURNTO] <child>', '[LOOKAT] <child>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['dry_pasta', 'glue', 'blender', 'food_salt', 'character', 'bedroom', 'mat', 'tvstand', 'food_noodles', 'garbage_can', 'couch', 'nightstand', 'wall_clock', 'bench', 'powersocket', 'toy', 'cutting_board', 'tape', 'food_vegetable', 'food_food', 'food_donut', 'tray', 'mouse', 'pencil', 'door', 'bathtub', 'home_office', 'table', 'colander', 'pantry']
Task:Organize pantry
response:
| {
"thoughts": "Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <pantry>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>",
"[FIND] <garbage_can>",
"[PUTBACK] <food_food> <garbage_can>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[TURNTO] <food_vegetable>",
"[LOOKAT] <food_vegetable>",
"[PUTBACK] <food_vegetable> <garbage_can>",
"[FIND] <dry_pasta>",
"[GRAB] <dry_pasta>",
"[TURNTO] <dry_pasta>",
"[LOOKAT] <dry_pasta>",
"[PUTOBJBACK] <dry_pasta>",
"[FIND] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>",
"[PUSH] <food_food>",
"[FIND] <food_noodles>",
"[GRAB] <food_noodles>",
"[TURNTO] <food_noodles>",
"[LOOKAT] <food_noodles>",
"[PUTOBJBACK] <food_noodles>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_ice_cream', 'freezer', 'walllamp', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'oven', 'powersocket', 'cup', 'ice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']
Task:Get something to drink
response:
{
"thoughts": Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[CLOSE] <freezer>', '[POUR] <milk> <cup>', '[DRINK] <cup>']
}
|
Scene_Objects:['measuring_cup', 'dog', 'chair', 'dough', 'wallshelf', 'hanger', 'cleaning_solution', 'keyboard', 'computer', 'ceilinglamp', 'plate', 'shower', 'faucet', 'window', 'homework', 'clothes_hat', 'nightstand', 'wall_clock', 'cup', 'photoframe', 'novel', 'check', 'oven_mitts', 'curtain', 'rag', 'towel_rack', 'shoes', 'hairbrush', 'maindoor', 'spoon']
Task:Clean mirror
response:
| {
"thoughts": "Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[POUR] <cleaning_solution> <rag>",
"[PUTOBJBACK] <cleaning_solution>",
"[WALK] <mirror>",
"[WIPE] <mirror>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'food_salt', 'milk', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'photoframe', 'check', 'mouthwash', 'razor', 'television', 'coin', 'coffe_maker', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'table']
Task:Relax on sofa
response:
{
"thoughts": I walk into the living room and I lie down on the sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['microwave', 'chair', 'jelly', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'laptop', 'stovefan', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'table']
Task:Use laptop
response:
| {
"thoughts": "Sit down on a couch and perform tasks such as navigating the internet on a laptop",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <laptop>",
"[SWITCHON] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[TURNTO] <keyboard>",
"[LOOKAT] <keyboard>",
"[TYPE] <keyboard>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'toilet', 'bathroom', 'trashcan', 'milk', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'clothes_jacket', 'toaster', 'stovefan', 'tvstand', 'picture', 'window', 'dustpan', 'pillow', 'dining_room', 'wall', 'box', 'bed', 'wine', 'curtain', 'kettle', 'home_office', 'light', 'dishwasher']
Task:Look out window
response:
{
"thoughts": I head into my child's room and look out the window to view the neighborhood from a different area in the house.,
"actions": ['[WALK] <bedroom>', '[WALK] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']
}
|
Scene_Objects:['pot', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'dough', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'wall', 'powersocket', 'shelf', 'toilet_paper', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'light', 'table', 'vase']
Task:Vacuum
response:
| {
"thoughts": "Keep my keyboard vacuumed and free of debris.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'bed', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:
{
"thoughts": Type on a computer in the home office.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Scene_Objects:['microwave', 'chair', 'dog', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'powersocket', 'box', 'television', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'door', 'bathtub', 'light', 'table']
Task:Clean screen
response:
| {
"thoughts": "Use a soft rag to wipe the screen until there are no marks on it.",
"actions": [
"[WALK] <home_office>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <computer>",
"[WIPE] <computer>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'button', 'ceilinglamp', 'faucet', 'oil', 'teeth', 'clothes_hat', 'towel', 'wall', 'photoframe', 'bed', 'doorjamb', 'diary', 'kitchen_counter', 'dishrack', 'coffee', 'hairbrush', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Go to the bathroom. Turn on the sink. Rinse hands. Apply soap and scrub your hands together. Rinse hands again. Turn off faucet. Dry hands on a towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['glue', 'pot', 'filing_cabinet', 'food_bread', 'microwave', 'walllamp', 'dough', 'woman', 'toothbrush', 'wallshelf', 'ceiling', 'character', 'man', 'toaster', 'stereo', 'window', 'couch', 'dustpan', 'pillow', 'nightstand', 'bench', 'newspaper', 'keys', 'standingmirror', 'television', 'curtain', 'sink', 'instrument_guitar', 'table', 'light']
Task:Greet guests
response:
| {
"thoughts": "Stand next to the door. When the door opens from the outside, greet the guests.",
"actions": [
"[RUN] <home_office>",
"[WALK] <woman>",
"[FIND] <woman>",
"[TURNTO] <woman>",
"[LOOKAT] <woman>",
"[GREET] <woman>",
"[FIND] <man>",
"[TURNTO] <man>",
"[LOOKAT] <man>",
"[GREET] <man>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'laptop', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dishrack', 'door', 'light', 'shoe_rack']
Task:Browse internet
response:
{
"thoughts": Walk to home office, walk to desk, sit in chair, turn on laptop, grab mouse, open a web page to look at it, move mouse, keep looking at laptop screen.,
"actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']
}
|
Scene_Objects:['food_butter', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'bench', 'cutting_board', 'cup', 'check', 'food_donut', 'food_rice', 'curtain', 'centerpiece', 'mouse', 'vacuum_cleaner', 'shoes', 'dresser', 'light', 'teeth']
Task:Vacuum
response:
| {
"thoughts": "Run the vacuum cleaner across the floor, back and forth a couple of times until clean.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[WALK] <dresser>",
"[PUTIN] <vacuum_cleaner> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'remote_control', 'alcohol', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'curtain', 'rag', 'doorjamb', 'dresser', 'table', 'clothes_skirt']
Task:Watch TV
response:
{
"thoughts": go to living room, sit on couch, get remote, switch on tv, watch tv,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>']
}
|
Scene_Objects:['fork', 'filing_cabinet', 'juice', 'freezer', 'walllamp', 'drawing', 'orchid', 'phone', 'ceiling', 'character', 'cleaning_solution', 'button', 'toaster', 'ceilinglamp', 'homework', 'oil', 'mousepad', 'pillow', 'dining_room', 'food_kiwi', 'pasta', 'oven', 'coffe_maker', 'food_food', 'television', 'rag', 'towel_rack', 'bathtub', 'instrument_guitar', 'vase']
Task:Clean
response:
| {
"thoughts": "Spray counter tops with all purpose cleaner. Using towel, wipe counter, removing all dirt and grime until clean.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[PUTOBJBACK] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'beer', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'foundation', 'window', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'door', 'table', 'light']
Task:Change TV channel
response:
{
"thoughts": Walk into the Living room. Find the television remote. Use it to turn on the television. Point the remote at the television. Press the channel button on the remote.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>']
}
|
Scene_Objects:['tablelamp', 'food_salt', 'microwave', 'chair', 'blow_dryer', 'nail_polish', 'trashcan', 'dough', 'needle', 'cpuscreen', 'stamp', 'thread', 'stereo', 'floor_lamp', 'mousepad', 'form', 'pillow', 'dining_room', 'nightstand', 'oven', 'bench', 'cup', 'standingmirror', 'coffe_maker', 'food_donut', 'kettle', 'door', 'home_office', 'light', 'vase']
Task:Clean
response:
| {
"thoughts": "Clean lamp",
"actions": [
"[WALK] <home_office>",
"[WALK] <paper_towel>",
"[FIND] <paper_towel>",
"[GRAB] <paper_towel>",
"[WALK] <floor_lamp>",
"[SWITCHOFF] <floor_lamp>",
"[WIPE] <floor_lamp>",
"[FIND] <trashcan>",
"[PUTBACK] <paper_towel> <trashcan>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'glue', 'toilet', 'chair', 'detergent', 'dough', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'keyboard', 'alcohol', 'stovefan', 'ceilinglamp', 'couch', 'microphone', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'doorjamb', 'kitchen_counter', 'hairbrush', 'cupboard', 'home_office', 'dishwasher', 'coffee', 'shoe_rack']
Task:Make coffee
response:
{
"thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[PUTBACK] <coffee> <coffe_maker>']
}
|
Scene_Objects:['filing_cabinet', 'crayon', 'cat', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'food_cake', 'computer', 'brush', 'electric_shaver', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'toy', 'food_food', 'towel_rack', 'mouse', 'dresser', 'pajamas', 'sink', 'napkin', 'light', 'colander', 'tooth_paste']
Task:Pick up toys
response:
| {
"thoughts": "Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <toy>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[PUTBACK] <toy> <dresser>",
"[CLOSE] <dresser>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'walllamp', 'toothbrush', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'bench', 'box', 'cup', 'photoframe', 'novel', 'mouthwash', 'television', 'curtain', 'doorjamb', 'comb', 'light', 'table']
Task:Read book
response:
{
"thoughts": Sit and read,
"actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[WALK] <couch>', '[SIT] <couch>', '[READ] <novel>']
}
|
Scene_Objects:['filing_cabinet', 'mop', 'band-aids', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'cleaning_solution', 'bookshelf', 'computer', 'stereo', 'oil', 'mousepad', 'wall', 'wall_clock', 'nightstand', 'shelf', 'newspaper', 'food_food', 'video_game_controller', 'coin', 'rag', 'mouse', 'pencil', 'bathtub', 'bathroom_cabinet', 'light', 'coffee', 'creditcard']
Task:Clean mirror
response:
| {
"thoughts": "GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR",
"actions": [
"[WALK] <bathroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[POUR] <cleaning_solution> <rag>",
"[PUTOBJBACK] <cleaning_solution>",
"[WALK] <mirror>",
"[WIPE] <mirror>",
"[WIPE] <mirror>",
"[WIPE] <mirror>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'bathroom', 'ceilingfan', 'knife', 'drawing', 'needle', 'knifeblock', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'phone', 'piano_bench', 'faucet', 'window', 'teeth', 'clothes_pants', 'wall', 'photoframe', 'check', 'oven_mitts', 'tray', 'pencil', 'clothes_dress', 'sink', 'bathroom_cabinet', 'home_office', 'clothes_skirt', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Go to the bathroom and to the sink, turn the faucet on, push the bottle of soap onto your hands and scrub them. Then rinse your hands out and turn the faucet off.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[PUSH] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']
}
|
Scene_Objects:['fork', 'chair', 'milk', 'drawing', 'cpuscreen', 'shampoo', 'folder', 'bookshelf', 'computer', 'table_cloth', 'ceilinglamp', 'mat', 'oil', 'mousepad', 'couch', 'towel', 'nightstand', 'wall', 'cutting_board', 'cup', 'photoframe', 'bed', 'food_donut', 'mouse', 'kitchen_counter', 'pajamas', 'sink', 'napkin', 'home_office', 'tooth_paste']
Task:Open front door
response:
| {
"thoughts": "Walk over to the front door, turn the knob, and open the door.",
"actions": [
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'fork', 'filing_cabinet', 'tablelamp', 'chair', 'band-aids', 'floor', 'ceiling', 'stamp', 'alcohol', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'towel', 'wall', 'toy', 'bed', 'keys', 'photoframe', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'dresser', 'cupboard', 'food_steak', 'sink', 'table']
Task:Wash dishes
response:
{
"thoughts": Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel.,
"actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <plate>', '[PUTOBJBACK] <towel>', '[WALK] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'floor', 'ceiling', 'bedroom', 'window', 'clothes_socks', 'couch', 'dustpan', 'clothes_pants', 'food_orange', 'food_kiwi', 'wall', 'toy', 'bed', 'photoframe', 'food_food', 'coffe_maker', 'wine', 'doorjamb', 'diary', 'console', 'mouse', 'door', 'bathroom_cabinet', 'light', 'vase', 'soap']
Task:Turn off light
response:
| {
"thoughts": "Grasp light switch, flip light switch.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <light>",
"[FIND] <light>",
"[TURNTO] <light>",
"[SWITCHOFF] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'food_kiwi', 'wall', 'powersocket', 'clothes_gloves', 'food_food', 'coffe_maker', 'doorjamb', 'coffee_pot', 'headset', 'door', 'hairdryer', 'light', 'tooth_paste']
Task:Turn on light
response:
{
"thoughts": I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door.,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['filing_cabinet', 'scissors', 'walllamp', 'orchid', 'needle', 'clothes_underwear', 'dvd_player', 'character', 'desk', 'mop_bucket', 'table_cloth', 'brush', 'ceilinglamp', 'mat', 'stereo', 'dining_room', 'nightstand', 'powersocket', 'toy', 'shelf', 'check', 'toothbrush_holder', 'mouse', 'chessboard', 'dresser', 'laundry_detergent', 'home_office', 'bathroom_cabinet', 'teeth', 'creditcard']
Task:Put toys away
response:
| {
"thoughts": "Pick up all the toys on the floor and put them in their correct storage bin or shelf.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <toy>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'video_game_console', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'cup', 'video_game_controller', 'television', 'curtain', 'dishrack', 'napkin', 'table', 'vase', 'scrabble', 'shoe_rack']
Task:Play games
response:
{
"thoughts": Turn on game. Use controller,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[PLUGIN] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['filing_cabinet', 'food_bread', 'crayon', 'tea', 'freezer', 'walllamp', 'bathroom', 'detergent', 'blow_dryer', 'drawing', 'floor', 'desk', 'thread', 'mop_bucket', 'tvstand', 'towel', 'wall', 'toy', 'cup', 'check', 'razor', 'food_donut', 'wine', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'laundry_detergent', 'light', 'soap']
Task:Vacuum
response:
| {
"thoughts": "Robot has a vacuum underneath its feat/body that will allow it to clean the surface of the floor.",
"actions": [
"[WALK] <home_office>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[WALK] <dining_room>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[WALK] <home_office>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <vacuum_cleaner> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'sheets', 'food_bread', 'food_pizza', 'tablelamp', 'scissors', 'toilet', 'walllamp', 'woman', 'knifeblock', 'hanger', 'bathroom_counter', 'man', 'tea_bag', 'keyboard', 'mail', 'stereo', 'window', 'couch', 'child', 'powersocket', 'photoframe', 'novel', 'coffe_maker', 'video_game_controller', 'ice', 'rag', 'headset', 'chessboard', 'maindoor']
Task:Greet guests
response:
{
"thoughts": Greet guests when they knock on the door and invite them to enter my home,
"actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']
}
|
Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'ground_coffee', 'cpuscreen', 'floor', 'ceiling', 'keyboard', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'food_orange', 'bowl', 'wall', 'wall_clock', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'mouthwash', 'coffee_filter', 'water', 'doorjamb', 'pencil', 'kitchen_counter', 'hair', 'controller', 'sink', 'soap']
Task:Make coffee
response:
| {
"thoughts": "Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[OPEN] <coffe_maker>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[GRAB] <ground_coffee>",
"[PUTOBJBACK] <ground_coffee>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <coffe_maker>",
"[CLOSE] <coffe_maker>",
"[SWITCHON] <coffe_maker>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'keyboard', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'bed', 'check', 'television', 'tray', 'curtain', 'mouse', 'cupboard', 'door', 'table']
Task:Relax on sofa
response:
{
"thoughts": Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['dry_pasta', 'microwave', 'toilet', 'freezer', 'walllamp', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'phone', 'character', 'mail', 'food_bacon', 'stovefan', 'mat', 'mousepad', 'couch', 'dining_room', 'broom', 'wall', 'oven', 'cutting_board', 'coffe_maker', 'food_food', 'tray', 'cards', 'mouse', 'kitchen_counter', 'home_office', 'soap']
Task:Put away groceries
response:
| {
"thoughts": "Place groceries in refrigerator from shopping at the grocery store.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'microwave', 'walllamp', 'trashcan', 'drawing', 'floor', 'ceiling', 'button', 'toaster', 'window', 'mousepad', 'clothes_pants', 'wall', 'basket_for_clothes', 'coffe_maker', 'check', 'television', 'toothbrush_holder', 'ice', 'diary', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'pajamas', 'napkin', 'coffee_cup', 'dishwasher', 'soap', 'coffee']
Task:Make coffee
response:
{
"thoughts": Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[OPEN] <coffe_maker>', '[POUR] <coffee> <coffe_maker>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>']
}
|
Scene_Objects:['sponge', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'oven', 'bench', 'shelf', 'check', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'light', 'table', 'vase']
Task:Research
response:
| {
"thoughts": "I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <check>",
"[GRAB] <check>",
"[READ] <check>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'trashcan', 'drawing', 'floor', 'bookshelf', 'toaster', 'ceilinglamp', 'stereo', 'picture', 'window', 'couch', 'towel', 'wall', 'nightstand', 'oven', 'cup', 'television', 'tray', 'kitchen_counter', 'cd', 'dresser', 'hairbrush', 'cupboard', 'home_office', 'table', 'bathroom_cabinet', 'light']
Task:Listen to music
response:
{
"thoughts": Walk to living room. Walk to radio. Switch on the radio. Walk to sofa and sit on it.,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['toilet', 'band-aids', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'desk', 'keyboard', 'mail', 'button', 'table_cloth', 'bookmark', 'electric_shaver', 'pillow', 'food_kiwi', 'nightstand', 'shelf', 'food_cheese', 'light_bulb', 'check', 'coffe_maker', 'razor', 'mirror', 'food_food', 'centerpiece', 'kitchen_counter', 'sink', 'bathtub', 'home_office', 'table']
Task:Shave
response:
| {
"thoughts": "Pick up razor. Push the button to turn it on. Move it in a linear motion against the beard growth. Make sure to get the bottom of your chin, your cheeks, and mustache area.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <electric_shaver>",
"[FIND] <electric_shaver>",
"[GRAB] <electric_shaver>",
"[FIND] <mirror>",
"[TURNTO] <mirror>",
"[SWITCHON] <electric_shaver>",
"[SWITCHOFF] <electric_shaver>",
"[PUTOBJBACK] <electric_shaver>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'chair', 'bathroom', 'food_carrot', 'knifeblock', 'floor', 'phone', 'bedroom', 'envelope', 'mail', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'tvstand', 'shower', 'window', 'candle', 'microphone', 'pillow', 'basket_for_clothes', 'toilet_paper', 'check', 'rag', 'chessboard', 'laundry_detergent', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'washing_machine', 'coffee']
Task:Wash clothes
response:
{
"thoughts": Pick up my dirty clothes, load the washer, add detergent, turn on washer,
"actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>']
}
|
Scene_Objects:['microwave', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'stereo', 'shower', 'mousepad', 'closetdrawer', 'dustpan', 'wall', 'powersocket', 'box', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'light', 'table', 'printing_paper']
Task:Print out papers
response:
| {
"thoughts": "Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.",
"actions": [
"[WALK] <home_office>",
"[WALK] <fax_machine>",
"[FIND] <fax_machine>",
"[SWITCHON] <fax_machine>",
"[FIND] <printing_paper>",
"[GRAB] <printing_paper>",
"[PUTBACK] <printing_paper> <fax_machine>",
"[FIND] <computer>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[GRAB] <printing_paper>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'glue', 'pot', 'toilet', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'photoframe', 'food_food', 'television', 'doorjamb', 'kettle', 'shaving_cream', 'kitchen_counter', 'chessboard', 'dresser', 'controller', 'light']
Task:Relax on sofa
response:
{
"thoughts": I get home from work and walk into the living room. I see the couch and go to sit on it.,
"actions": ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['ironing_board', 'sheets', 'glue', 'microwave', 'toilet', 'walllamp', 'blow_dryer', 'bathroom_counter', 'bedroom', 'computer', 'stovefan', 'tvstand', 'iron', 'faucet', 'mousepad', 'clothes_socks', 'couch', 'toy', 'cup', 'keys', 'coffe_maker', 'after_shave', 'towel_rack', 'mouse', 'kitchen_counter', 'controller', 'maindoor', 'bathtub', 'tooth_paste', 'clothes_shirt']
Task:Iron shirt
response:
| {
"thoughts": "Set up an ironing board and an iron. Lay a shirt on board. Run iron over shirt until it is free of wrinkles.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <ironing_board>",
"[FIND] <ironing_board>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUTBACK] <clothes_shirt> <ironing_board>",
"[FIND] <iron>",
"[GRAB] <iron>",
"[PLUGIN] <iron>",
"[PLUGOUT] <iron>",
"[PUTOBJBACK] <iron>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'beer', 'crayon', 'detergent', 'drawing', 'food_egg', 'floor', 'ceiling', 'bedroom', 'brush', 'mat', 'ceilinglamp', 'shower', 'balanceball', 'window', 'couch', 'towel', 'wall', 'bench', 'light_bulb', 'television', 'water', 'curtain', 'mouse', 'kitchen_counter', 'door', 'home_office', 'soap', 'laser_pointer']
Task:Take shower
response:
{
"thoughts": Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[TURNTO] <shower>', '[FIND] <water>', '[RINSE] <water>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <water>', '[FIND] <towel>', '[GRAB] <towel>', '[SCRUB] <towel>']
}
|
Scene_Objects:['sheets', 'filing_cabinet', 'chair', 'cpuscreen', 'floor', 'toaster', 'mat', 'iron', 'window', 'electric_shaver', 'homework', 'clothes_socks', 'couch', 'candle', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'standingmirror', 'razor', 'television', 'tray', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'comb', 'door', 'table']
Task:Pull up carpet
response:
| {
"thoughts": "Pry up a corner of your old dirty carpet. Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt.",
"actions": [
"[WALK] <home_office>",
"[WALK] <mat>",
"[FIND] <mat>",
"[TOUCH] <mat>",
"[PULL] <mat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'chair', 'trashcan', 'drawing', 'clothes_underwear', 'floor', 'phone', 'character', 'keyboard', 'mat', 'ceilinglamp', 'plate', 'tvstand', 'shower', 'faucet', 'mousepad', 'couch', 'wall', 'bench', 'powersocket', 'newspaper', 'bed', 'television', 'mouse', 'controller', 'table', 'light', 'instrument_violin', 'creditcard']
Task:Set up table
response:
{
"thoughts": I walk to the table. I put down the dish. I put down the silverware. I put down the napkin.,
"actions": ['[WALK] <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>']
}
|
Scene_Objects:['filing_cabinet', 'food_carrot', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'stovefan', 'mat', 'faucet', 'mousepad', 'towel', 'pillow', 'wall', 'wall_clock', 'oven', 'toy', 'cup', 'hands_both', 'standingmirror', 'food_donut', 'tray', 'mouse', 'kitchen_counter', 'hairdryer', 'sink', 'bathroom_cabinet', 'soap', 'teeth', 'shoe_rack']
Task:Wash hands
response:
| {
"thoughts": "Turn faucet clockwise to turn on water. Place hands under stream of water, pick up soap, rub hands with soap. Put soap back down. Rub hands together with soap on them. Rinse hands under water from faucet. Turn faucet counterclockwise to turn water off. Dry hands by rubbing them on a towel.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[FIND] <hands_both>",
"[SCRUB] <hands_both>",
"[PUTOBJBACK] <soap>",
"[WASH] <hands_both>",
"[SWITCHOFF] <faucet>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[WIPE] <hands_both>",
"[PUTOBJBACK] <towel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'detergent', 'trashcan', 'floor', 'ceiling', 'bedroom', 'toaster', 'mat', 'stereo', 'pillow', 'wall', 'cup', 'bed', 'coffe_maker', 'food_food', 'coffee_filter', 'water', 'food_donut', 'wooden_spoon', 'food_onion', 'doorjamb', 'pencil', 'kitchen_counter', 'cupboard', 'napkin', 'spoon', 'dishwasher', 'coffee']
Task:Make coffee
response:
{
"thoughts": I find the coffee machine, fill it with water and coffee then press the button to make the coffee,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[WALK] <coffee>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['measuring_cup', 'food_butter', 'knife', 'orchid', 'floor', 'character', 'desk', 'food_bacon', 'table_cloth', 'piano_bench', 'mat', 'picture', 'window', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'child', 'light_bulb', 'toilet_paper', 'television', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'bathtub', 'table', 'board_game']
Task:Let baby learn how to walk
response:
| {
"thoughts": "The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.",
"actions": [
"[WALK] <home_office>",
"[WALK] <child>",
"[FIND] <child>",
"[TOUCH] <child>",
"[GREET] <child>",
"[FIND] <couch>",
"[TURNTO] <couch>",
"[POINTAT] <couch>",
"[TURNTO] <child>",
"[LOOKAT] <child>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'tablelamp', 'mop', 'toilet', 'chair', 'trashcan', 'knifeblock', 'hanger', 'longboard', 'floor', 'phone', 'keyboard', 'balanceball', 'foundation', 'pillow', 'wall', 'powersocket', 'box', 'photoframe', 'bed', 'check', 'rag', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'maindoor', 'light', 'colander']
Task:Sit
response:
{
"thoughts": We sit at the dining room table,
"actions": ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>']
}
|
Scene_Objects:['scissors', 'microwave', 'toilet', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'stovefan', 'mat', 'faucet', 'mousepad', 'towel', 'wall', 'wall_clock', 'oven', 'bench', 'cutting_board', 'shelf', 'food_rice', 'tray', 'after_shave', 'towel_rack', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'soap', 'laser_pointer', 'dirt', 'hands_both']
Task:Hand washing
response:
| {
"thoughts": "Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[FIND] <hands_both>",
"[SCRUB] <hands_both>",
"[PUTOBJBACK] <soap>",
"[WASH] <hands_both>",
"[SWITCHOFF] <faucet>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[WIPE] <hands_both>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'blow_dryer', 'cat', 'wallshelf', 'ceiling', 'desk', 'bedroom', 'keyboard', 'stovefan', 'mousepad', 'powersocket', 'oven', 'bed', 'food_food', 'check', 'wooden_spoon', 'towel_rack', 'mouse', 'dishrack', 'comb', 'maindoor', 'bathtub', 'napkin', 'home_office', 'light', 'table', 'soap', 'laser_pointer', 'scrabble']
Task:Read book
response:
{
"thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
"actions": ['[WALK] <home_office>', '[WALK] <address_book>', '[FIND] <address_book>', '[GRAB] <address_book>', '[READ] <address_book>']
}
|
Scene_Objects:['microwave', 'chair', 'freezer', 'detergent', 'food_carrot', 'orchid', 'floor', 'wine_glass', 'food_cake', 'mat', 'picture', 'window', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'wall', 'pasta', 'shelf', 'food_cheese', 'newspaper', 'food_food', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'bathtub', 'table', 'vase']
Task:Entertain
response:
| {
"thoughts": "Give guests wine, cheese, crackers and sit and talk",
"actions": [
"[WALK] <home_office>",
"[WALK] <food_cheese>",
"[FIND] <food_cheese>",
"[FIND] <food_food>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <wine_glass>",
"[GRAB] <wine_glass>",
"[DRINK] <wine_glass>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'drawing', 'needle', 'knife', 'clothes_underwear', 'hanger', 'floor', 'envelope', 'computer', 'ceilinglamp', 'oil', 'mousepad', 'pillow', 'bowl', 'wall', 'nightstand', 'child', 'bed', 'novel', 'food_food', 'coffe_maker', 'television', 'doorjamb', 'dishrack', 'comb', 'laundry_detergent', 'conditioner', 'sink', 'instrument_violin']
Task:Story reading time
response:
{
"thoughts": Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures,
"actions": ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[TURNTO] <child>', '[LOOKAT] <child>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['blender', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'clothes_jacket', 'table_cloth', 'mat', 'floor_lamp', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'light_bulb', 'novel', 'mouthwash', 'television', 'ice', 'curtain', 'after_shave', 'doorjamb', 'console', 'kettle', 'conditioner', 'bathtub', 'sink', 'table', 'vase']
Task:Read book
response:
| {
"thoughts": "A person brings a book into the living room and sits down in a comfortable chair. If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read. The person begins reading the book until they need to stop for some reason.",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'trashcan', 'orchid', 'knifeblock', 'floor', 'tea_bag', 'keyboard', 'computer', 'stovefan', 'tvstand', 'stereo', 'window', 'dustpan', 'candle', 'food_jam', 'wall', 'pasta', 'bed', 'photoframe', 'coffe_maker', 'television', 'tray', 'curtain', 'wooden_spoon', 'towel_rack', 'pencil', 'chessboard', 'cupboard', 'maindoor', 'light']
Task:Listen to music
response:
{
"thoughts": Put iPhone into speaker holder, open up the Pandora app, listen to music.,
"actions": ['[WALK] <bedroom>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[WALK] <stereo>', '[PLUGIN] <phone>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[SIT] <bed>']
}
|
Scene_Objects:['food_bread', 'filing_cabinet', 'food_ice_cream', 'beer', 'microwave', 'toilet', 'freezer', 'walllamp', 'food_egg', 'floor', 'ceiling', 'phone', 'keyboard', 'toaster', 'stovefan', 'brush', 'faucet', 'food_peanut_butter', 'clothes_pants', 'wall', 'oven', 'powersocket', 'cutting_board', 'food_cheese', 'coffe_maker', 'food_food', 'tray', 'kitchen_counter', 'comb', 'sink']
Task:Make toast
response:
| {
"thoughts": "Place slices of bread in a toaster ,wait for the bread to pop up .Set aside.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_bread>",
"[GRAB] <food_bread>",
"[CLOSE] <freezer>",
"[FIND] <toaster>",
"[PLUGIN] <toaster>",
"[PUTBACK] <food_bread> <toaster>",
"[SWITCHON] <toaster>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'measuring_cup', 'microwave', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'face', 'mop_bucket', 'tvstand', 'faucet', 'food_peanut_butter', 'towel', 'wall', 'oven', 'face_soap', 'tape', 'photoframe', 'bed', 'keys', 'rag', 'cards', 'comb', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet']
Task:Wash face
response:
{
"thoughts": Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <rag>', '[GRAB] <rag>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[WASH] <rag>', '[FIND] <face_soap>', '[GRAB] <face_soap>', '[POUR] <face_soap> <rag>', '[PUTOBJBACK] <face_soap>', '[FIND] <face>', '[SCRUB] <face>', '[PUTBACK] <rag> <sink>', '[RINSE] <face>', '[RINSE] <rag>', '[SWITCHOFF] <faucet>', '[GRAB] <rag>', '[PUTOBJBACK] <rag>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['spectacles', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'legs_both', 'desk', 'keyboard', 'face', 'computer', 'toaster', 'mousepad', 'closetdrawer', 'dustpan', 'towel', 'wall', 'feet_both', 'powersocket', 'arms_both', 'basket_for_clothes', 'cup', 'check', 'mouse', 'shoes', 'dresser', 'hairbrush', 'controller', 'light', 'clothes_shirt']
Task:Try yourself off
response:
| {
"thoughts": "After your shower, go into your bedroom and use a towel to dry water off of yourself before dressing.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[FIND] <dresser>",
"[OPEN] <dresser>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[CLOSE] <dresser>",
"[FIND] <face>",
"[WIPE] <face>",
"[FIND] <arms_both>",
"[WIPE] <arms_both>",
"[FIND] <legs_both>",
"[WIPE] <legs_both>",
"[FIND] <feet_both>",
"[WIPE] <feet_both>",
"[FIND] <basket_for_clothes>",
"[PUTBACK] <towel> <basket_for_clothes>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'chair', 'ground_coffee', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'folder', 'purse', 'computer', 'toaster', 'laptop', 'shower', 'picture', 'couch', 'wall', 'pasta', 'nightstand', 'box', 'photoframe', 'coffe_maker', 'television', 'coffee_filter', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'instrument_violin']
Task:Make coffee
response:
{
"thoughts": Open the coffee maker and put a filer, grab ground coffee and put it in the coffee maker, then close the coffee maker and switch it on,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[FIND] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['pot', 'tea', 'walllamp', 'bathroom', 'wallshelf', 'ceiling', 'dvd_player', 'tea_bag', 'food_bacon', 'toaster', 'homework', 'clothes_pants', 'nightstand', 'wall', 'powersocket', 'toy', 'newspaper', 'standingmirror', 'novel', 'bed', 'console', 'mouse', 'shoes', 'controller', 'door', 'sink', 'bathtub', 'home_office', 'table', 'vase']
Task:Watch fly
response:
| {
"thoughts": "Look around for a fly, often on a wall or ceiling. Follow it's movements.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <fly>",
"[FIND] <fly>",
"[TURNTO] <fly>",
"[LOOKAT] <fly>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'foundation', 'couch', 'wall', 'pasta', 'toy', 'box', 'television', 'curtain', 'diary', 'towel_rack', 'kitchen_counter', 'cupboard', 'clothes_scarf', 'home_office', 'table', 'vase', 'coffee']
Task:Change TV channels
response:
{
"thoughts": Take remote. Change to desired channel by you.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['fork', 'tablelamp', 'juice', 'nail_polish', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'mat', 'shower', 'window', 'closetdrawer', 'wall', 'nightstand', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'television', 'curtain', 'mouse', 'pencil', 'vacuum_cleaner', 'hair', 'maindoor', 'table', 'vase']
Task:Read book
response:
| {
"thoughts": "I lie on my bed and read a book.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[WALK] <bed>",
"[LIE] <bed>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'dresser', 'hairbrush', 'clothes_dress', 'door', 'sink', 'spoon', 'table', 'light']
Task:Change TV channel
response:
{
"thoughts": I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['sponge', 'tablelamp', 'detergent', 'wallshelf', 'hanger', 'floor', 'phone', 'shampoo', 'character', 'desk', 'mop_bucket', 'bookmark', 'toaster', 'mat', 'window', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'mouthwash', 'television', 'razor', 'curtain', 'after_shave', 'doorjamb', 'bathroom_cabinet', 'table', 'light']
Task:Read book
response:
| {
"thoughts": "Pick up a book and open to the last page you were on. Read the book.",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <bookmark>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'cat', 'ceilingfan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'oil', 'couch', 'wall', 'wall_clock', 'powersocket', 'oven', 'bench', 'newspaper', 'mouthwash', 'television', 'diary', 'towel_rack', 'mouse', 'dresser', 'hairbrush', 'hairdryer', 'soap']
Task:Check email
response:
{
"thoughts": Sit in teak deck chair, have wooden drawing board on lap, laptop on wooden drawing board, log in to my two email accounts, go through new emails and respond.,
"actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <chair>', '[SIT] <chair>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>']
}
|
Scene_Objects:['microwave', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'plate', 'iron', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'cutting_board', 'clothes_gloves', 'check', 'coffe_maker', 'food_food', 'curtain', 'food_onion', 'mouse', 'comb', 'dresser', 'clothes_dress', 'sink', 'light', 'coffee']
Task:Hang up jacket
response:
| {
"thoughts": "I put clothes on hangers and hang them in the closet",
"actions": [
"[WALK] <bedroom>",
"[WALK] <clothes_dress>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[WALK] <dresser>",
"[FIND] <hanger>",
"[OPEN] <dresser>",
"[PUTIN] <clothes_dress> <dresser>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[WALK] <dresser>",
"[PUTIN] <clothes_dress> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'juice', 'jelly', 'freezer', 'walllamp', 'nail_polish', 'knifeblock', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'button', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'mousepad', 'pillow', 'wall', 'oven', 'powersocket', 'bench', 'cup', 'food_food', 'food_rice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'table', 'board_game']
Task:Grab some juice
response:
{
"thoughts": I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass.,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <juice>', '[GRAB] <juice>', '[POUR] <juice> <cup>', '[PUTOBJBACK] <juice>', '[CLOSE] <freezer>', '[FIND] <table>', '[PUTBACK] <cup> <table>']
}
|
Scene_Objects:['pot', 'tablelamp', 'chair', 'toothbrush', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'mat', 'faucet', 'window', 'towel', 'pillow', 'wall', 'wall_clock', 'oven', 'bench', 'cutting_board', 'television', 'food_rice', 'ice', 'wooden_spoon', 'tray', 'comb', 'sink', 'bathroom_cabinet', 'tooth_paste', 'teeth']
Task:Brush teeth
response:
| {
"thoughts": "Put toothpaste on toothbrush, brush teeth, rinse mouth",
"actions": [
"[WALK] <bathroom>",
"[WALK] <toothbrush>",
"[FIND] <toothbrush>",
"[GRAB] <toothbrush>",
"[FIND] <tooth_paste>",
"[GRAB] <tooth_paste>",
"[POUR] <tooth_paste> <toothbrush>",
"[PUTOBJBACK] <tooth_paste>",
"[WALK] <sink>",
"[FIND] <teeth>",
"[SCRUB] <teeth>",
"[SCRUB] <teeth>",
"[SCRUB] <teeth>",
"[PUTBACK] <toothbrush> <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <toothbrush>",
"[RINSE] <teeth>",
"[SWITCHOFF] <faucet>",
"[GRAB] <toothbrush>",
"[PUTOBJBACK] <toothbrush>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'microwave', 'toilet', 'cat', 'wallshelf', 'bathroom_counter', 'floor', 'dvd_player', 'bookshelf', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'shower', 'faucet', 'tvstand', 'couch', 'towel', 'wall', 'bench', 'cutting_board', 'bed', 'razor', 'television', 'curtain', 'kitchen_counter', 'dresser', 'home_office', 'light']
Task:Pet cat
response:
{
"thoughts": Pet Cat,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['spectacles', 'filing_cabinet', 'food_salt', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'deck_of_cards', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'powersocket', 'toy', 'tape', 'light_bulb', 'check', 'food_food', 'television', 'curtain', 'doorjamb', 'mouse', 'pencil', 'dresser', 'conditioner', 'spoon', 'light', 'table', 'colander']
Task:Re arrange office
response:
| {
"thoughts": "Walk in.Turn on light.Move furniture. Change the room",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <desk>",
"[PUSH] <desk>",
"[WALK] <chair>",
"[PUSH] <chair>",
"[WALK] <couch>",
"[PUSH] <couch>",
"[WALK] <filing_cabinet>",
"[PUSH] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'crayon', 'jelly', 'freezer', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'food_cake', 'mop_bucket', 'stovefan', 'mat', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'food_food', 'television', 'wine', 'tray', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'light', 'clothes_skirt']
Task:Put groceries in Fridge
response:
{
"thoughts": Go to kitchen, open fridge, get groceries, put groceries in fridge, close fridge,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}
|
Scene_Objects:['food_ice_cream', 'bathroom', 'food_carrot', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'stamp', 'faucet', 'stereo', 'shower', 'oil', 'closetdrawer', 'microphone', 'clothes_hat', 'wall', 'nightstand', 'oven', 'tape', 'cup', 'keys', 'toilet_paper', 'curtain', 'shoes', 'maindoor', 'sink', 'bathtub', 'food_steak', 'light', 'coffee']
Task:Take dishes out of dishwasher
response:
| {
"thoughts": "Take clean dishes out of the dishwasher and put away",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[OPEN] <dishwasher>",
"[CLOSE] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'dog', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'form', 'wall', 'powersocket', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'mouse', 'cupboard', 'bathtub', 'sink', 'table']
Task:Work
response:
{
"thoughts": go to home office. turn the computer on. begin working,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['dry_pasta', 'food_ice_cream', 'toothbrush', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'alcohol', 'brush', 'shoe-shine_kit', 'faucet', 'mousepad', 'closetdrawer', 'candle', 'clothes_pants', 'wall', 'standingmirror', 'food_food', 'television', 'tray', 'coffee_pot', 'towel_rack', 'dresser', 'bathtub', 'bathroom_cabinet', 'vase']
Task:Dust
response:
| {
"thoughts": "Using soft brush, carefully dust both Indonesian wedding doll statues.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <brush>",
"[GRAB] <brush>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_bread', 'filing_cabinet', 'tablelamp', 'crayon', 'woman', 'wallshelf', 'shampoo', 'floor', 'phone', 'desk', 'man', 'bookshelf', 'closetdrawer', 'couch', 'dining_room', 'nightstand', 'child', 'bed', 'photoframe', 'standingmirror', 'toilet_paper', 'oven_mitts', 'towel_rack', 'kitchen_counter', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'vase']
Task:Say goodbye to guests leaving
response:
{
"thoughts": Tell them bye,
"actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[FIND] <man>', '[TOUCH] <man>', '[FIND] <woman>', '[TOUCH] <woman>']
}
|
Scene_Objects:['food_bread', 'chair', 'cpuscreen', 'ceiling', 'character', 'video_game_console', 'bookshelf', 'keyboard', 'computer', 'mat', 'faucet', 'window', 'mousepad', 'wall_clock', 'tape', 'cutting_board', 'food_cheese', 'check', 'video_game_controller', 'mouthwash', 'food_onion', 'rag', 'coffee_pot', 'towel_rack', 'pencil', 'vacuum_cleaner', 'cd', 'dresser', 'home_office', 'dirt']
Task:Playing video game
response:
| {
"thoughts": "Playing video games on various video game systems such as wii u and xbox",
"actions": [
"[WALK] <home_office>",
"[WALK] <video_game_console>",
"[FIND] <video_game_console>",
"[SWITCHON] <video_game_console>",
"[FIND] <video_game_controller>",
"[GRAB] <video_game_controller>",
"[PUTOBJBACK] <video_game_controller>",
"[SWITCHOFF] <video_game_console>",
"[FIND] <video_game_console>",
"[SWITCHON] <video_game_console>",
"[FIND] <video_game_controller>",
"[GRAB] <video_game_controller>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'scissors', 'measuring_cup', 'freezer', 'food_butter', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'food_cake', 'mat', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'food_food', 'check', 'television', 'water', 'kitchen_counter', 'cupboard', 'door', 'light', 'clothes_skirt']
Task:Drink
response:
{
"thoughts": go to kitchen, find water glass and grab it, find fridge and open grab water and pour into it, then drink.,
"actions": ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[FIND] <freezer>', '[OPEN] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[CLOSE] <freezer>', '[DRINK] <water_glass>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'bathroom', 'milk', 'floor', 'bookshelf', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'bench', 'oven', 'toy', 'cutting_board', 'shelf', 'cup', 'standingmirror', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'console', 'pencil', 'comb', 'sink', 'home_office', 'scrabble']
Task:Pick up toys
response:
| {
"thoughts": "Grab toys off floor. Put it in a container.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <toy>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_salt', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'computer', 'button', 'tvstand', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'oven', 'coffee_table', 'novel', 'television', 'curtain', 'doorjamb', 'lighter', 'dresser', 'home_office', 'table']
Task:Change TV channel
response:
{
"thoughts": Go to the living room, find the remote control on the coffee table, and change the TV channel.,
"actions": ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <coffee_table>', '[WALK] <coffee_table>', '[TURNTO] <coffee_table>', '[LOOKAT] <coffee_table>', '[FIND] <remote_control>', '[TOUCH] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[TOUCH] <button>', '[PUSH] <button>']
}
|
Scene_Objects:['toilet', 'chair', 'bathroom', 'food_butter', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'shoe-shine_kit', 'shower', 'mousepad', 'closetdrawer', 'clothes_hat', 'wall', 'powersocket', 'cup', 'photoframe', 'novel', 'doorjamb', 'mouse', 'dresser', 'clothes_dress', 'light', 'clothes_skirt', 'vase']
Task:Sew
response:
| {
"thoughts": "Using the sewing machine to fix and make clothes",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[CLOSE] <dresser>",
"[FIND] <chair>",
"[SIT] <chair>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'ceilingfan', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'face', 'mail', 'table_cloth', 'faucet', 'food_jam', 'towel', 'dining_room', 'wall', 'face_soap', 'toy', 'photoframe', 'keys', 'water', 'rag', 'pencil', 'shoes', 'dresser', 'sink', 'bathroom_cabinet', 'home_office', 'colander', 'hands_both']
Task:Wash face
response:
{
"thoughts": Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <rag> <sink>', '[GRAB] <rag>', '[FIND] <face_soap>', '[GRAB] <face_soap>', '[POUR] <face_soap> <rag>', '[PUTOBJBACK] <face_soap>', '[FIND] <face>', '[SCRUB] <face>', '[PUTBACK] <rag> <sink>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <hands_both>', '[POUR] <water> <hands_both>', '[RINSE] <face>', '[WASH] <rag>', '[GRAB] <rag>', '[PUTOBJBACK] <rag>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['mop', 'walllamp', 'food_butter', 'food_carrot', 'drawing', 'cpuscreen', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'food_bacon', 'electric_shaver', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'photoframe', 'curtain', 'rag', 'mouse', 'shoes', 'dresser', 'hairdryer', 'bag', 'light', 'tooth_paste']
Task:Take off shoes
response:
| {
"thoughts": "Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <shoes>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PULL] <shoes>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[PUTIN] <shoes> <dresser>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PULL] <shoes>",
"[WALK] <dresser>",
"[PUTIN] <shoes> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'stamp', 'envelope', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'powersocket', 'standingmirror', 'television', 'curtain', 'doorjamb', 'mouse', 'bag', 'home_office', 'table', 'soap']
Task:Relax on sofa
response:
{
"thoughts": I walk to my living room and switch on the television, and lay on the sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['sheets', 'glue', 'tablelamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'clothes_jacket', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'bed', 'novel', 'mouse', 'shoes', 'dresser', 'clothes_dress', 'light', 'table']
Task:Get ready for day
response:
| {
"thoughts": "Grab shoes, purse etc and head out the door!",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[FIND] <dresser>",
"[OPEN] <dresser>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[PUTON] <clothes_dress>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PUTON] <shoes>",
"[FIND] <purse>",
"[GRAB] <purse>",
"[CLOSE] <dresser>",
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['band-aids', 'trashcan', 'wallshelf', 'clothes_underwear', 'desk', 'keyboard', 'mail', 'computer', 'tvstand', 'shower', 'window', 'clothes_socks', 'couch', 'food_peanut_butter', 'pillow', 'basket_for_clothes', 'keys', 'coffe_maker', 'television', 'food_donut', 'tray', 'rag', 'headset', 'clothes_scarf', 'bathtub', 'sink', 'light', 'dishwasher', 'soap', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine,
"actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['knife', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'folder', 'desk', 'keyboard', 'computer', 'mat', 'stereo', 'mousepad', 'closetdrawer', 'clothes_pants', 'wall', 'powersocket', 'cup', 'newspaper', 'novel', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'spoon', 'light', 'soap', 'board_game', 'clothes_shirt', 'scrabble']
Task:Get dressed
response:
| {
"thoughts": "Pick out the clothes you are going to wear and put them on your body",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[PUTON] <clothes_pants>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUTON] <clothes_shirt>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'tablelamp', 'microwave', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'bench', 'cup', 'doorjamb', 'mouse', 'address_book', 'hairbrush', 'hairdryer', 'light', 'creditcard']
Task:Work
response:
{
"thoughts": Walk to home office. Walk to computer. Switch on computer. Open the address book.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[FIND] <address_book>']
}
|
Scene_Objects:['juice', 'blender', 'beer', 'microwave', 'freezer', 'walllamp', 'detergent', 'floor', 'ceiling', 'character', 'stovefan', 'faucet', 'couch', 'clothes_hat', 'food_orange', 'broom', 'wall', 'oven', 'cutting_board', 'shelf', 'food_cheese', 'bed', 'coffe_maker', 'food_food', 'tray', 'after_shave', 'lighter', 'kitchen_counter', 'vase', 'coffee']
Task:Eat cheese
response:
| {
"thoughts": "Open fridge. Get cheese. Eat it.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_cheese>",
"[GRAB] <food_cheese>",
"[EAT] <food_cheese>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'chair', 'dog', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'pasta', 'light_bulb', 'clothes_gloves', 'television', 'curtain', 'doorjamb', 'conditioner', 'door', 'light']
Task:Relax on sofa
response:
{
"thoughts": I walk into the living room and turn on the light. I walk to the couch then sit on the couch.,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['spectacles', 'microwave', 'chair', 'dog', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'laptop', 'mat', 'mousepad', 'closetdrawer', 'couch', 'wall', 'powersocket', 'coffe_maker', 'wine', 'doorjamb', 'kettle', 'mouse', 'pencil', 'dresser', 'light']
Task:Work
response:
| {
"thoughts": "I walk in. Turn on the light. Set in my chair. Turn on lap top. And start to work.",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <laptop>",
"[GRAB] <laptop>",
"[SWITCHON] <laptop>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'mop', 'bathroom', 'dough', 'knifeblock', 'hanger', 'keyboard', 'alcohol', 'toaster', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'pasta', 'basket_for_clothes', 'check', 'television', 'razor', 'tray', 'doorjamb', 'chessboard', 'dishrack', 'hairbrush', 'napkin', 'bathroom_cabinet', 'light', 'dishwasher', 'table']
Task:Pick up phone
response:
{
"thoughts": go to living room, find phone, pick up phone,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['sheets', 'freezer', 'nail_polish', 'woman', 'bathroom_counter', 'floor', 'shampoo', 'man', 'keyboard', 'purse', 'stovefan', 'mat', 'window', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'wall_clock', 'bench', 'shelf', 'standingmirror', 'check', 'television', 'curtain', 'doorjamb', 'pencil', 'bag', 'table', 'soap']
Task:Hang with friends
response:
| {
"thoughts": "Sit with friends. Talk",
"actions": [
"[WALK] <home_office>",
"[WALK] <man>",
"[FIND] <man>",
"[TURNTO] <man>",
"[LOOKAT] <man>",
"[GREET] <man>",
"[FIND] <woman>",
"[TURNTO] <woman>",
"[LOOKAT] <woman>",
"[GREET] <woman>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TURNTO] <man>",
"[LOOKAT] <man>",
"[GREET] <man>",
"[TURNTO] <woman>",
"[LOOKAT] <woman>",
"[GREET] <woman>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'milk', 'floor', 'ceiling', 'desk', 'keyboard', 'button', 'mop_bucket', 'toaster', 'stereo', 'window', 'wall', 'powersocket', 'bench', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'food_sugar', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'coffee_cup', 'dishwasher', 'light', 'clothes_shirt']
Task:Make coffee
response:
{
"thoughts": walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[LOOKAT] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <milk>', '[GRAB] <milk>', '[PUTBACK] <milk> <coffe_maker>', '[FIND] <food_sugar>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>']
}
|
Scene_Objects:['pot', 'tablelamp', 'walllamp', 'woman', 'drawing', 'phone', 'desk', 'man', 'toaster', 'laptop', 'mat', 'shower', 'electric_shaver', 'oil', 'form', 'pillow', 'dining_room', 'oven', 'shelf', 'bed', 'standingmirror', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'tooth_paste', 'scrabble']
Task:Greet guests
response:
| {
"thoughts": "Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.",
"actions": [
"[WALK] <home_office>",
"[WALK] <man>",
"[FIND] <man>",
"[GREET] <man>",
"[FIND] <woman>",
"[GREET] <woman>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'nail_polish', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'bedroom', 'tea_bag', 'laptop', 'tvstand', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_hat', 'wall', 'nightstand', 'powersocket', 'photoframe', 'coffe_maker', 'check', 'television', 'doorjamb', 'towel_rack', 'cards', 'dresser', 'door', 'home_office', 'light']
Task:Turn on light
response:
{
"thoughts": I walk into the dining room and turn on the lights,
"actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['sheets', 'tablelamp', 'dough', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'window', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'check', 'curtain', 'mouse', 'pencil', 'dresser', 'light', 'table', 'vase', 'shoe_rack']
Task:Read book
response:
| {
"thoughts": "Put child in bed, sit down,read book.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[FIND] <bed>",
"[SIT] <bed>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'desk', 'food_cake', 'stovefan', 'toaster', 'deck_of_cards', 'faucet', 'candle', 'pillow', 'dining_room', 'oven', 'photoframe', 'check', 'food_food', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'soap', 'board_game', 'clothes_shirt']
Task:Pet cat
response:
{
"thoughts": Walk to living room. Find cat. Walk to cat. Pull cat.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[PULL] <cat>']
}
|
Scene_Objects:['sheets', 'spectacles', 'filing_cabinet', 'food_salt', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'character', 'shower', 'stereo', 'microphone', 'wall', 'toy', 'cutting_board', 'cup', 'novel', 'food_food', 'check', 'food_onion', 'coffee_pot', 'console', 'shaving_cream', 'towel_rack', 'shoes', 'cd', 'hairbrush', 'maindoor', 'soap', 'coffee']
Task:Read
response:
| {
"thoughts": "Read a book in the living room",
"actions": [
"[WALK] <home_office>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[CLOSE] <filing_cabinet>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'glue', 'toilet', 'chair', 'bathroom', 'drawing', 'longboard', 'floor', 'ceiling', 'food_cake', 'mat', 'ceilinglamp', 'shower', 'deck_of_cards', 'balanceball', 'shoe-shine_kit', 'tvstand', 'candle', 'food_kiwi', 'wall', 'nightstand', 'powersocket', 'bench', 'food_cheese', 'novel', 'coffe_maker', 'curtain', 'towel_rack', 'home_office', 'dishwasher']
Task:Take shower
response:
{
"thoughts": Walk to the bathroom and wash with the shower.,
"actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[WASH] <shower>']
}
|
Scene_Objects:['chair', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'tvstand', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'oven', 'cup', 'standingmirror', 'check', 'television', 'centerpiece', 'console', 'mouse', 'vacuum_cleaner', 'shoes', 'comb', 'dresser', 'hairbrush', 'sink', 'bag', 'napkin', 'bathroom_cabinet', 'vase']
Task:vacuum carpet
response:
| {
"thoughts": "I bring my vacuum cleaner into the living room. I plug it into the wall. I press the on switch on the vacuum cleaner. I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet. I turn the vacuum cleaner off. I take the vacuum cleaner back to the hall closet.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[WALK] <dresser>",
"[PUTIN] <vacuum_cleaner> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'stovefan', 'faucet', 'window', 'mousepad', 'closetdrawer', 'couch', 'towel', 'wall', 'nightstand', 'curtain', 'towel_rack', 'mouse', 'coffee_pot', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": I go to the bathroom and locate the sink. I turn the faucet so that water is running, and rinse my hands briefly. Then I grab the soap and squeeze some onto my hands. I spend a few minutes rubbing my hands together, then I rinse them again. Finally, I turn the faucet off and wipe my hands on a towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SQUEEZE] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}
|
Scene_Objects:['food_bread', 'tablelamp', 'blender', 'tea', 'chair', 'freezer', 'drawing', 'orchid', 'hanger', 'floor', 'shampoo', 'stamp', 'bedroom', 'desk', 'computer', 'mat', 'stereo', 'mousepad', 'food_jam', 'dining_room', 'wall', 'wall_clock', 'bench', 'photoframe', 'food_food', 'dresser', 'napkin', 'home_office', 'table', 'spoon']
Task:Eat dinner
response:
| {
"thoughts": "In our dining room, my family eats dinner. Once the food has been prepared, we gather at the dining room table and prepare to eat.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <food_food> <table>",
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <food_food> <table>",
"[WALK] <chair>",
"[PULL] <chair>",
"[SIT] <chair>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'door', 'light', 'table']
Task:Vacuum
response:
{
"thoughts": Keep my keyboard vacuumed and free of debris.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']
}
|
Scene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'thread', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'photoframe', 'toilet_paper', 'television', 'razor', 'coin', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table']
Task:Turn on computer
response:
| {
"thoughts": "Push power button.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[SWITCHON] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'plate', 'couch', 'pillow', 'wall', 'newspaper', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'bathtub', 'light', 'table']
Task:Pet cat
response:
{
"thoughts": My cat looks like it wants attention, so I will go pet it on the couch.,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['filing_cabinet', 'blender', 'band-aids', 'freezer', 'orchid', 'cpuscreen', 'floor', 'bookshelf', 'envelope', 'toaster', 'stovefan', 'plate', 'shower', 'faucet', 'foundation', 'oil', 'mousepad', 'food_jam', 'microphone', 'dining_room', 'bench', 'oven', 'toy', 'box', 'food_food', 'food_onion', 'diary', 'kitchen_counter', 'cupboard', 'colander']
Task:Get out dish
response:
| {
"thoughts": "Open cupboard. Get out the dish.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[CLOSE] <cupboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'soap']
Task:Work
response:
{
"thoughts": I go to my home office, sit on the chair and turn on the computer. I open my email account to look for all the information I need.I pull up my online task on the computer to look at what the assigned task is.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}
|
Scene_Objects:['fork', 'sheets', 'food_salt', 'tea', 'blow_dryer', 'wallshelf', 'ceiling', 'character', 'food_cake', 'computer', 'tvstand', 'window', 'mousepad', 'cutting_board', 'basket_for_clothes', 'cup', 'newspaper', 'light_bulb', 'novel', 'photoframe', 'coin', 'food_donut', 'rag', 'cards', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'maindoor', 'bag', 'creditcard']
Task:Clean
response:
| {
"thoughts": "Clean the welcome mat",
"actions": [
"[WALK] <home_office>",
"[WALK] <vacuum_cleaner>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'light_bulb', 'novel', 'television', 'curtain', 'cupboard', 'bathtub', 'table']
Task:Read book
response:
{
"thoughts": I go to the living room, take a book from the shelf, sit in the sofa and read the book,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>']
}
|
Scene_Objects:['sheets', 'fork', 'scissors', 'food_salt', 'dog', 'milk', 'drawing', 'needle', 'hanger', 'bedroom', 'keyboard', 'bookshelf', 'stovefan', 'tvstand', 'closetdrawer', 'wall_clock', 'oven', 'toy', 'photoframe', 'novel', 'toilet_paper', 'food_food', 'check', 'food_onion', 'kitchen_counter', 'hairdryer', 'bathtub', 'vase', 'instrument_violin', 'creditcard']
Task:Read book
response:
| {
"thoughts": "Go to the book shelf, get a book, open the book and read the book.",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'powersocket', 'clothes_gloves', 'television', 'razor', 'curtain', 'doorjamb', 'console', 'mouse', 'door', 'bag', 'table', 'dishwasher']
Task:Change TV channel
response:
{
"thoughts": I walk in living room. I find TV remote. I grab TV remote. I sit on sofa. I switch on TV. I switch channel.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[PUSH] <remote_control>']
}
|
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'phone', 'button', 'mat', 'stereo', 'window', 'homework', 'foundation', 'couch', 'pillow', 'wall', 'toy', 'cup', 'light_bulb', 'television', 'razor', 'curtain', 'after_shave', 'doorjamb', 'rag', 'coffee_pot', 'laundry_detergent', 'bathtub', 'table']
Task:Arrange furniture
response:
| {
"thoughts": "Move furniture where you want it.",
"actions": [
"[WALK] <home_office>",
"[WALK] <coffee_table>",
"[PUSH] <coffee_table>",
"[WALK] <couch>",
"[PUSH] <couch>",
"[WALK] <couch>",
"[PUSH] <couch>",
"[WALK] <filing_cabinet>",
"[PUSH] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'measuring_cup', 'toilet', 'chair', 'cat', 'milk', 'orchid', 'phone', 'video_game_console', 'bookshelf', 'keyboard', 'purse', 'table_cloth', 'brush', 'mat', 'iron', 'couch', 'cup', 'basket_for_clothes', 'video_game_controller', 'oven_mitts', 'food_donut', 'doorjamb', 'console', 'dresser', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'home_office']
Task:Playing video game
response:
{
"thoughts": Playing video games on various video game systems such as wii u and xbox,
"actions": ['[WALK] <home_office>', '[WALK] <video_game_console>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[PUTOBJBACK] <video_game_controller>', '[SWITCHOFF] <video_game_console>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>']
}
|
Scene_Objects:['chair', 'walllamp', 'ground_coffee', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'bookmark', 'ceilinglamp', 'window', 'foundation', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'television', 'coffee_filter', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'sink', 'light', 'table', 'shoe_rack']
Task:Write an email
response:
| {
"thoughts": "Compose an email in the home office.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'bathroom', 'orchid', 'wallshelf', 'ceiling', 'phone', 'stamp', 'bookshelf', 'mail', 'computer', 'tvstand', 'shower', 'couch', 'pillow', 'oven', 'powersocket', 'box', 'bed', 'clothes_gloves', 'photoframe', 'check', 'curtain', 'pencil', 'dresser', 'cupboard', 'door', 'sink', 'bathtub', 'home_office', 'dishwasher']
Task:Pet cat
response:
{
"thoughts": find a cat, touch it gently,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['sheets', 'toilet', 'dog', 'band-aids', 'walllamp', 'ground_coffee', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'phone', 'food_cake', 'computer', 'toaster', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'table', 'light', 'scrabble']
Task:Relax on sofa
response:
| {
"thoughts": "I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[TURNTO] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'food_pizza', 'food_salt', 'freezer', 'drawing', 'knife', 'cpuscreen', 'knifeblock', 'floor', 'character', 'bookshelf', 'laptop', 'plate', 'mousepad', 'candle', 'dining_room', 'wall', 'light_bulb', 'food_food', 'coffe_maker', 'tray', 'kitchen_counter', 'chessboard', 'dishrack', 'shoes', 'cupboard', 'laundry_detergent', 'dishwasher', 'instrument_violin']
Task:Wash dishes with dishwasher
response:
{
"thoughts": I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'food_butter', 'dough', 'food_carrot', 'drawing', 'food_egg', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'faucet', 'oil', 'wall', 'pasta', 'powersocket', 'oven', 'wall_clock', 'cutting_board', 'food_food', 'coffe_maker', 'oven_mitts', 'wooden_spoon', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'maindoor', 'sink', 'bathroom_cabinet', 'light']
Task:Cook some food
response:
| {
"thoughts": "I walk into the kitchen and walk over the cabinent. I pull out a pan and walk to the stove. I put the pan on the stove and walk over to the fridge. I pull out out meat from the fridge and walk back over the stove. Then I put the meat in the pan.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <kitchen_cabinet>",
"[FIND] <pot>",
"[GRAB] <pot>",
"[WALK] <oven>",
"[PUTBACK] <pot> <oven>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_chicken>",
"[GRAB] <food_chicken>",
"[WALK] <oven>",
"[PUTBACK] <food_chicken> <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_salt', 'microwave', 'ceilingfan', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'stovefan', 'mat', 'iron', 'electric_shaver', 'food_noodles', 'mousepad', 'couch', 'clothes_pants', 'pillow', 'powersocket', 'keys', 'coffe_maker', 'oven_mitts', 'wine', 'shaving_cream', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'light', 'tooth_paste']
Task:Hang up car keys
response:
{
"thoughts": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,
"actions": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']
}
|
Scene_Objects:['microwave', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'mat', 'window', 'clothes_socks', 'couch', 'pillow', 'towel', 'broom', 'wall', 'bench', 'oven', 'toy', 'bed', 'coffe_maker', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'food_onion', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table', 'scrabble']
Task:Relax on sofa
response:
| {
"thoughts": "Walk to living room. Find couch. Sit on couch",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'juice', 'measuring_cup', 'microwave', 'walllamp', 'trashcan', 'floor', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'candle', 'pillow', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'newspaper', 'coffe_maker', 'tray', 'kitchen_counter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['toilet', 'chair', 'walllamp', 'floor', 'dvd_player', 'bedroom', 'bookshelf', 'food_cake', 'shower', 'picture', 'foundation', 'mousepad', 'closetdrawer', 'tooth_paste', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'shelf', 'food_food', 'doorjamb', 'coffee_pot', 'mouse', 'pencil', 'kitchen_counter', 'towel_rack', 'door', 'napkin', 'bathroom_cabinet', 'board_game']
Task:Go to toilet
response:
| {
"thoughts": "I go to the bathroom. I locate the toilet. I walk to the toilet.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <toilet>",
"[FIND] <toilet>",
"[WALK] <toilet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'walllamp', 'ceilingfan', 'drawing', 'hanger', 'floor', 'bedroom', 'computer', 'ceilinglamp', 'deck_of_cards', 'iron', 'window', 'electric_shaver', 'couch', 'food_orange', 'wall', 'wall_clock', 'bed', 'novel', 'check', 'television', 'toothbrush_holder', 'wooden_spoon', 'after_shave', 'towel_rack', 'dresser', 'conditioner', 'maindoor', 'table', 'vase']
Task:Relax on sofa
response:
{
"thoughts": Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['microwave', 'food_egg', 'bathroom_counter', 'ceiling', 'computer', 'button', 'food_bacon', 'plate', 'stereo', 'shower', 'window', 'picture', 'food_kiwi', 'wall', 'wall_clock', 'toy', 'shelf', 'bed', 'toilet_paper', 'oven_mitts', 'tray', 'after_shave', 'doorjamb', 'mouse', 'pencil', 'clothes_dress', 'maindoor', 'sink', 'food_steak', 'bathroom_cabinet']
Task:Listen to music
response:
| {
"thoughts": "I go into the living room and turn on the radio. Then, I select the station I want, which is usually a preset.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[FIND] <button>",
"[PUSH] <button>",
"[FIND] <button>",
"[PUSH] <button>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'bathroom', 'ceilingfan', 'drawing', 'bills', 'knife', 'orchid', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'keys', 'television', 'coffee_filter', 'curtain', 'centerpiece', 'cupboard', 'bathroom_cabinet', 'table']
Task:Change TV channel
response:
{
"thoughts": change the tv channel,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[FIND] <button>', '[PUSH] <button>']
}
|
Scene_Objects:['food_ice_cream', 'tea', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'table_cloth', 'mat', 'stereo', 'window', 'foundation', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'bench', 'keys', 'toilet_paper', 'food_food', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'vacuum_cleaner', 'comb', 'maindoor', 'bathtub', 'table']
Task:Relax on sofa
response:
| {
"thoughts": "move to living room, locate sofa, move to sofa, sit on sofa, lie on sofa",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[WALK] <couch>",
"[SIT] <couch>",
"[LIE] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'juice', 'toilet', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'phone', 'desk', 'stovefan', 'plate', 'faucet', 'window', 'mousepad', 'form', 'pillow', 'wall', 'wall_clock', 'oven', 'clothes_gloves', 'tray', 'diary', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'sink']
Task:Wash dishes by hand
response:
{
"thoughts": Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry.,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[TURNTO] <plate>', '[LOOKAT] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WASH] <plate>', '[PUTBACK] <plate> <kitchen_counter>']
}
|
Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'wallshelf', 'hanger', 'phone', 'character', 'desk', 'table_cloth', 'mat', 'tvstand', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall_clock', 'powersocket', 'cutting_board', 'television', 'food_donut', 'food_rice', 'towel_rack', 'controller', 'maindoor']
Task:Pet cat
response:
| {
"thoughts": "find a cat, touch it gently",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'toaster', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'love_seat', 'clothes_gloves', 'television', 'tray', 'curtain', 'food_onion', 'dresser', 'cupboard', 'instrument_guitar', 'table', 'light']
Task:Watch TV
response:
{
"thoughts": I'll watch TV,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'blender', 'milk', 'orchid', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'thread', 'stovefan', 'mat', 'toaster', 'faucet', 'plate', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'wall_clock', 'oven', 'tray', 'curtain', 'mouse', 'sink', 'napkin', 'bathroom_cabinet', 'soap']
Task:Wash hands
response:
| {
"thoughts": "walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse hands,",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <sink>",
"[FIND] <soap>",
"[WASH] <soap>",
"[RINSE] <soap>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'food_bread', 'dog', 'ground_coffee', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'bedroom', 'alcohol', 'mop_bucket', 'stovefan', 'laptop', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'window', 'mat', 'mousepad', 'food_orange', 'pillow', 'powersocket', 'coffe_maker', 'fly', 'coffee_pot', 'kitchen_counter', 'cupboard', 'dishwasher', 'soap']
Task:Watch fly
response:
{
"thoughts": Look around for a fly, often on a wall or ceiling. Follow it's movements.,
"actions": ['[WALK] <bedroom>', '[WALK] <fly>', '[FIND] <fly>', '[TURNTO] <fly>', '[LOOKAT] <fly>']
}
|
Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'orchid', 'hanger', 'phone', 'computer', 'piano_bench', 'nightstand', 'pasta', 'wall_clock', 'powersocket', 'toy', 'food_cheese', 'clothes_gloves', 'check', 'toilet_paper', 'television', 'after_shave', 'doorjamb', 'door', 'hairdryer', 'sink', 'home_office', 'light', 'table', 'clothes_scarf', 'soap']
Task:Read book
response:
| {
"thoughts": "go to bedroom, sit down, pick up book, read",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'stovefan', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'towel', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'coin', 'tray', 'food_onion', 'doorjamb', 'towel_rack', 'dishrack', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Go to the bathroom. Turn on the sink. Rinse hands. Apply soap and scrub your hands together. Rinse hands again. Turn off faucet. Dry hands on a towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['food_salt', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'thread', 'computer', 'piano_bench', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table']
Task:Work
response:
| {
"thoughts": "Walk to the home office and turn to the desk. Switch on the computer. Grab the mouse and keyboard to start working.",
"actions": [
"[WALK] <home_office>",
"[WALK] <desk>",
"[FIND] <desk>",
"[TURNTO] <desk>",
"[FIND] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[SWITCHON] <computer>",
"[FIND] <keyboard>",
"[GRAB] <keyboard>",
"[FIND] <mouse>",
"[GRAB] <mouse>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'laptop', 'faucet', 'tvstand', 'window', 'couch', 'microphone', 'towel', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'food_food', 'television', 'tray', 'mouse', 'dresser', 'sink', 'clothes_scarf', 'home_office', 'table', 'clothes_skirt']
Task:Relax on sofa
response:
{
"thoughts": I walk to the living room. I see the couch. I sit down on the couch, then lie down and put my feet up.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['toilet', 'chair', 'dog', 'walllamp', 'ground_coffee', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'shower', 'faucet', 'clothes_socks', 'towel', 'wall', 'cutting_board', 'shelf', 'basket_for_clothes', 'coffe_maker', 'food_rice', 'water', 'tray', 'doorjamb', 'food_steak', 'home_office', 'vase', 'soap', 'teeth']
Task:Take shower
response:
| {
"thoughts": "Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <shower>",
"[FIND] <shower>",
"[TURNTO] <shower>",
"[FIND] <water>",
"[RINSE] <water>",
"[FIND] <soap>",
"[WASH] <soap>",
"[RINSE] <water>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[SCRUB] <towel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'toilet', 'dog', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'longboard', 'floor', 'phone', 'character', 'purse', 'computer', 'toaster', 'plate', 'balanceball', 'stereo', 'dish_soap', 'food_kiwi', 'wall', 'oven', 'tape', 'coffe_maker', 'mouthwash', 'tray', 'door', 'sink', 'napkin', 'dishwasher', 'vase']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'oil', 'pillow', 'dining_room', 'wall', 'wall_clock', 'bench', 'standingmirror', 'television', 'curtain', 'doorjamb', 'mouse', 'headset', 'napkin', 'table']
Task:Watch TV
response:
| {
"thoughts": "Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[WALK] <chair>",
"[SIT] <chair>",
"[TURNTO] <television>",
"[WATCH] <television>",
"[SWITCHOFF] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'microwave', 'freezer', 'trashcan', 'toothbrush', 'orchid', 'hanger', 'desk', 'keyboard', 'bookmark', 'shoe-shine_kit', 'iron', 'tvstand', 'plate', 'mousepad', 'microphone', 'wall', 'bench', 'toilet_paper', 'television', 'toothbrush_holder', 'ice', 'shoes', 'chessboard', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'tooth_paste', 'teeth', 'creditcard']
Task:Wash teeth
response:
{
"thoughts": walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the teeth,
"actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>']
}
|
Scene_Objects:['toilet', 'freezer', 'dough', 'cpuscreen', 'hanger', 'computer', 'piano_bench', 'bookmark', 'mat', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'wall', 'nightstand', 'box', 'photoframe', 'toilet_paper', 'video_game_controller', 'food_food', 'doorjamb', 'towel_rack', 'hairbrush', 'hair', 'instrument_violin', 'sink', 'home_office', 'light', 'vase', 'tooth_paste']
Task:Pick up phone
response:
| {
"thoughts": "walk into room, grab phone",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'floor', 'ceiling', 'bedroom', 'window', 'clothes_socks', 'couch', 'dustpan', 'clothes_pants', 'food_orange', 'food_kiwi', 'wall', 'toy', 'bed', 'photoframe', 'food_food', 'coffe_maker', 'wine', 'doorjamb', 'diary', 'console', 'mouse', 'door', 'bathroom_cabinet', 'light', 'vase', 'soap']
Task:Turn off light
response:
{
"thoughts": Grasp light switch, flip light switch.,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[SWITCHOFF] <light>']
}
|
Scene_Objects:['microwave', 'toilet', 'freezer', 'ground_coffee', 'walllamp', 'dough', 'food_carrot', 'floor', 'ceiling', 'stovefan', 'toaster', 'stereo', 'clothes_hat', 'wall', 'oven', 'bench', 'cutting_board', 'food_cheese', 'coffe_maker', 'food_food', 'check', 'toothbrush_holder', 'food_donut', 'tray', 'kitchen_counter', 'dishrack', 'hairbrush', 'bag', 'bathroom_cabinet', 'creditcard']
Task:Put groceries in Fridge
response:
| {
"thoughts": "Open the fridge, put the groceries in the fridge and close it.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'nail_polish', 'bathroom', 'detergent', 'knife', 'cpuscreen', 'dvd_player', 'bedroom', 'computer', 'table_cloth', 'mop_bucket', 'brush', 'toaster', 'shower', 'window', 'couch', 'dining_room', 'wall', 'pasta', 'cup', 'photoframe', 'after_shave', 'pencil', 'kitchen_counter', 'dresser', 'clothes_dress', 'sink', 'instrument_guitar', 'light', 'creditcard']
Task:Sit
response:
{
"thoughts": We sit at the dining room table,
"actions": ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>']
}
|
Scene_Objects:['glue', 'dog', 'bathroom', 'toothbrush', 'orchid', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'dining_room', 'wall', 'wall_clock', 'oven', 'razor', 'toothbrush_holder', 'tray', 'centerpiece', 'doorjamb', 'instrument_violin', 'sink', 'bathroom_cabinet', 'vase', 'tooth_paste']
Task:Brush teeth
response:
| {
"thoughts": "go to bathroom. grab toothbrush. put toothpaste on toothbrush. brush teeth. turn on faucet. rinse toothbrush and mouth. put toothbrush away.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <toothbrush_holder>",
"[TURNTO] <toothbrush_holder>",
"[LOOKAT] <toothbrush_holder>",
"[FIND] <tooth_paste>",
"[GRAB] <tooth_paste>",
"[FIND] <toothbrush>",
"[GRAB] <toothbrush>",
"[PUTBACK] <tooth_paste> <toothbrush_holder>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <toothbrush>",
"[PUTBACK] <toothbrush> <toothbrush_holder>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'mat', 'faucet', 'window', 'wall', 'wall_clock', 'powersocket', 'box', 'cup', 'bed', 'video_game_controller', 'television', 'doorjamb', 'console', 'kitchen_counter', 'door', 'light', 'teeth']
Task:Pick up phone
response:
{
"thoughts": I walk over to the phone and pick it up.,
"actions": ['[WALK] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['spectacles', 'blender', 'crayon', 'microwave', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'envelope', 'stovefan', 'window', 'oil', 'wall', 'powersocket', 'bench', 'toy', 'keys', 'food_donut', 'wooden_spoon', 'curtain', 'doorjamb', 'maindoor', 'bathtub', 'bathroom_cabinet', 'light', 'dirt', 'teeth']
Task:Turn on light
response:
| {
"thoughts": "walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <home_office>",
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_carrot', 'milk', 'dough', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'stereo', 'towel', 'pillow', 'wall', 'bench', 'cup', 'bed', 'photoframe', 'coffe_maker', 'wooden_spoon', 'after_shave', 'rag', 'mouse', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Turn on the water faucet. Wet my hands and turn off the faucet. Put soap on my hands. Rub hands together, making sure the soap covers all areas of the hands. Scrub hands for about 20 seconds. Turn on the water water faucet. Rinse hands under the running water. Turn off the water faucet. Dry hands with a towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['dry_pasta', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'table_cloth', 'stovefan', 'mat', 'faucet', 'foundation', 'mousepad', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'toy', 'hands_both', 'tray', 'doorjamb', 'towel_rack', 'shaving_cream', 'door', 'sink', 'spoon', 'bathroom_cabinet', 'light', 'teeth']
Task:Wash teeth
response:
| {
"thoughts": "I need to rinse my dentures off and put them back in my mouth.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <teeth>",
"[GRAB] <teeth>",
"[WASH] <teeth>",
"[PUTOBJBACK] <teeth>",
"[SWITCHOFF] <faucet>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[FIND] <hands_both>",
"[SCRUB] <hands_both>",
"[PUTOBJBACK] <towel>",
"[SWITCHOFF] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'pot', 'fork', 'tablelamp', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'toaster', 'plate', 'tvstand', 'dish_soap', 'food_noodles', 'bowl', 'wall', 'pasta', 'oven', 'box', 'coffe_maker', 'television', 'ice', 'tray', 'curtain', 'console', 'towel_rack', 'pencil', 'maindoor', 'sink', 'instrument_guitar', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Wash a plate using the dishwasher in the kitchen.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'walllamp', 'nail_polish', 'cpuscreen', 'bathroom_counter', 'character', 'desk', 'folder', 'keyboard', 'food_cake', 'bedroom', 'alcohol', 'stovefan', 'toaster', 'shower', 'window', 'candle', 'pillow', 'wall', 'wall_clock', 'oven', 'nightstand', 'cutting_board', 'video_game_controller', 'curtain', 'doorjamb', 'towel_rack', 'shoes', 'board_game']
Task:Read book
response:
| {
"thoughts": "pick up your book and read it",
"actions": [
"[WALK] <bedroom>",
"[WALK] <novel>",
"[GRAB] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'toaster', 'shower', 'wall', 'novel', 'food_food', 'television', 'oven_mitts', 'tray', 'kitchen_counter', 'headset', 'dresser', 'cupboard', 'hair', 'bathtub']
Task:Put groceries in Fridge
response:
{
"thoughts": Go to kitchen, open fridge, get groceries, put groceries in fridge, close fridge,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}
|
Scene_Objects:['pot', 'food_pizza', 'toilet', 'detergent', 'toothbrush', 'orchid', 'wallshelf', 'hanger', 'bedroom', 'bookshelf', 'computer', 'shower', 'window', 'cutting_board', 'food_cheese', 'novel', 'check', 'mouthwash', 'toothbrush_holder', 'wine', 'doorjamb', 'pajamas', 'hairdryer', 'maindoor', 'bathtub', 'home_office', 'door', 'clothes_skirt', 'tooth_paste', 'teeth']
Task:Wash teeth
response:
| {
"thoughts": "walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the teeth",
"actions": [
"[WALK] <bathroom>",
"[WALK] <toothbrush_holder>",
"[FIND] <toothbrush_holder>",
"[TURNTO] <toothbrush_holder>",
"[LOOKAT] <toothbrush_holder>",
"[FIND] <toothbrush>",
"[GRAB] <toothbrush>",
"[FIND] <tooth_paste>",
"[SQUEEZE] <tooth_paste>",
"[FIND] <teeth>",
"[WASH] <teeth>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'faucet', 'shower', 'tooth_paste', 'towel', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'clothes_gloves', 'light_bulb', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'vase', 'soap', 'home_office', 'hands_both']
Task:Wash hands
response:
{
"thoughts": I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}
|
Scene_Objects:['freezer', 'bathroom', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stovefan', 'mat', 'faucet', 'dining_room', 'wall', 'wall_clock', 'oven', 'newspaper', 'light_bulb', 'tray', 'curtain', 'towel_rack', 'laundry_detergent', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'bathtub', 'home_office', 'soap', 'laser_pointer', 'hands_both']
Task:Wash hands
response:
| {
"thoughts": "go to the bathroom and wash your hands",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <soap>",
"[SQUEEZE] <soap>",
"[FIND] <hands_both>",
"[WASH] <hands_both>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'nightstand', 'feet_both', 'photoframe', 'bed', 'television', 'coin', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'shoes', 'hairbrush', 'door']
Task:Put on your shoes
response:
{
"thoughts": Sit on a chair with your shoes in front of you. Put them on one at a time.,
"actions": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <feet_both>', '[PUTBACK] <shoes> <feet_both>']
}
|
Scene_Objects:['scissors', 'blender', 'tablelamp', 'ground_coffee', 'bathroom', 'toothbrush', 'drawing', 'knife', 'orchid', 'desk', 'keyboard', 'brush', 'shower', 'homework', 'food_jam', 'pillow', 'dining_room', 'bowl', 'wall_clock', 'check', 'television', 'toothbrush_holder', 'tray', 'kettle', 'kitchen_counter', 'maindoor', 'sink', 'clothes_skirt', 'tooth_paste', 'dirt']
Task:Wash teeth
response:
| {
"thoughts": "WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR TEETH",
"actions": [
"[WALK] <bathroom>",
"[WALK] <toothbrush_holder>",
"[FIND] <toothbrush_holder>",
"[FIND] <tooth_paste>",
"[GRAB] <tooth_paste>",
"[FIND] <toothbrush>",
"[GRAB] <toothbrush>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'glue', 'tablelamp', 'mop', 'microwave', 'freezer', 'walllamp', 'needle', 'food_egg', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'stovefan', 'stereo', 'form', 'dining_room', 'wall', 'oven', 'powersocket', 'cutting_board', 'toy', 'keys', 'food_food', 'coffe_maker', 'wine', 'tray', 'kitchen_counter', 'clothes_scarf', 'creditcard']
Task:Put groceries in Fridge
response:
{
"thoughts": Open the fridge, and put groceries in the fridge. Close the fridge.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}
|
Scene_Objects:['dry_pasta', 'food_bread', 'microwave', 'freezer', 'ground_coffee', 'dough', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'toaster', 'faucet', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'kitchen_counter', 'cupboard', 'sink']
Task:Make coffee
response:
| {
"thoughts": "I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[OPEN] <coffe_maker>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <coffe_maker>",
"[CLOSE] <coffe_maker>",
"[SWITCHON] <coffe_maker>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'microphone', 'form', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'television', 'curtain', 'vacuum_cleaner', 'dishrack', 'dresser', 'hairbrush', 'door', 'table', 'soap']
Task:Watch TV
response:
{
"thoughts": I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['scissors', 'crayon', 'chair', 'nail_polish', 'cat', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'computer', 'food_bacon', 'clothes_jacket', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'toy', 'doorjamb', 'kettle', 'mouse', 'dresser', 'hairdryer', 'sink', 'bathroom_cabinet', 'light']
Task:Turn on light
response:
| {
"thoughts": "Coming home turning on lights.",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'microwave', 'freezer', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'button', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'couch', 'wall', 'wall_clock', 'oven', 'keys', 'coffe_maker', 'water', 'tray', 'curtain', 'coffee_pot', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'tooth_paste']
Task:Drink
response:
{
"thoughts": I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'sponge', 'microwave', 'freezer', 'walllamp', 'food_carrot', 'hanger', 'bathroom_counter', 'floor', 'envelope', 'stovefan', 'mat', 'faucet', 'clothes_hat', 'wall', 'wall_clock', 'oven', 'cutting_board', 'cup', 'food_vegetable', 'food_food', 'coin', 'water', 'tray', 'kitchen_counter', 'shoes', 'door', 'sink', 'bathroom_cabinet']
Task:Cook some food
response:
| {
"thoughts": "walk to kicthen , find stove , find cooking pot , find vegetables , find water ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove",
"actions": [
"[WALK] <dining_room>",
"[WALK] <oven>",
"[FIND] <oven>",
"[FIND] <pot>",
"[FIND] <food_vegetable>",
"[FIND] <water>",
"[GRAB] <water>",
"[WASH] <food_vegetable>",
"[POUR] <water> <pot>",
"[FIND] <pot>",
"[GRAB] <pot>",
"[PUTBACK] <pot> <oven>",
"[SWITCHON] <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_ice_cream', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'shower', 'mousepad', 'food_peanut_butter', 'food_jam', 'wall', 'bench', 'powersocket', 'toy', 'box', 'standingmirror', 'coffe_maker', 'water', 'doorjamb', 'cards', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'soap', 'board_game']
Task:Take shower
response:
{
"thoughts": go to a bathroom, open the shower, let water wash your body,
"actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']
}
|
Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'knife', 'cpuscreen', 'hanger', 'floor', 'phone', 'desk', 'keyboard', 'thread', 'computer', 'piano_bench', 'toaster', 'laptop', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'box', 'console', 'mouse', 'dresser', 'maindoor', 'hairdryer', 'board_game']
Task:Write an email
response:
| {
"thoughts": "I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email",
"actions": [
"[WALK] <laptop>",
"[SWITCHON] <laptop>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'chair', 'walllamp', 'detergent', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'napkin']
Task:Watch TV
response:
{
"thoughts": Find the remote, turn on the TV, watch.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['food_pizza', 'microwave', 'dog', 'drawing', 'hanger', 'bedroom', 'desk', 'computer', 'table_cloth', 'stovefan', 'brush', 'faucet', 'mousepad', 'dining_room', 'bowl', 'wall_clock', 'powersocket', 'novel', 'food_food', 'check', 'coffee_filter', 'kitchen_counter', 'cd', 'food_steak', 'napkin', 'home_office', 'light', 'clothes_skirt', 'vase', 'board_game']
Task:Listen to music
response:
| {
"thoughts": "Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[SWITCHON] <stereo>"
]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.