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:['microwave', 'bathroom', 'detergent', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'video_game_console', 'keyboard', 'stovefan', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall_clock', 'oven', 'bed', 'coffe_maker', 'video_game_controller', 'television', 'doorjamb', 'cd', 'cupboard', 'door', 'bathtub', 'bathroom_cabinet', 'light', 'home_office', 'table']
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:['filing_cabinet', 'juice', 'chair', 'blow_dryer', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'toaster', 'laptop', 'deck_of_cards', 'faucet', 'food_noodles', 'closetdrawer', 'food_orange', 'wall', 'nightstand', 'clothes_gloves', 'coffe_maker', 'toilet_paper', 'food_food', 'curtain', 'towel_rack', 'console', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'spoon', 'dishwasher']
Task:Make coffee
response:
| {
"thoughts": "Making coffee",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <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', 'food_salt', 'microwave', 'chair', 'walllamp', 'knifeblock', 'floor', 'phone', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'purse', 'toaster', 'mat', 'stereo', 'faucet', 'mousepad', 'pillow', 'mouthwash', 'curtain', 'cards', 'shoes', 'cd', 'dishrack', 'dresser', 'door', 'instrument_guitar', 'table', 'bathroom_cabinet']
Task:Read book
response:
{
"thoughts": Read a book,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[PUTOBJBACK] <novel>']
}
|
Scene_Objects:['chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'toy', 'photoframe', 'bed', 'television', 'doorjamb', 'towel_rack', 'dresser', 'dishwasher', 'shoe_rack']
Task:Watch movie
response:
| {
"thoughts": "Sit down on couch in front of TV. Use remote to turn on the TV",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[WATCH] <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:['filing_cabinet', 'tablelamp', 'microwave', 'jelly', 'chair', 'walllamp', 'detergent', 'trashcan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'keyboard', 'stovefan', 'mat', 'ceilinglamp', 'food_orange', 'wall', 'bench', 'oven', 'food_food', 'oven_mitts', 'doorjamb', 'dresser', 'cupboard', 'home_office', 'table', 'bathroom_cabinet']
Task:Play games
response:
{
"thoughts": I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours.,
"actions": ['[WALK] <home_office>', '[WALK] <board_game>', '[FIND] <board_game>', '[GRAB] <board_game>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <board_game> <table>']
}
|
Scene_Objects:['sponge', 'tablelamp', 'chair', 'detergent', 'toothbrush', 'floor', 'ceiling', 'food_cake', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'ceilinglamp', 'dish_soap', 'closetdrawer', 'pillow', 'bowl', 'dining_room', 'wall', 'powersocket', 'cup', 'food_cheese', 'clothes_gloves', 'coffe_maker', 'after_shave', 'kitchen_counter', 'dishrack', 'cupboard', 'sink']
Task:Wash dishes
response:
| {
"thoughts": "Turn water on and run over dishes while scrubbing with a soapy sponge.",
"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>",
"[RINSE] <plate>",
"[FIND] <dishrack>",
"[PUTBACK] <plate> <dishrack>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[SCRUB] <plate>",
"[RINSE] <plate>",
"[PUTBACK] <plate> <dishrack>",
"[RINSE] <sponge>",
"[PUTOBJBACK] <sponge>",
"[SWITCHOFF] <faucet>"
]
} |
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', 'food_bread', 'microwave', 'chair', 'band-aids', 'woman', 'needle', 'longboard', 'man', 'keyboard', 'envelope', 'toaster', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'nightstand', 'box', 'light_bulb', 'coffe_maker', 'curtain', 'towel_rack', 'shoes', 'dresser', 'hairbrush', 'door', 'vase', 'instrument_violin', 'creditcard']
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>']
}
|
Scene_Objects:['pot', 'tablelamp', 'beer', 'microwave', 'chair', 'freezer', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'stovefan', 'shower', 'wall', 'powersocket', 'oven', 'coffe_maker', 'food_food', 'tray', 'rag', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'table', 'dishwasher', 'light']
Task:Clean
response:
| {
"thoughts": "Take out a rag. Turn on faucet and get water on the rag. Clean counter off.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[PUTBACK] <rag> <sink>",
"[SWITCHOFF] <faucet>",
"[GRAB] <rag>",
"[SQUEEZE] <rag>",
"[WALK] <kitchen_counter>",
"[WIPE] <kitchen_counter>",
"[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:['chair', 'walllamp', 'bathroom', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'table_cloth', 'ceilinglamp', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'shelf', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office', 'light', 'table', 'laser_pointer']
Task:Write an email
response:
{
"thoughts": Find the computer. Turn on the computer. Open the e-mail program. Create a new message. Write the message.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['tablelamp', 'mop', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'table_cloth', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'keys', 'newspaper', 'food_rice', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet', 'light', 'scrabble']
Task:Turn light off
response:
| {
"thoughts": "Put the light switch into the down, or off, position.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <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', 'toilet', 'freezer', 'bathroom', 'detergent', 'food_butter', 'longboard', 'bookshelf', 'stovefan', 'shower', 'pillow', 'towel', 'dining_room', 'nightstand', 'powersocket', 'toy', 'basket_for_clothes', 'newspaper', 'light_bulb', 'photoframe', 'food_food', 'coin', 'doorjamb', 'headset', 'shoes', 'hairbrush', 'cupboard', 'napkin', 'home_office']
Task:Listen to music
response:
{
"thoughts": I walk into my room and turn the radio on so that I can listen to music.,
"actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['measuring_cup', 'toilet', 'chair', 'freezer', 'walllamp', 'toothbrush', 'phone', 'character', 'bedroom', 'bookshelf', 'purse', 'food_cake', 'stovefan', 'stereo', 'electric_shaver', 'homework', 'couch', 'dining_room', 'nightstand', 'toy', 'light_bulb', 'video_game_controller', 'wooden_spoon', 'tray', 'kitchen_counter', 'sink', 'clothes_scarf', 'home_office', 'bag', 'light']
Task:Walk through
response:
| {
"thoughts": "Walk through the hallway.",
"actions": [
"[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:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'keyboard', 'purse', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'food_noodles', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'table']
Task:Write an email
response:
{
"thoughts": FIRST YOU NEED TO SWITVH ON YOU COMPUTER AND CHECK THE INTERNET CONNECTION.FOR SENDING EMAIL EMAIL ID FOR REQUIRED FOR BOTH SEND AND RECEIVE .SO CLEALY MENTION THE ID ON THE TO PLACE THEN ONLY IT WILL GO CORRECTLY,
"actions": ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[FIND] <computer>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table']
Task:Draft home
response:
| {
"thoughts": "Using mathematics and CAD software design a home",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[TURNTO] <computer>",
"[POINTAT] <computer>",
"[PUTOBJBACK] <mouse>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[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:['filing_cabinet', 'toilet', 'walllamp', 'bathroom', 'food_carrot', 'knife', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'stamp', 'purse', 'computer', 'mat', 'shoe-shine_kit', 'shower', 'foundation', 'mousepad', 'closetdrawer', 'food_jam', 'powersocket', 'coffe_maker', 'television', 'tray', 'curtain', 'diary', 'cards', 'pencil', 'table']
Task:Listen to music
response:
{
"thoughts": I walk to the radio. I switch on the radio and listen,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'computer', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'clothes_socks', 'closetdrawer', 'couch', 'pillow', 'towel', 'wall', 'powersocket', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet']
Task:Watch TV
response:
| {
"thoughts": "Sit on the couch and use the remote control to turn on the TV",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[PUTOBJBACK] <remote_control>",
"[TURNTO] <television>",
"[WATCH] <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:['sheets', 'microwave', 'toilet', 'ground_coffee', 'blow_dryer', 'orchid', 'wallshelf', 'bathroom_counter', 'character', 'desk', 'bookshelf', 'alcohol', 'computer', 'ceilinglamp', 'laptop', 'faucet', 'pillow', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'cup', 'television', 'oven_mitts', 'after_shave', 'doorjamb', 'diary', 'towel_rack', 'cards', 'maindoor']
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:['pot', 'juice', 'blow_dryer', 'walllamp', 'detergent', 'floor', 'ceiling', 'bedroom', 'keyboard', 'purse', 'tvstand', 'deck_of_cards', 'clothes_pants', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'keys', 'tray', 'kettle', 'shoes', 'hair', 'sink', 'home_office', 'table', 'dishwasher', 'soap', 'board_game', 'dirt']
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>"
]
} |
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', 'chair', 'freezer', 'walllamp', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'faucet', 'window', 'oil', 'couch', 'wall', 'bench', 'powersocket', 'photoframe', 'bed', 'television', 'curtain', 'after_shave', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'light']
Task:Open bathroom window
response:
{
"thoughts": Make sure bathroom window is unlocked. Lift up bathroom window so it is open.,
"actions": ['[WALK] <bathroom>', '[WALK] <window>', '[FIND] <window>', '[OPEN] <window>']
}
|
Scene_Objects:['pot', 'tablelamp', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'floor_lamp', 'mousepad', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'door', 'light', 'laser_pointer']
Task:Read book
response:
| {
"thoughts": "Take a book off the bookshelf. Sit down in a chair at the desk. Turn on desk lamp. Read the book.",
"actions": [
"[WALK] <home_office>",
"[WALK] <desk>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>",
"[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', 'food_ice_cream', 'chair', 'nail_polish', 'bathroom', 'cat', 'dough', 'toothbrush', 'desk', 'button', 'stovefan', 'shower', 'faucet', 'window', 'pillow', 'nightstand', 'wall_clock', 'oven', 'cutting_board', 'novel', 'check', 'television', 'toothbrush_holder', 'lighter', 'kettle', 'chessboard', 'dresser', 'sink', 'home_office', 'clothes_skirt']
Task:Keep cats out of room
response:
{
"thoughts": Stand in the doorway and create a loud noise so the cats will stay out.,
"actions": ['[WALK] <bedroom>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>']
}
|
Scene_Objects:['spectacles', 'pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'deck_of_cards', 'picture', 'mousepad', 'wall', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'cards', 'mouse', 'door', 'light', 'printing_paper']
Task:Add paper to printer
response:
| {
"thoughts": "Take a stack of paper, about 25 pieces. Place carefully in the paper tray.",
"actions": [
"[WALK] <home_office>",
"[WALK] <desk>",
"[FIND] <printing_paper>",
"[GRAB] <printing_paper>",
"[WALK] <fax_machine>",
"[PUTBACK] <printing_paper> <fax_machine>"
]
} |
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', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'computer', 'food_bacon', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'deck_of_cards', 'mousepad', 'couch', 'wall', 'nightstand', 'newspaper', 'television', 'mouse', 'door', 'sink', 'home_office']
Task:Read newspaper
response:
{
"thoughts": Sit in my chair at my desk. Open up newspaper. Read about current events.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[OPEN] <newspaper>', '[READ] <newspaper>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:
| {
"thoughts": "Go to the computer, sit in the chair, pull up computer screen get the mouse and keyboard load work software",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[FIND] <mousepad>",
"[PUTBACK] <mouse> <mousepad>",
"[TURNTO] <computer>",
"[POINTAT] <computer>",
"[PULL] <mouse>",
"[FIND] <button>",
"[PUSH] <button>",
"[GRAB] <mouse>",
"[PUTOBJBACK] <mouse>",
"[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:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'bathroom_cabinet']
Task:Use computer
response:
{
"thoughts": Browse the internet,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>']
}
|
Scene_Objects:['tablelamp', 'juice', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Write an email
response:
| {
"thoughts": "Open computer. Log in to email provider. Click new email tab. Write email. Click send.",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[FIND] <mail>",
"[OPEN] <mail>",
"[PUTOBJBACK] <mouse>",
"[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:['pot', 'tablelamp', 'bathroom', 'food_butter', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mop_bucket', 'toaster', 'shower', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'toy', 'bed', 'razor', 'television', 'after_shave', 'doorjamb', 'dresser', 'conditioner', 'door', 'light']
Task:Turn on light
response:
{
"thoughts": Walk into the bedroom and walk to the light switch. Flip the switch.,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['chair', 'freezer', 'food_carrot', 'drawing', 'orchid', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'computer', 'mat', 'plate', 'ceilinglamp', 'stereo', 'couch', 'candle', 'food_orange', 'pillow', 'wall', 'oven', 'food_vegetable', 'novel', 'food_food', 'razor', 'television', 'console', 'kitchen_counter', 'cupboard', 'controller', 'table']
Task:Fix snack
response:
| {
"thoughts": "Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[CLOSE] <kitchen_cabinet>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_carrot>",
"[GRAB] <food_carrot>",
"[PUTBACK] <food_carrot> <plate>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[PUTBACK] <food_vegetable> <plate>",
"[CLOSE] <freezer>",
"[WALK] <table>",
"[PUTBACK] <plate> <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:['water_glass', 'tablelamp', 'chair', 'freezer', 'detergent', 'food_carrot', 'knife', 'cpuscreen', 'kitchen_cabinet', 'character', 'bedroom', 'mail', 'stovefan', 'laptop', 'form', 'pillow', 'nightstand', 'bench', 'oven', 'cup', 'keys', 'toothbrush_holder', 'water', 'food_rice', 'curtain', 'controller', 'sink', 'bathtub', 'dishwasher', 'dirt']
Task:Drink
response:
{
"thoughts": Get a glass of water to drink,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']
}
|
Scene_Objects:['food_pizza', 'chair', 'walllamp', 'cat', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'box', 'photoframe', 'television', 'doorjamb', 'dresser', 'conditioner', 'door', 'coffee']
Task:Watch TV
response:
| {
"thoughts": "We sit all around the television and watch a program.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[TURNTO] <television>",
"[POINTAT] <television>",
"[SWITCHON] <television>",
"[PUTBACK] <remote_control> <couch>",
"[WATCH] <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:['pot', 'filing_cabinet', 'tablelamp', 'crayon', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'door', 'clothes_scarf', 'light']
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>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Complete surveys on amazon turk
response:
| {
"thoughts": "Sit down at computer, Turn computer on. Go online to Amazon mechanical turk, Browse through surveys, Select a survey.",
"actions": [
"[WALK] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[TURNTO] <computer>",
"[POINTAT] <computer>",
"[FIND] <check>",
"[GRAB] <check>",
"[READ] <check>",
"[PUTOBJBACK] <mouse>",
"[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:['tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cutting_board', 'cup', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'controller', 'door', 'light', 'table']
Task:Work
response:
{
"thoughts": Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[SWITCHOFF] <computer>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'door', 'table', 'light']
Task:Watch TV
response:
| {
"thoughts": "I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[TURNTO] <television>",
"[POINTAT] <television>",
"[PUTOBJBACK] <remote_control>",
"[WATCH] <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:['filing_cabinet', 'toilet', 'band-aids', 'freezer', 'food_carrot', 'toothbrush', 'orchid', 'floor', 'mail', 'button', 'faucet', 'foundation', 'oil', 'pillow', 'towel', 'food_food', 'toothbrush_holder', 'doorjamb', 'lighter', 'kettle', 'headset', 'cd', 'dresser', 'hairbrush', 'controller', 'napkin', 'light', 'dishwasher', 'tooth_paste', 'teeth']
Task:Brush teeth
response:
{
"thoughts": walk to bathroom, look at the toothbrush holder, take toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now brush teeth,
"actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[TURNTO] <toothbrush>', '[LOOKAT] <toothbrush>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Watch youtube
response:
| {
"thoughts": "Go to youtube.Com watch videos",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[TURNTO] <computer>",
"[LOOKAT] <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:['water_glass', 'tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'water', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink']
Task:Drink
response:
{
"thoughts": I need to go to Kitchen. Get a cup. Fill cup. Drink,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}
|
Scene_Objects:['sponge', 'crayon', 'chair', 'walllamp', 'hanger', 'floor', 'ceiling', 'phone', 'tea_bag', 'clothes_jacket', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'dish_soap', 'mousepad', 'dustpan', 'clothes_hat', 'wall', 'cup', 'coffe_maker', 'coffee_filter', 'curtain', 'coffee_pot', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'napkin']
Task:Wash dishes
response:
| {
"thoughts": "Place all of the dirty dishes in a sink full of clean, soapy water. Wash them. Rinse them in fresh, running water. Place them in the strainer to dry.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[SWITCHOFF] <faucet>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[POUR] <dish_soap> <sink>",
"[PUTOBJBACK] <dish_soap>",
"[FIND] <sponge>",
"[GRAB] <sponge>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[SCRUB] <cup>",
"[PUTOBJBACK] <cup>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[SCRUB] <cup>",
"[PUTOBJBACK] <cup>",
"[PUTBACK] <sponge> <sink>",
"[SWITCHON] <faucet>",
"[RINSE] <cup>",
"[GRAB] <cup>",
"[FIND] <dishrack>",
"[PUTBACK] <cup> <dishrack>",
"[RINSE] <cup>",
"[GRAB] <cup>",
"[PUTBACK] <cup> <dishrack>",
"[RINSE] <sponge>",
"[SWITCHOFF] <faucet>",
"[GRAB] <sponge>",
"[PUTOBJBACK] <sponge>"
]
} |
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', 'microwave', 'chair', 'freezer', 'walllamp', 'food_butter', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'bedroom', 'alcohol', 'window', 'food_jam', 'dining_room', 'wall', 'bench', 'powersocket', 'newspaper', 'food_food', 'doorjamb', 'kettle', 'towel_rack', 'dresser', 'cupboard', 'door', 'table', 'light']
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>']
}
|
Scene_Objects:['sheets', 'filing_cabinet', 'juice', 'microwave', 'jelly', 'bathroom', 'cat', 'dough', 'drawing', 'hanger', 'phone', 'character', 'bookshelf', 'food_bacon', 'ceilinglamp', 'tvstand', 'shower', 'clothes_hat', 'bowl', 'oven', 'toy', 'bed', 'photoframe', 'razor', 'curtain', 'vacuum_cleaner', 'cupboard', 'bathroom_cabinet', 'teeth', 'electrical_outlet']
Task:Vacuum
response:
| {
"thoughts": "Plug vacuum into the wall. Turn on the vacuum. Move vacuum around the floor to clean it. Unplug vacuum.",
"actions": [
"[WALK] <home_office>",
"[WALK] <vacuum_cleaner>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[FIND] <electrical_outlet>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[PUTOBJBACK] <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:['chair', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'shower', 'window', 'homework', 'mousepad', 'pillow', 'powersocket', 'photoframe', 'coffe_maker', 'doorjamb', 'kettle', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'clothes_dress', 'door', 'bag', 'light', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent.,
"actions": ['[WALK] <bedroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>']
}
|
Scene_Objects:['scissors', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'food_noodles', 'closetdrawer', 'couch', 'candle', 'pillow', 'dining_room', 'wall', 'food_cheese', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'headset', 'dresser', 'creditcard']
Task:Watch TV
response:
| {
"thoughts": "Watch favorite shows, netflix, hulu",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[PUTBACK] <remote_control> <couch>",
"[TURNTO] <television>",
"[WATCH] <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:['sheets', 'tea', 'chair', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'plate', 'mousepad', 'couch', 'clothes_hat', 'wall', 'nightstand', 'cup', 'food_food', 'check', 'coffe_maker', 'after_shave', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'hairdryer', 'table']
Task:Read book
response:
{
"thoughts": go to living room,find the text book on the self ,sat on the chair ,open and read the book,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}
|
Scene_Objects:['scissors', 'microwave', 'freezer', 'character', 'bedroom', 'computer', 'stovefan', 'mat', 'plate', 'homework', 'closetdrawer', 'clothes_hat', 'dining_room', 'powersocket', 'basket_for_clothes', 'cup', 'bed', 'keys', 'coffe_maker', 'check', 'television', 'towel_rack', 'dishrack', 'dresser', 'napkin', 'home_office', 'light', 'table', 'instrument_violin', 'shoe_rack']
Task:Dust
response:
| {
"thoughts": "Get a broom or duster with long handle. Dust blades of ceiling fan.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <duster>",
"[FIND] <duster>",
"[GRAB] <duster>",
"[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:['blow_dryer', 'trashcan', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookmark', 'toaster', 'stovefan', 'tvstand', 'food_jam', 'pillow', 'dining_room', 'bowl', 'wall', 'powersocket', 'clothes_gloves', 'novel', 'coffe_maker', 'coffee_filter', 'tray', 'after_shave', 'curtain', 'cd', 'chessboard', 'cupboard', 'sink', 'dishwasher', 'scrabble', 'coffee']
Task:Make coffee
response:
{
"thoughts": Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on.,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[WALK] <coffee>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door']
Task:Watch youtube
response:
| {
"thoughts": "Go to youtube.Com watch videos",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <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:['food_bread', 'drawing', 'orchid', 'knifeblock', 'bills', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'shower', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'television', 'food_rice', 'tray', 'curtain', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'home_office', 'table', 'light', 'bathroom_cabinet']
Task:Relax on sofa
response:
{
"thoughts": Walk into the living room. Walk up to the sofa. Sit down on the sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['tablelamp', 'measuring_cup', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'floor_lamp', 'mousepad', 'wall', 'nightstand', 'novel', 'video_game_controller', 'television', 'mouse', 'door', 'napkin']
Task:Study
response:
| {
"thoughts": "Study norwegian",
"actions": [
"[WALK] <home_office>",
"[WALK] <floor_lamp>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[FIND] <chair>",
"[SIT] <chair>",
"[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', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'bedroom', 'keyboard', 'piano_bench', 'bookmark', 'laptop', 'electric_shaver', 'food_kiwi', 'wall', 'powersocket', 'toothbrush_holder', 'curtain', 'rag', 'doorjamb', 'shaving_cream', 'cards', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'light', 'coffee']
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:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Surf web for money legitimate making opportunities
response:
| {
"thoughts": "Sit down in front of computer. Turn computer on. Go online. Surf the web.",
"actions": [
"[WALK] <home_office>",
"[WALK] <desk>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <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:['dry_pasta', 'pot', 'filing_cabinet', 'tablelamp', 'blender', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'mat', 'balanceball', 'clothes_socks', 'dustpan', 'wall', 'powersocket', 'food_cheese', 'after_shave', 'doorjamb', 'towel_rack', 'dresser', 'door', 'bathroom_cabinet', 'light', 'home_office']
Task:Turn on light
response:
{
"thoughts": Hit light switch,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'toilet', 'dog', 'freezer', 'bathroom', 'orchid', 'bathroom_counter', 'phone', 'character', 'tea_bag', 'bookshelf', 'keyboard', 'stovefan', 'mat', 'plate', 'mousepad', 'oil', 'wall', 'newspaper', 'novel', 'food_food', 'television', 'rag', 'lighter', 'pencil', 'shoes', 'sink', 'home_office']
Task:Open window
response:
| {
"thoughts": "Unlock the latch at the top. Push the bottom half of the window upwards.",
"actions": [
"[WALK] <home_office>",
"[WALK] <window>",
"[OPEN] <window>"
]
} |
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:['measuring_cup', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'ceilinglamp', 'faucet', 'teeth', 'towel', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'light_bulb', 'toilet_paper', 'television', 'food_donut', 'tray', 'cards', 'towel_rack', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'soap', '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>']
}
|
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Work
response:
| {
"thoughts": "I have my desktop computer set up on my desk and complete the paperwork I brought home with me from work.",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <check>",
"[GRAB] <check>",
"[READ] <check>",
"[FIND] <desk>",
"[OPEN] <desk>",
"[PUTBACK] <check> <desk>",
"[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:['fork', 'crayon', 'dog', 'toothbrush', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'faucet', 'shower', 'balanceball', 'mousepad', 'wall', 'pasta', 'powersocket', 'oven', 'nightstand', 'photoframe', 'video_game_controller', 'coffee_filter', 'wooden_spoon', 'console', 'shoes', '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>']
}
|
Scene_Objects:['blender', 'tea', 'microwave', 'orchid', 'bathroom_counter', 'character', 'desk', 'mat', 'shower', 'closetdrawer', 'couch', 'clothes_pants', 'food_orange', 'tape', 'cup', 'basket_for_clothes', 'bed', 'food_food', 'coin', 'wooden_spoon', 'towel_rack', 'shoes', 'dishrack', 'hairbrush', 'controller', 'door', 'sink', 'table', 'board_game', 'shoe_rack']
Task:Walk through
response:
| {
"thoughts": "Walk through the hallway.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dining_room>",
"[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:['microwave', 'toilet', 'ground_coffee', 'bathroom', 'trashcan', 'food_butter', 'knifeblock', 'needle', 'floor', 'ceiling', 'character', 'clothes_jacket', 'toaster', 'ceilinglamp', 'balanceball', 'mousepad', 'broom', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'rag', 'coffee_pot', 'laundry_detergent', 'maindoor', 'napkin', 'table', 'dishwasher']
Task:Make coffee
response:
{
"thoughts": Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. 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>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['tablelamp', 'juice', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'food_cake', 'envelope', 'computer', 'mop_bucket', 'laptop', 'mat', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'television', 'doorjamb', 'mouse', 'controller', 'door']
Task:Surf internet
response:
| {
"thoughts": "SIT ON COUCH OR CHAIR AND SURF SHOPPING AN SOCIAL MEDIA SITES",
"actions": [
"[WALK] <home_office>",
"[WALK] <laptop>",
"[FIND] <laptop>",
"[GRAB] <laptop>",
"[FIND] <couch>",
"[SIT] <couch>",
"[SWITCHON] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <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:['fork', 'filing_cabinet', 'beer', 'tea', 'freezer', 'shampoo', 'character', 'desk', 'piano_bench', 'ceilinglamp', 'iron', 'picture', 'mousepad', 'couch', 'bowl', 'nightstand', 'wall_clock', 'toy', 'bed', 'coffe_maker', 'television', 'coin', 'after_shave', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'shoes', 'bathroom_cabinet']
Task:Change TV channel
response:
{
"thoughts": take remote control, push "change channel" button,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']
}
|
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light', 'creditcard']
Task:Shop
response:
| {
"thoughts": "find computer, find shopping website, pick items, get credit card, make a purchase",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[FIND] <creditcard>",
"[GRAB] <creditcard>",
"[TURNTO] <creditcard>",
"[LOOKAT] <creditcard>",
"[FIND] <desk>",
"[OPEN] <desk>",
"[PUTBACK] <creditcard> <desk>",
"[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:['crayon', 'toilet', 'chair', 'bathroom', 'detergent', 'dough', 'knife', 'drawing', 'floor', 'ceiling', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'mousepad', 'clothes_socks', 'pillow', 'wall', 'cup', 'doorjamb', 'console', 'shoes', 'dresser', 'door', 'hairdryer', 'napkin', 'light', 'soap', 'laser_pointer']
Task:Turn on light
response:
{
"thoughts": Walk over to light switch. Turn on lights.,
"actions": ['[WALK] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['chair', 'walllamp', 'nail_polish', 'cat', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'tray', 'doorjamb', 'dresser', 'cupboard', 'controller', 'door', 'sink', 'bathroom_cabinet', 'tooth_paste', 'creditcard']
Task:Watch TV
response:
| {
"thoughts": "I sit on the couch and watch TV.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <couch>",
"[SIT] <couch>",
"[WATCH] <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:['pot', 'ground_coffee', 'walllamp', 'detergent', 'knifeblock', 'longboard', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'faucet', 'candle', 'wall', 'box', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'hair', 'maindoor', 'sink', 'napkin', 'dishwasher', 'tooth_paste']
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>']
}
|
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink']
Task:Use computer
response:
| {
"thoughts": "Browse the internet",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <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:['scissors', 'mop', 'ground_coffee', 'ceilingfan', 'trashcan', 'toothbrush', 'drawing', 'needle', 'bookshelf', 'keyboard', 'laptop', 'balanceball', 'stereo', 'mousepad', 'wall_clock', 'bench', 'coffe_maker', 'food_food', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'kettle', 'controller', 'napkin', 'home_office', 'light', 'vase', 'soap', 'tooth_paste']
Task:Brush teeth
response:
{
"thoughts": walk to bathroom, look at the toothbrush holder, take toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now brush teeth,
"actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[TURNTO] <toothbrush>', '[LOOKAT] <toothbrush>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>']
}
|
Scene_Objects:['food_pizza', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'ceiling', 'phone', 'thread', 'computer', 'stovefan', 'faucet', 'shower', 'food_jam', 'dining_room', 'wall', 'powersocket', 'tape', 'coffe_maker', 'food_food', 'mirror', 'doorjamb', 'mouse', 'paper_towel', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'home_office', 'dirt']
Task:Clean mirror
response:
| {
"thoughts": "Spray Windex or glass and mirror cleaner onto mirror. Use paper towel to wipe off cleaner until mirror is dry and has no streaks.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <bathroom_cabinet>",
"[FIND] <bathroom_cabinet>",
"[OPEN] <bathroom_cabinet>",
"[FIND] <paper_towel>",
"[GRAB] <paper_towel>",
"[CLOSE] <bathroom_cabinet>",
"[WALK] <mirror>",
"[WIPE] <mirror>",
"[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:['tablelamp', 'toilet', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:
{
"thoughts": Find home office. Walk to home office. Find computer. Find chair at desk. Sit in chair. Switch on computer. Work on computer.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['tablelamp', 'chair', 'ground_coffee', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'bookmark', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'cup', 'bed', 'television', 'coffee_filter', 'mouse', 'door']
Task:Answer emails
response:
| {
"thoughts": "Open email application. Open new emails. Respond accordingly",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <laptop>",
"[SWITCHON] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[FIND] <mail>",
"[GRAB] <mail>",
"[READ] <mail>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[SWITCHOFF] <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:['freezer', 'bathroom', 'detergent', 'cat', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'form', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'coffee_filter', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'controller', 'door', 'light', 'coffee']
Task:Put groceries in Fridge
response:
{
"thoughts": I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing 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:['filing_cabinet', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'candle', 'pillow', 'wall', 'photoframe', 'bed', 'television', 'food_rice', 'doorjamb', 'centerpiece', 'dresser', 'napkin', 'light', 'coffee']
Task:Watch TV
response:
| {
"thoughts": "I sit on the couch and watch TV.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <couch>",
"[SIT] <couch>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[WATCH] <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:['freezer', 'bathroom', 'detergent', 'orchid', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'purse', 'computer', 'table_cloth', 'bookmark', 'stovefan', 'stereo', 'oil', 'closetdrawer', 'coffe_maker', 'television', 'food_donut', 'food_rice', 'tray', 'centerpiece', 'doorjamb', 'pencil', 'maindoor', 'sink', 'home_office', 'table', 'clothes_skirt']
Task:Read book
response:
{
"thoughts": Walk to living room. Find book. Grab book. Open book. Read book.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['sheets', 'food_bread', 'juice', 'food_salt', 'toilet', 'walllamp', 'detergent', 'dough', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'character', 'tea_bag', 'toaster', 'mat', 'broom', 'powersocket', 'love_seat', 'newspaper', 'photoframe', 'keys', 'food_food', 'coffe_maker', 'toilet_paper', 'ice', 'tray', 'lighter', 'kettle', 'home_office', 'dirt']
Task:Read
response:
| {
"thoughts": "Reading a magazine",
"actions": [
"[WALK] <home_office>",
"[WALK] <newspaper>",
"[FIND] <newspaper>",
"[GRAB] <newspaper>",
"[FIND] <love_seat>",
"[SIT] <love_seat>",
"[READ] <newspaper>"
]
} |
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', 'purse', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'electric_shaver', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:
{
"thoughts": Walk to home office. Sit on chair. Switch on computer. type in keyboard.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'light']
Task:Compute
response:
| {
"thoughts": "Use computer.",
"actions": [
"[WALK] <home_office>",
"[WALK] <desk>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <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:['tablelamp', 'scissors', 'drawing', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'shower', 'electric_shaver', 'food_kiwi', 'wall', 'bench', 'food_cheese', 'photoframe', 'newspaper', 'bed', 'food_food', 'standingmirror', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'door', 'soap', 'clothes_shirt', 'scrabble', 'coffee']
Task:Change TV channel
response:
{
"thoughts": Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control,
"actions": ['[WALK] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[PUTOBJBACK] <remote_control>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'thread', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'wall_clock', 'basket_for_clothes', 'photoframe', 'television', 'food_onion', 'doorjamb', 'dresser', 'door', 'clothes_scarf']
Task:Watch TV
response:
| {
"thoughts": "Watch your favorite TV shows.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[WATCH] <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:['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:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'bathroom_cabinet']
Task:Use computer
response:
| {
"thoughts": "Browse the internet",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[TURNTO] <computer>",
"[POINTAT] <computer>",
"[PUTOBJBACK] <mouse>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[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:['sheets', 'freezer', 'bathroom', 'ceilingfan', 'drawing', 'bills', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'toy', 'tape', 'bed', 'television', 'curtain', 'comb', 'hair', 'home_office', 'table', 'soap']
Task:Watch TV
response:
{
"thoughts": Go to the living room and sit on the couch. Turn on television using remote control. Use remote control buttons to navigate to desired channel. Watch television.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'hanger', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'computer', 'toaster', 'mat', 'plate', 'faucet', 'brush', 'oil', 'candle', 'broom', 'wall', 'tape', 'bed', 'coffe_maker', 'ice', 'rag', 'console', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'colander']
Task:Clean sink
response:
| {
"thoughts": "Squirt soap into the sink. Get a wet rag. Wipe out the sink. Rinse out the sink and the rag. Hang the rag out to dry.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[WALK] <sink>",
"[POUR] <cleaning_solution> <sink>",
"[PUTOBJBACK] <cleaning_solution>",
"[WIPE] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <sink>",
"[RINSE] <rag>",
"[SWITCHOFF] <faucet>",
"[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:['fork', 'dry_pasta', 'food_salt', 'chair', 'drawing', 'bills', 'hanger', 'floor', 'phone', 'ceiling', 'toaster', 'plate', 'wall', 'bench', 'powersocket', 'tape', 'cup', 'bed', 'check', 'food_food', 'tray', 'doorjamb', 'pencil', 'dishrack', 'dresser', 'cupboard', 'door', 'table', 'light', 'laser_pointer']
Task:Eat
response:
{
"thoughts": Serve food on dinning table in appropriate utensils, sit on the chair, eat,
"actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <plate>', '[PUTBACK] <food_food> <plate>', '[GRAB] <food_food>', '[PUTOBJBACK] <food_food>', '[FIND] <fork>', '[GRAB] <fork>', '[EAT] <plate>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'detergent', 'drawing', 'floor', 'phone', 'bedroom', 'keyboard', 'mat', 'tvstand', 'stereo', 'clothes_socks', 'candle', 'towel', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bed', 'check', 'food_food', 'razor', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'door', 'sink', 'light']
Task:Listen to music
response:
| {
"thoughts": "Turn on radio, put on favorite channel, listen to music.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <stereo>",
"[FIND] <bed>",
"[LIE] <bed>"
]
} |
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', 'tea', 'bathroom', 'ceilingfan', 'milk', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'shoe-shine_kit', 'couch', 'food_jam', 'microphone', 'wall', 'nightstand', 'oven', 'cutting_board', 'television', 'curtain', 'pencil', 'table']
Task:Watch TV
response:
{
"thoughts": We sit all around the television and watch a program.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[WATCH] <television>']
}
|
Scene_Objects:['fork', 'chair', 'walllamp', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'candle', 'pillow', 'wall', 'cup', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'bathroom_cabinet', 'teeth']
Task:Watch TV
response:
| {
"thoughts": "SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[PUTBACK] <remote_control> <couch>",
"[TURNTO] <television>",
"[WATCH] <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:['spectacles', 'pot', 'scissors', 'microwave', 'jelly', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'shampoo', 'ceiling', 'keyboard', 'mail', 'brush', 'toaster', 'stovefan', 'plate', 'picture', 'oil', 'form', 'bowl', 'photoframe', 'newspaper', 'bed', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'home_office']
Task:Read book
response:
{
"thoughts": Walk to living room. Find book. Grab book. Open book. Read book.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['tablelamp', 'microwave', 'chair', 'dog', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'laptop', 'mat', 'mousepad', 'wall', 'oven', 'love_seat', 'bed', 'coffe_maker', 'food_food', 'doorjamb', 'centerpiece', 'coffee_pot', 'mouse', 'pencil', 'hairbrush', 'controller', 'door', 'dishwasher', 'electrical_outlet']
Task:Write book
response:
| {
"thoughts": "Writing a book",
"actions": [
"[WALK] <home_office>",
"[WALK] <laptop>",
"[FIND] <laptop>",
"[GRAB] <laptop>",
"[FIND] <electrical_outlet>",
"[PLUGIN] <laptop>",
"[WALK] <love_seat>",
"[SIT] <love_seat>",
"[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:['microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'computer', 'mail', 'table_cloth', 'mat', 'tvstand', 'plate', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'photoframe', 'check', 'television', 'curtain', 'after_shave', 'doorjamb', 'cards', 'mouse', 'shoes', 'sink']
Task:Relax on sofa
response:
{
"thoughts": I walk to the living room. I sit in the sofa and I relax.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['glue', 'pot', 'spectacles', 'food_ice_cream', 'crayon', 'microwave', 'toilet', 'band-aids', 'bathroom', 'needle', 'bathroom_counter', 'man', 'alcohol', 'mat', 'plate', 'stereo', 'faucet', 'mousepad', 'couch', 'pillow', 'dining_room', 'light_bulb', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'home_office', 'table', 'board_game']
Task:Greet guests
response:
| {
"thoughts": "When someone knocks I n the door walk through the hallway and greet them.",
"actions": [
"[RUN] <home_office>",
"[WALK] <man>",
"[FIND] <man>",
"[GREET] <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:['filing_cabinet', 'juice', 'food_salt', 'microwave', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'keyboard', 'food_cake', 'purse', 'shoe-shine_kit', 'faucet', 'wall', 'nightstand', 'powersocket', 'photoframe', 'check', 'coffe_maker', 'doorjamb', 'hair', 'sink', 'bathroom_cabinet', 'table']
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', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'toaster', 'closetdrawer', 'couch', 'food_jam', 'pillow', 'wall', 'cup', 'photoframe', 'coffee_table', 'novel', 'television', 'doorjamb', 'shoes', 'comb', 'dresser', 'instrument_violin']
Task:Watch TV
response:
| {
"thoughts": "I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <coffee_table>",
"[PUTBACK] <remote_control> <coffee_table>",
"[TURNTO] <television>",
"[WATCH] <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:['sheets', 'filing_cabinet', 'chair', 'ground_coffee', 'bathroom', 'detergent', 'bathroom_counter', 'bedroom', 'bookshelf', 'button', 'toaster', 'mat', 'ceilinglamp', 'window', 'mousepad', 'couch', 'dining_room', 'photoframe', 'bed', 'novel', 'coffe_maker', 'food_food', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'sink', 'dishwasher', 'clothes_skirt', 'soap']
Task:Pick up phone
response:
{
"thoughts": walk to living room , find phone ,pick up phone 3,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>']
}
|
Scene_Objects:['sponge', 'chair', 'detergent', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'toaster', 'mat', 'plate', 'faucet', 'ceilinglamp', 'dish_soap', 'wall', 'food_cheese', 'light_bulb', 'novel', 'coffe_maker', 'food_food', 'television', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'shoes', 'dishrack', 'dresser', 'cupboard', 'sink', 'home_office']
Task:Wash dishes
response:
| {
"thoughts": "Put all dirty dishes on one side. Take sponge and cover it in soap. Soap each dish. Rinse each dish with water. Put on drying rack.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <sponge>",
"[GRAB] <sponge>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[POUR] <dish_soap> <sponge>",
"[PUTOBJBACK] <dish_soap>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[SCRUB] <plate>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <plate>",
"[FIND] <dishrack>",
"[PUTBACK] <plate> <dishrack>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[SCRUB] <plate>",
"[RINSE] <plate>",
"[PUTBACK] <plate> <dishrack>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[SCRUB] <plate>",
"[RINSE] <plate>",
"[PUTBACK] <plate> <dishrack>",
"[RINSE] <sponge>",
"[SQUEEZE] <sponge>",
"[SWITCHOFF] <faucet>",
"[PUTOBJBACK] <sponge>"
]
} |
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', 'crayon', 'chair', 'cat', 'dough', 'milk', 'hanger', 'floor', 'keyboard', 'mail', 'table_cloth', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'couch', 'form', 'dining_room', 'cutting_board', 'photoframe', 'check', 'wine', 'dresser', 'hairbrush', 'pajamas', 'conditioner', 'home_office', 'bathroom_cabinet', 'table']
Task:Give milk to cat
response:
{
"thoughts": Grab milk and pour it into the plate so that the cat can drink,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[POINTAT] <cat>', '[PULL] <cat>', '[FIND] <milk>', '[GRAB] <milk>', '[FIND] <plate>', '[POUR] <milk> <plate>', '[TOUCH] <cat>', '[SCRUB] <cat>']
}
|
Scene_Objects:['pot', 'microwave', 'chair', 'drawing', 'floor', 'ceiling', 'bedroom', 'alcohol', 'toaster', 'stovefan', 'mat', 'shower', 'faucet', 'deck_of_cards', 'shoe-shine_kit', 'pillow', 'wall', 'oven', 'cup', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'table', 'dishwasher']
Task:Drink
response:
| {
"thoughts": "Turn on the faucet. Place glass under tap and fill with water. Turn off faucet. Drink water.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[CLOSE] <cupboard>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[PUTBACK] <cup> <sink>",
"[GRAB] <cup>",
"[SWITCHOFF] <faucet>",
"[DRINK] <cup>"
]
} |
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', 'toilet', 'chair', 'walllamp', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'plate', 'mousepad', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'wine', 'curtain', 'doorjamb', 'light']
Task:Watch TV
response:
{
"thoughts": Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['pot', 'food_bread', 'chair', 'freezer', 'drawing', 'orchid', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'ceilinglamp', 'plate', 'mat', 'stereo', 'shower', 'couch', 'pillow', 'food_kiwi', 'wall', 'pasta', 'bed', 'novel', 'food_food', 'check', 'television', 'console', 'pencil', 'kitchen_counter', 'cupboard', 'table']
Task:Cut bread
response:
| {
"thoughts": "I get a slice of bread, grab a knife, and then cut the piece of bread in half.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <knife>",
"[GRAB] <knife>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[CLOSE] <kitchen_cabinet>",
"[FIND] <table>",
"[PUTBACK] <plate> <table>",
"[PUTBACK] <knife> <table>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_bread>",
"[GRAB] <food_bread>",
"[CLOSE] <freezer>",
"[PUTBACK] <food_bread> <plate>",
"[GRAB] <knife>",
"[CUT] <food_bread>",
"[PUTOBJBACK] <knife>"
]
} |
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', 'nail_polish', 'trashcan', 'drawing', 'orchid', 'floor', 'desk', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'bench', 'coffe_maker', 'television', 'curtain', 'mouse', 'bathtub', 'home_office', 'table', 'bathroom_cabinet']
Task:Relax on sofa
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] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['pot', 'food_bread', 'juice', 'microwave', 'chair', 'freezer', 'detergent', 'drawing', 'orchid', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'shower', 'mat', 'ceilinglamp', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'cup', 'newspaper', 'coffe_maker', 'television', 'ice', 'wine', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'cupboard', 'table', 'dishwasher', 'creditcard']
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>"
]
} |
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', 'freezer', 'detergent', 'tea_bag', 'food_bacon', 'mop_bucket', 'stereo', 'iron', 'couch', 'pasta', 'powersocket', 'oven', 'wall_clock', 'photoframe', 'coffe_maker', 'mouthwash', 'television', 'food_rice', 'tray', 'after_shave', 'towel_rack', 'kitchen_counter', 'cd', 'dishrack', 'comb', 'dresser', 'clothes_skirt', 'creditcard']
Task:Listen to music
response:
{
"thoughts": I walk to the radio. I switch on the radio and listen,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['mop', 'chair', 'jelly', 'walllamp', 'drawing', 'wallshelf', 'food_egg', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'food_rice', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'coffee']
Task:Watch horror movie
response:
| {
"thoughts": "I would find something scary to watch on dvd",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[WATCH] <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:['sheets', 'tablelamp', 'food_ice_cream', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'bookshelf', 'computer', 'faucet', 'balanceball', 'window', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'nightstand', 'bench', 'powersocket', 'basket_for_clothes', 'novel', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'maindoor', 'sink', 'hairdryer']
Task:Pick up phone
response:
{
"thoughts": Enter the Home office, then walk to the phone, pickup the phone.,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'bed', 'television', 'doorjamb', 'shaving_cream', 'mouse', 'coffee', 'dresser', 'hairbrush', 'clothes_scarf', 'soap', 'teeth']
Task:Watch TV
response:
| {
"thoughts": "Sitting on the couch watching my favorite television show.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[TURNTO] <television>",
"[WATCH] <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:['spectacles', 'filing_cabinet', 'tea', 'microwave', 'dog', 'freezer', 'walllamp', 'drawing', 'orchid', 'hanger', 'keyboard', 'button', 'ceilinglamp', 'stereo', 'homework', 'mousepad', 'closetdrawer', 'food_peanut_butter', 'food_jam', 'wall', 'oven', 'food_cheese', 'keys', 'tray', 'lighter', 'mouse', 'kitchen_counter', 'cd', 'clothes_dress', 'bathroom_cabinet']
Task:Pet cat
response:
{
"thoughts": Petting the cat,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['pot', 'microwave', 'freezer', 'dough', 'milk', 'drawing', 'floor', 'ceiling', 'keyboard', 'food_bacon', 'toaster', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'bowl', 'wall', 'oven', 'cup', 'coffe_maker', 'check', 'television', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'light', 'dishwasher']
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>"
]
} |
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', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'stereo', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'powersocket', 'cup', 'toilet_paper', 'television', 'after_shave', 'rag', 'doorjamb', 'coffee_pot', 'dishrack', 'instrument_guitar', 'table', 'soap', 'laser_pointer']
Task:Relax on sofa
response:
{
"thoughts": walk to living room, walk to sofa, sit in sofa,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['glue', 'filing_cabinet', 'blow_dryer', 'walllamp', 'knife', 'orchid', 'cpuscreen', 'floor', 'computer', 'button', 'ceilinglamp', 'oil', 'mousepad', 'cup', 'bed', 'keys', 'novel', 'check', 'coffe_maker', 'toothbrush_holder', 'coffee_filter', 'food_food', 'curtain', 'pencil', 'shoes', 'controller', 'hairdryer', 'bathroom_cabinet', 'table', 'board_game']
Task:Get ready to leave
response:
| {
"thoughts": "Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave",
"actions": [
"[WALK] <home_office>",
"[WALK] <shoes>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PUTON] <shoes>",
"[FIND] <keys>",
"[GRAB] <keys>"
]
} |
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', 'trashcan', 'dough', 'orchid', 'knife', 'clothes_underwear', 'phone', 'tea_bag', 'envelope', 'mat', 'faucet', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bench', 'powersocket', 'basket_for_clothes', 'food_food', 'food_rice', 'tray', 'curtain', 'after_shave', 'doorjamb', 'pencil', 'laundry_detergent', 'bathroom_cabinet', 'table', 'light', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on.,
"actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'character', 'tea_bag', 'computer', 'table_cloth', 'toaster', 'mat', 'tvstand', 'stovefan', 'electric_shaver', 'couch', 'pillow', 'wall', 'basket_for_clothes', 'newspaper', 'coffee_table', 'photoframe', 'video_game_controller', 'television', 'doorjamb', 'dresser', 'cupboard', 'dishwasher']
Task:Read magazine
response:
| {
"thoughts": "Get magazine off coffee table. Sit in arm chair. Open magazine to first page. Read until finished.",
"actions": [
"[WALK] <home_office>",
"[WALK] <coffee_table>",
"[FIND] <newspaper>",
"[GRAB] <newspaper>",
"[FIND] <couch>",
"[SIT] <couch>",
"[READ] <newspaper>",
"[PUTBACK] <newspaper> <coffee_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', 'chair', 'band-aids', 'walllamp', 'detergent', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'video_game_console', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'plate', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'photoframe', 'video_game_controller', 'television', 'curtain', 'dresser', 'table', 'dishwasher']
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:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'laptop', 'mat', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'cup', 'photoframe', 'television', 'doorjamb', 'mouse', 'door', 'creditcard']
Task:Play on laptop
response:
| {
"thoughts": "Sit down on the couch. Place laptop on lap. Open laptop. Turn on laptop. Choose selected program. Play selected program. Close game. Close laptop.",
"actions": [
"[WALK] <home_office>",
"[WALK] <laptop>",
"[FIND] <laptop>",
"[GRAB] <laptop>",
"[FIND] <couch>",
"[SIT] <couch>",
"[SWITCHON] <laptop>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[SWITCHOFF] <laptop>",
"[PUTOBJBACK] <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:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'character', 'desk', 'bedroom', 'keyboard', 'thread', 'toaster', 'plate', 'couch', 'wall', 'light_bulb', 'novel', 'coffe_maker', 'food_rice', 'tray', 'food_onion', 'after_shave', 'curtain', 'kettle', 'kitchen_counter', 'shoes', 'cupboard', 'conditioner', 'door', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office']
Task:Check email
response:
| {
"thoughts": "Turn on the computer. Wait for it to load. Get online. Go to the email service. Open the email. Read the email.",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[FIND] <mail>",
"[GRAB] <mail>",
"[READ] <mail>"
]
} |
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', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'home_office', 'table', 'light']
Task:Read book
response:
{
"thoughts": Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>']
}
|
Scene_Objects:['spectacles', 'juice', 'nail_polish', 'wallshelf', 'floor', 'ceiling', 'face', 'mat', 'iron', 'shower', 'stereo', 'clothes_socks', 'food_jam', 'wall_clock', 'light_bulb', 'food_food', 'razor', 'mirror', 'food_rice', 'curtain', 'centerpiece', 'towel_rack', 'hair', 'clothes_dress', 'napkin', 'bathroom_cabinet', 'home_office', 'table', 'soap', 'shoe_rack']
Task:Check appearance in mirror
response:
| {
"thoughts": "Walk to full-length mirror. Look in mirror. Make sure everything about your appearance is adequate. Adjust clothes as needed.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <mirror>",
"[FIND] <mirror>",
"[TURNTO] <mirror>",
"[LOOKAT] <mirror>",
"[FIND] <face>",
"[TURNTO] <face>",
"[LOOKAT] <face>",
"[FIND] <hair>",
"[TURNTO] <hair>",
"[LOOKAT] <hair>",
"[FIND] <clothes_dress>",
"[TURNTO] <clothes_dress>",
"[LOOKAT] <clothes_dress>"
]
} |
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', 'microwave', 'cpuscreen', 'hanger', 'floor', 'bookshelf', 'bookmark', 'stovefan', 'mat', 'faucet', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'cutting_board', 'cup', 'newspaper', 'novel', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'hair', 'clothes_dress', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'table']
Task:Relax on sofa
response:
{
"thoughts": Go to the living room and relax on the sofa with a book,
"actions": ['[RUN] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[DROP] <bookmark>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['wallshelf', 'phone', 'dvd_player', 'character', 'computer', 'ceilinglamp', 'foundation', 'mousepad', 'bowl', 'wall', 'cutting_board', 'box', 'cup', 'food_cheese', 'bed', 'photoframe', 'coffe_maker', 'food_food', 'doorjamb', 'centerpiece', 'mouse', 'shoes', 'comb', 'dresser', 'conditioner', 'clothes_dress', 'hairdryer', 'spoon', 'bathroom_cabinet', 'light']
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:['dry_pasta', 'microwave', 'freezer', 'walllamp', 'detergent', 'dough', 'floor', 'phone', 'ceiling', 'tea_bag', 'bookshelf', 'keyboard', 'toaster', 'laptop', 'tvstand', 'faucet', 'mousepad', 'dining_room', 'wall', 'box', 'cup', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'dishwasher']
Task:Make popcorn
response:
{
"thoughts": Lay popcorn bag flat inside microwave and press popcorn button to start.,
"actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <microwave>', '[TURNTO] <microwave>', '[OPEN] <microwave>', '[PUTIN] <food_food> <microwave>', '[CLOSE] <microwave>', '[SWITCHON] <microwave>']
}
|
Scene_Objects:['sheets', 'pot', 'food_pizza', 'jelly', 'freezer', 'bathroom', 'detergent', 'food_butter', 'food_carrot', 'cpuscreen', 'bedroom', 'stovefan', 'ceilinglamp', 'toaster', 'faucet', 'mousepad', 'food_noodles', 'food_orange', 'nightstand', 'cup', 'check', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'napkin', 'spoon', 'table', 'home_office', 'soap']
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:['toilet', 'cat', 'floor', 'character', 'stamp', 'table_cloth', 'piano_bench', 'mat', 'window', 'couch', 'food_jam', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'cup', 'mouthwash', 'television', 'coffee_filter', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'food_steak', 'bathtub', 'bag', 'table']
Task:Pet cat
response:
{
"thoughts": I see my cat on the couch so I walk over, sit down and pet the cat.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'chair', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'food_food', 'television', 'doorjamb', 'mouse', 'pencil', 'dresser', 'door', 'shoe_rack']
Task:Put in chair
response:
| {
"thoughts": "Take a comfortable chair. Place it in the entrance hall",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[GRAB] <chair>",
"[WALK] <home_office>",
"[WALK] <floor>",
"[FIND] <floor>",
"[PUTBACK] <chair> <floor>"
]
} |
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', 'toilet', 'ground_coffee', 'walllamp', 'trashcan', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'toaster', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'photoframe', 'clothes_gloves', 'coffe_maker', 'coffee_filter', 'centerpiece', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'clothes_scarf', 'home_office', 'table', 'dishwasher']
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:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'cup', 'newspaper', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Start computer
response:
| {
"thoughts": "Sit in desk chair, press power button, let computer power on",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <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:['spectacles', 'toilet', 'chair', 'walllamp', 'bathroom', 'orchid', 'floor', 'ceiling', 'bookshelf', 'table_cloth', 'bookmark', 'ceilinglamp', 'mat', 'stereo', 'shower', 'floor_lamp', 'food_noodles', 'clothes_hat', 'dining_room', 'wall', 'television', 'food_donut', 'doorjamb', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'bathroom_cabinet', 'light', 'coffee']
Task:Turn on light
response:
{
"thoughts": walk to wall, find light switch, turn on lights,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[WALK] <bedroom>', '[WALK] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['food_bread', 'freezer', 'walllamp', 'drawing', 'needle', 'floor', 'ceiling', 'bookshelf', 'toaster', 'mat', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'food_kiwi', 'wall', 'cup', 'coffe_maker', 'television', 'food_donut', 'wine', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'food_steak', 'sink', 'dishwasher', '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:['tablelamp', 'chair', 'jelly', 'bathroom', 'knife', 'dvd_player', 'character', 'bedroom', 'thread', 'computer', 'toaster', 'shoe-shine_kit', 'deck_of_cards', 'shower', 'electric_shaver', 'homework', 'food_peanut_butter', 'form', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'novel', 'light_bulb', 'food_food', 'curtain', 'coffee_pot', 'food_steak', 'door', 'light']
Task:Listen to music
response:
{
"thoughts": Go to the living room. Find the radio. Turn on the radio.,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['scissors', 'chair', 'food_butter', 'drawing', 'orchid', 'bills', 'wallshelf', 'cpuscreen', 'floor', 'shampoo', 'character', 'thread', 'alcohol', 'piano_bench', 'brush', 'ceilinglamp', 'mat', 'iron', 'dining_room', 'wall', 'wall_clock', 'pasta', 'newspaper', 'food_food', 'television', 'console', 'kitchen_counter', 'pajamas', 'table', 'shoe_rack']
Task:Put down bags
response:
| {
"thoughts": "When walking into the house, putting down the things i am carrying",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[FIND] <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:['walllamp', 'trashcan', 'toothbrush', 'drawing', 'orchid', 'needle', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'remote_control', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'wall', 'powersocket', 'television', 'food_rice', 'doorjamb', 'pencil', 'chessboard', 'door', 'hairdryer', 'bathroom_cabinet', 'table', 'scrabble']
Task:Change TV channel
response:
{
"thoughts": I go to the livingroom. The TV is on. I pick up the remote and press the next channel button. I look at the television, and see that the channel has changed.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[LOOKAT] <television>']
}
|
Scene_Objects:['pot', 'tablelamp', 'beer', 'detergent', 'food_butter', 'orchid', 'hanger', 'floor', 'ceiling', 'computer', 'toaster', 'mat', 'closetdrawer', 'broom', 'wall', 'nightstand', 'toy', 'newspaper', 'toilet_paper', 'television', 'wine', 'doorjamb', 'kitchen_counter', 'shoes', 'chessboard', 'dresser', 'door', 'dishwasher', 'instrument_violin', 'laser_pointer']
Task:Put away shoes
response:
| {
"thoughts": "Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door.",
"actions": [
"[WALK] <home_office>",
"[WALK] <shoes>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[FIND] <dresser>",
"[OPEN] <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:['blow_dryer', 'bathroom', 'food_carrot', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stamp', 'bedroom', 'food_cake', 'computer', 'shower', 'picture', 'oven', 'basket_for_clothes', 'photoframe', 'food_food', 'check', 'towel_rack', 'mouse', 'pencil', 'shoes', 'comb', 'hairbrush', 'cupboard', 'laundry_detergent', 'sink', 'napkin', 'light', 'washing_machine']
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:['chair', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'food_food', 'television', 'doorjamb', 'mouse', 'cupboard', 'conditioner', 'door', 'bathroom_cabinet', 'light', 'table']
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:['tablelamp', 'beer', 'toilet', 'dough', 'toothbrush', 'drawing', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'stereo', 'shower', 'window', 'oil', 'couch', 'bowl', 'wall', 'oven', 'toy', 'cup', 'bed', 'food_food', 'television', 'wooden_spoon', 'towel_rack', 'comb', 'cupboard', 'table', 'dishwasher']
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>']
}
|
Scene_Objects:['dry_pasta', 'freezer', 'walllamp', 'bathroom', 'dough', 'knife', 'orchid', 'thread', 'computer', 'ceilinglamp', 'deck_of_cards', 'shower', 'clothes_socks', 'food_noodles', 'dustpan', 'nightstand', 'photoframe', 'light_bulb', 'television', 'coffee_filter', 'mirror', 'curtain', 'doorjamb', 'laundry_detergent', 'sink', 'bag', 'table', 'soap', 'clothes_shirt', 'creditcard']
Task:Look at mirror
response:
| {
"thoughts": "I look at my reflection to check my cleanliness.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <mirror>",
"[FIND] <mirror>",
"[TURNTO] <mirror>",
"[LOOKAT] <mirror>"
]
} |
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:['jelly', 'bathroom', 'trashcan', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall_clock', 'newspaper', 'coffe_maker', 'television', 'curtain', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathtub', 'sink', 'clothes_scarf', 'light']
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:['glue', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'mat', 'mousepad', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'food_food', 'coffe_maker', 'doorjamb', 'pencil', 'kitchen_counter', 'cd', 'shoes', 'hair', 'clothes_dress', '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:['fork', 'pot', 'toilet', 'chair', 'freezer', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'keyboard', 'mat', 'ceilinglamp', 'shower', 'oil', 'food_peanut_butter', 'food_orange', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'food_onion', 'doorjamb', 'pencil', 'dresser', 'door', 'napkin', 'light', 'shoe_rack']
Task:Put groceries in Fridge
response:
{
"thoughts": put away groceries in fridge. open the door, put on shelf, close the door.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}
|
Scene_Objects:['tablelamp', 'food_ice_cream', 'drawing', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'mat', 'closetdrawer', 'couch', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'basket_for_clothes', 'photoframe', 'mouthwash', 'doorjamb', 'kitchen_counter', 'shoes', 'dresser', 'door', 'sink', 'light', 'clothes_shirt', 'teeth', 'creditcard']
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:['food_pizza', 'microwave', 'toilet', 'jelly', 'freezer', 'band-aids', 'drawing', 'knifeblock', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'powersocket', 'cup', 'basket_for_clothes', 'photoframe', 'food_food', 'water', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']
Task:Get drink
response:
{
"thoughts": I go to the fridge and open the door. I look for the water pitcher, and take it out, making sure to close the fridge door behind me. Then I take a pint glass out of the upper cabinet over the sink and use the water pitcher to pour a full glass of water. Then I return the pitcher to the fridge and shut the door again, and take my glass of water out of the kitche.,
"actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[OPEN] <freezer>']
}
|
Scene_Objects:['spectacles', 'pot', 'freezer', 'walllamp', 'detergent', 'bills', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'shower', 'faucet', 'closetdrawer', 'microphone', 'dining_room', 'pasta', 'mouthwash', 'mouse', 'pencil', 'dresser', 'pajamas', 'controller', 'sink', 'napkin', 'home_office', 'dishwasher', 'soap']
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:['sheets', 'walllamp', 'drawing', 'cpuscreen', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'alcohol', 'laptop', 'plate', 'faucet', 'homework', 'mousepad', 'dining_room', 'check', 'food_food', 'television', 'tray', 'wooden_spoon', 'mouse', 'shoes', 'conditioner', 'maindoor', 'napkin', 'home_office', 'soap', 'instrument_violin']
Task:Browse internet
response:
{
"thoughts": I turn on computer. I use keyboard to type. I open browser. I search.,
"actions": ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}
|
Scene_Objects:['tablelamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'cleaning_solution', 'bookshelf', 'table_cloth', 'mat', 'ceilinglamp', 'tvstand', 'foundation', 'closetdrawer', 'couch', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'television', 'rag', 'doorjamb', 'dresser', 'door', 'home_office', 'light']
Task:Dust
response:
| {
"thoughts": "Gather wood cleaner and cleaning rag. Wipe baseboards and window sills with dry cloth, then spray with cleaner and buff",
"actions": [
"[WALK] <bedroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[POUR] <cleaning_solution> <rag>",
"[PUTOBJBACK] <cleaning_solution>",
"[WALK] <wall>",
"[WALK] <window>",
"[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:['pot', 'tablelamp', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'homework', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'photoframe', 'check', 'curtain', 'doorjamb', 'mouse', 'light', 'dirt']
Task:Work
response:
{
"thoughts": Find a PC and do homework,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[FIND] <mouse>', '[FIND] <check>', '[FIND] <homework>', '[GRAB] <homework>', '[FIND] <homework>', '[READ] <homework>', '[SWITCHOFF] <computer>']
}
|
Scene_Objects:['glue', 'sponge', 'measuring_cup', 'toilet', 'food_butter', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'character', 'face', 'food_bacon', 'shoe-shine_kit', 'closetdrawer', 'candle', 'food_jam', 'towel', 'pillow', 'nightstand', 'oven', 'cup', 'mouthwash', 'television', 'food_rice', 'after_shave', 'diary', 'headset', 'hair', 'door', 'light']
Task:Rain welcome
response:
| {
"thoughts": "The robot would greet me and then hand me a towel. It would make an appropriate quip about the weather while I dried off. It would receive the wet towel when I was done.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <towel>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[FIND] <face>",
"[WIPE] <face>",
"[FIND] <hair>",
"[WIPE] <hair>",
"[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:['water_glass', 'food_bread', 'chair', 'freezer', 'walllamp', 'detergent', 'trashcan', 'drawing', 'desk', 'keyboard', 'bookshelf', 'bookmark', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'pillow', 'bowl', 'wall', 'box', 'coffe_maker', 'razor', 'television', 'curtain', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathroom_cabinet']
Task:Drink
response:
{
"thoughts": Pour water into a glass and drink from the glass.,
"actions": ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}
|
Scene_Objects:['sheets', 'crayon', 'chair', 'walllamp', 'bathroom', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'clothes_jacket', 'toaster', 'deck_of_cards', 'faucet', 'mousepad', 'microphone', 'wall', 'tape', 'novel', 'food_food', 'check', 'food_donut', 'tray', 'towel_rack', 'dresser', 'pajamas', 'clothes_dress', 'hairdryer', 'bathroom_cabinet', 'home_office', 'table']
Task:Grab things
response:
| {
"thoughts": "The robot will need some kind of hands or grabbing device to transport objects.",
"actions": [
"[WALK] <novel>",
"[TURNTO] <novel>",
"[GRAB] <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', 'scissors', 'toilet', 'band-aids', 'food_carrot', 'dough', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'folder', 'bedroom', 'shoe-shine_kit', 'closetdrawer', 'food_orange', 'nightstand', 'wall', 'powersocket', 'coin', 'shaving_cream', 'pencil', 'cupboard', 'sink', 'napkin', 'instrument_guitar', 'bathroom_cabinet', 'soap', 'scrabble', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine.,
"actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <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:['dry_pasta', 'tablelamp', 'food_salt', 'measuring_cup', 'microwave', 'chair', 'orchid', 'knife', 'food_egg', 'wallshelf', 'desk', 'alcohol', 'computer', 'bookmark', 'shower', 'stereo', 'mousepad', 'dining_room', 'oven', 'powersocket', 'photoframe', 'mouthwash', 'tray', 'curtain', 'mouse', 'vacuum_cleaner', 'pajamas', 'sink', 'dishwasher', 'dirt']
Task:Close door
response:
| {
"thoughts": "Push the door shut until it latches.",
"actions": [
"[RUN] <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_ice_cream', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'iron', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'video_game_controller', 'television', 'doorjamb', 'kettle', 'mouse', 'door', 'table']
Task:Browse internet
response:
{
"thoughts": Walk to home office. Walk to computer. Switch on Computer.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['juice', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'thread', 'computer', 'stovefan', 'mat', 'tvstand', 'toaster', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'television', 'doorjamb', 'laundry_detergent', 'conditioner', 'sink', 'door', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Do homework
response:
| {
"thoughts": "Sit on the couch in the Living room and pick u some papers",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <check>",
"[GRAB] <check>",
"[DROP] <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', 'food_salt', 'microwave', 'toilet', 'dog', 'detergent', 'orchid', 'wallshelf', 'food_egg', 'cpuscreen', 'phone', 'stamp', 'bedroom', 'bookshelf', 'bookmark', 'shower', 'mousepad', 'food_jam', 'towel', 'pasta', 'bed', 'novel', 'food_food', 'curtain', 'centerpiece', 'shaving_cream', 'dresser', 'cupboard', 'table', 'creditcard']
Task:Walk through
response:
{
"thoughts": Walk through the entrance hall,
"actions": ['[WALK] <home_office>', '[WALK] <home_office>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'walllamp', 'food_butter', 'cpuscreen', 'phone', 'folder', 'bedroom', 'computer', 'stovefan', 'tvstand', 'plate', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'check', 'razor', 'television', 'tray', 'curtain', 'diary', 'shaving_cream', 'door', 'soap']
Task:Open curtains
response:
| {
"thoughts": "Gently pull the curtains open, from the middle to the sides.",
"actions": [
"[WALK] <home_office>",
"[WALK] <curtain>",
"[FIND] <curtain>",
"[PULL] <curtain>",
"[FIND] <curtain>",
"[PULL] <curtain>"
]
} |
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_bread', 'freezer', 'cat', 'food_carrot', 'dough', 'orchid', 'needle', 'hanger', 'longboard', 'floor', 'ceiling', 'bathroom_counter', 'ceilinglamp', 'mat', 'stereo', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'light_bulb', 'food_food', 'coffe_maker', 'video_game_controller', 'oven_mitts', 'food_rice', 'vacuum_cleaner', 'dresser', 'door', 'hairdryer']
Task:Put groceries in Fridge
response:
{
"thoughts": I leave the bags with groceries near the fridge, open the door and put the groceries in the shelves.,
"actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>']
}
|
Scene_Objects:['spectacles', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'tape', 'photoframe', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'light']
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:['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:['tablelamp', 'tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'dresser', 'door', 'home_office']
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', 'freezer', 'walllamp', 'bathroom', 'cat', 'trashcan', 'drawing', 'wallshelf', 'floor', 'desk', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'cup', 'food_food', 'television', 'curtain', 'towel_rack', 'mouse', 'sink', 'bathroom_cabinet', 'table', 'scrabble']
Task:Pet cat
response:
{
"thoughts": I walk to the living room. I locate the cat. I walk to the couch and sit down beside the cat. I pet the cat.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']
}
|
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'drawing', 'clothes_underwear', 'hanger', 'bathroom_counter', 'bedroom', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mat', 'mousepad', 'couch', 'pillow', 'dining_room', 'food_food', 'check', 'coffe_maker', 'mirror', 'ice', 'wooden_spoon', 'rag', 'cupboard', 'door', 'sink', 'table']
Task:Clean mirror
response:
| {
"thoughts": "Spray glass cleaner on mirror. Wipe with a clean cloth.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[WALK] <mirror>",
"[PUTOBJBACK] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[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:['pot', 'chair', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'table']
Task:Browse internet
response:
{
"thoughts": I go to my desk. I turn on the computer. I open a web page and look at it.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'chair', 'freezer', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'button', 'mat', 'shoe-shine_kit', 'pillow', 'wall', 'oven', 'tape', 'bed', 'photoframe', 'novel', 'food_food', 'curtain', 'coffee_pot', 'mouse', 'pencil', 'conditioner', 'sink', 'coffee']
Task:Read to child
response:
| {
"thoughts": "Read a book out loud to a child",
"actions": [
"[WALK] <bedroom>",
"[WALK] <child>",
"[FIND] <child>",
"[GREET] <child>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[WALK] <chair>",
"[PULL] <chair>",
"[SIT] <chair>",
"[TURNTO] <novel>",
"[LOOKAT] <novel>",
"[TURNTO] <novel>",
"[POINTAT] <novel>",
"[TURNTO] <novel>",
"[POINTAT] <novel>",
"[READ] <novel>",
"[READ] <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:['food_salt', 'chair', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'phone', 'remote_control', 'food_bacon', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'powersocket', 'oven', 'cup', 'bed', 'coffe_maker', 'television', 'curtain', 'lighter', 'doorjamb', 'shaving_cream', 'headset', 'cupboard', 'table', 'clothes_shirt']
Task:Watch TV
response:
{
"thoughts": We recently got a 43 inch TV and have enjoyed watching some of our favorite movies and TV shows. We use a remote to do so.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['crayon', 'chair', 'detergent', 'cat', 'toothbrush', 'phone', 'character', 'purse', 'thread', 'computer', 'ceilinglamp', 'stereo', 'couch', 'food_peanut_butter', 'towel', 'wall', 'cup', 'food_cheese', 'photoframe', 'light_bulb', 'coffe_maker', 'television', 'towel_rack', 'kitchen_counter', 'dishrack', 'comb', 'dresser', 'door', 'sink', 'instrument_violin']
Task:Keep cats out of room
response:
| {
"thoughts": "Stand in the doorway and create a loud noise so the cats will stay out.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <cat>",
"[FIND] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <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:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'towel', 'wall', 'wall_clock', 'oven', 'television', 'tray', 'rag', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'laser_pointer']
Task:Take shower
response:
{
"thoughts": Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower.,
"actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <bathroom_cabinet>', '[FIND] <shower>', '[RINSE] <shower>']
}
|
Scene_Objects:['sheets', 'cpuscreen', 'phone', 'desk', 'cleaning_solution', 'keyboard', 'purse', 'table_cloth', 'stovefan', 'tvstand', 'shower', 'stereo', 'food_noodles', 'towel', 'pillow', 'wall', 'wall_clock', 'oven', 'basket_for_clothes', 'photoframe', 'novel', 'food_rice', 'rag', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'napkin', 'table']
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:['jelly', 'bathroom', 'trashcan', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall_clock', 'newspaper', 'coffe_maker', 'television', 'curtain', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathtub', 'sink', 'clothes_scarf', 'light']
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', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light', 'table']
Task:Straighten paintings on wall
response:
| {
"thoughts": "Go up to the painting and tilt it which ever way it is uneven until it looks straight.",
"actions": [
"[WALK] <home_office>",
"[WALK] <wall>",
"[WALK] <drawing>",
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>",
"[TOUCH] <drawing>",
"[PULL] <drawing>",
"[PUSH] <drawing>",
"[WALK] <drawing>",
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>",
"[TOUCH] <drawing>",
"[PULL] <drawing>",
"[PUSH] <drawing>",
"[WALK] <drawing>",
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>",
"[TOUCH] <drawing>",
"[PULL] <drawing>",
"[PUSH] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <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:['water_glass', 'pot', 'microwave', 'toilet', 'band-aids', 'walllamp', 'trashcan', 'knifeblock', 'drawing', 'ceiling', 'desk', 'stovefan', 'faucet', 'mousepad', 'wall', 'nightstand', 'oven', 'check', 'food_food', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cd', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'soap', 'laser_pointer']
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:['blender', 'tea', 'microwave', 'jelly', 'band-aids', 'freezer', 'bathroom', 'needle', 'ceiling', 'character', 'keyboard', 'mop_bucket', 'ceilinglamp', 'mat', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'oven', 'photoframe', 'coffe_maker', 'check', 'television', 'cards', 'laundry_detergent', 'clothes_dress', 'home_office', 'table']
Task:Put umbrella away
response:
| {
"thoughts": "Place the umbrella in the umbrella bucket point first.",
"actions": [
"[WALK] <home_office>",
"[WALK] <mop_bucket>"
]
} |
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', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'light']
Task:Work
response:
{
"thoughts": you go into your office, switch on the light, find chair at desk, sit in the chair, switch on the computer and work.,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']
}
|
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>"
]
} |
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:['freezer', 'toothbrush', 'cpuscreen', 'clothes_underwear', 'wallshelf', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'computer', 'button', 'pillow', 'dining_room', 'bench', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'cd', 'dresser', 'cupboard', 'pajamas', 'clothes_dress', 'sink', 'home_office', 'laser_pointer']
Task:Browse internet
response:
{
"thoughts": Walk to home office. Walk to computer. Switch on Computer.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['spectacles', 'filing_cabinet', 'walllamp', 'drawing', 'floor', 'desk', 'tea_bag', 'computer', 'clothes_jacket', 'toaster', 'mat', 'mousepad', 'closetdrawer', 'towel', 'tape', 'basket_for_clothes', 'bed', 'curtain', 'shaving_cream', 'towel_rack', 'mouse', 'kitchen_counter', 'chessboard', 'dresser', 'hair', 'laundry_detergent', 'bathroom_cabinet', 'light', 'board_game', 'dirt']
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:['tablelamp', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'broom', 'wall', 'pasta', 'powersocket', 'shelf', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'light', 'table']
Task:Work
response:
{
"thoughts": I walk to the living room. I find the computer and turn it on. I look at the computer screen. I move and click the mouse to select buttons on the screen.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[PUSH] <mouse>', '[FIND] <button>', '[PUSH] <button>']
}
|
Scene_Objects:['spectacles', 'walllamp', 'nail_polish', 'milk', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'food_bacon', 'piano_bench', 'mat', 'tvstand', 'stereo', 'couch', 'clothes_hat', 'form', 'pillow', 'dining_room', 'wall', 'wall_clock', 'cup', 'photoframe', 'novel', 'coffe_maker', 'television', 'ice', 'doorjamb', 'mouse', 'scrabble']
Task:Read book
response:
| {
"thoughts": "Sit on a couch, grab a book, open it, and scan the pages",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TURNTO] <novel>",
"[LOOKAT] <novel>",
"[READ] <novel>",
"[READ] <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:['tablelamp', 'walllamp', 'food_butter', 'toothbrush', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'microphone', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'powersocket', 'bed', 'photoframe', 'razor', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser', 'door', 'light']
Task:Turn off light
response:
{
"thoughts": Hit the switch.,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHOFF] <light>']
}
|
Scene_Objects:['beer', 'measuring_cup', 'orchid', 'hanger', 'floor', 'ceiling', 'phone', 'tea_bag', 'keyboard', 'purse', 'computer', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'novel', 'food_food', 'television', 'doorjamb', 'coffee_pot', 'vacuum_cleaner', 'dresser', 'hairbrush', 'door', 'napkin', 'home_office', 'board_game']
Task:Sweep hallway please
response:
| {
"thoughts": "Vacuum all the way up and down the hallway. Get all the dirt and crumbs out of carpet please.",
"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:['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>']
}
|
Scene_Objects:['dry_pasta', 'sponge', 'filing_cabinet', 'measuring_cup', 'bathroom', 'trashcan', 'food_carrot', 'cpuscreen', 'character', 'computer', 'floor_lamp', 'closetdrawer', 'couch', 'food_peanut_butter', 'food_kiwi', 'oven', 'cup', 'bed', 'video_game_controller', 'doorjamb', 'coffee_pot', 'paper_towel', 'dishrack', 'headset', 'hair', 'cupboard', 'spoon', 'bathroom_cabinet', 'table', 'tooth_paste']
Task:Clean
response:
| {
"thoughts": "Clean lamp shades in the living room",
"actions": [
"[WALK] <home_office>",
"[WALK] <paper_towel>",
"[FIND] <paper_towel>",
"[GRAB] <paper_towel>",
"[WALK] <floor_lamp>",
"[WIPE] <floor_lamp>",
"[FIND] <trashcan>",
"[PUTBACK] <paper_towel> <trashcan>",
"[FIND] <paper_towel>",
"[GRAB] <paper_towel>",
"[WALK] <floor_lamp>",
"[WIPE] <floor_lamp>",
"[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:['sheets', 'jelly', 'freezer', 'chair', 'blow_dryer', 'bathroom', 'walllamp', 'knife', 'phone', 'keyboard', 'stovefan', 'homework', 'couch', 'food_jam', 'bench', 'oven', 'toy', 'box', 'food_cheese', 'oven_mitts', 'food_rice', 'tray', 'curtain', 'after_shave', 'dresser', 'clothes_dress', 'conditioner', 'hairdryer', 'vase', 'board_game']
Task:Pet cat
response:
{
"thoughts": I walk to my living room, find my cat, scrub it using my hand.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>']
}
|
Scene_Objects:['spectacles', 'walllamp', 'bathroom', 'blow_dryer', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'computer', 'mat', 'mousepad', 'closetdrawer', 'food_orange', 'dining_room', 'wall', 'nightstand', 'basket_for_clothes', 'coffe_maker', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'light', 'clothes_skirt', 'laser_pointer']
Task:Vacuum
response:
| {
"thoughts": "Plug in the vacuum. Turn it on. Push it back and forth across the floor until all the debris is gone.",
"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:['walllamp', 'nail_polish', 'trashcan', 'milk', 'drawing', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'computer', 'faucet', 'pillow', 'wall', 'photoframe', 'toilet_paper', 'check', 'coffe_maker', 'wine', 'after_shave', 'towel_rack', 'comb', 'controller', 'sink', 'bathroom_cabinet', 'light', 'table', 'instrument_violin', 'teeth']
Task:Get toilet paper
response:
{
"thoughts": There are extra toilet papers in the bottom cabinet.,
"actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'bathroom', 'drawing', 'orchid', 'floor', 'bookshelf', 'mat', 'tvstand', 'shower', 'oil', 'closetdrawer', 'candle', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'cup', 'bed', 'photoframe', 'tray', 'doorjamb', 'pencil', 'cupboard', 'door', 'home_office', 'light', 'soap']
Task:Read book
response:
| {
"thoughts": "Climb into bed, then read the novel",
"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:['chair', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'stereo', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'wall', 'oven', 'tape', 'check', 'television', 'doorjamb', 'mouse', 'pencil', 'cd', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light', 'table', 'instrument_violin']
Task:Relax on sofa
response:
{
"thoughts": I want to relax on the sofa to some relaxing music in the living room.,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <stereo>', '[PLUGIN] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light']
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:['fork', 'tablelamp', 'food_ice_cream', 'walllamp', 'bathroom', 'ceilingfan', 'trashcan', 'woman', 'drawing', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'bedroom', 'man', 'ceilinglamp', 'window', 'couch', 'wall', 'bench', 'cup', 'newspaper', 'novel', 'check', 'television', 'towel_rack', 'clothes_dress', 'table', 'clothes_skirt', 'creditcard']
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>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door', 'teeth', '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', 'filing_cabinet', 'crayon', 'dog', 'freezer', 'knife', 'orchid', 'bathroom_counter', 'character', 'bedroom', 'faucet', 'couch', 'food_orange', 'towel', 'nightstand', 'oven', 'powersocket', 'photoframe', 'check', 'video_game_controller', 'food_donut', 'food_rice', 'food_onion', 'diary', 'dresser', 'hairbrush', 'clothes_scarf', 'napkin', 'bathroom_cabinet', 'colander']
Task:Pet cat
response:
{
"thoughts": Walk into the living room. Walk up to the cat. Pet the cat with your hand.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'love_seat', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'clothes_scarf']
Task:Watch TV
response:
| {
"thoughts": "Sit and watch the television",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <love_seat>",
"[SIT] <love_seat>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[WATCH] <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:['fork', 'tablelamp', 'crayon', 'microwave', 'drawing', 'bills', 'cpuscreen', 'longboard', 'floor', 'bookshelf', 'computer', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'window', 'oil', 'couch', 'food_jam', 'food_orange', 'wall', 'bench', 'mouthwash', 'television', 'cupboard', 'table', 'clothes_skirt', 'light', 'tooth_paste']
Task:Relax on sofa
response:
{
"thoughts": walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['filing_cabinet', 'blender', 'food_ice_cream', 'toilet', 'walllamp', 'detergent', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'computer', 'toaster', 'mat', 'tvstand', 'laptop', 'ceilinglamp', 'brush', 'couch', 'pillow', 'dining_room', 'wall', 'child', 'oven', 'photoframe', 'bed', 'television', 'doorjamb', 'mouse', 'dishwasher']
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:['spectacles', 'food_pizza', 'filing_cabinet', 'tablelamp', 'freezer', 'nail_polish', 'cpuscreen', 'desk', 'bookshelf', 'keyboard', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'wall', 'wall_clock', 'bed', 'coffe_maker', 'mouthwash', 'video_game_controller', 'television', 'razor', 'check', 'tray', 'curtain', 'cd', 'spoon', 'vase']
Task:Pet cat
response:
{
"thoughts": Walk to living room. Find the cat. Walk over to the cat. Touch the cat.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'detergent', 'food_butter', 'toothbrush', 'drawing', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'dish_soap', 'wall', 'nightstand', 'cup', 'coffe_maker', 'coffee_filter', 'drinking_glass', 'tray', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'sink', 'coffee_cup', 'dishwasher', 'shoe_rack']
Task:Clean dishes
response:
| {
"thoughts": "Wash dishes in the sink then place them in the dishwasher. Put detergent in the dishwasher and turn it on when full.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[FIND] <drinking_glass>",
"[WASH] <drinking_glass>",
"[FIND] <coffee_cup>",
"[WASH] <coffee_cup>",
"[FIND] <plate>",
"[WASH] <plate>",
"[GRAB] <coffee_cup>",
"[PUTBACK] <coffee_cup> <plate>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[GRAB] <drinking_glass>",
"[PUTBACK] <drinking_glass> <dishwasher>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <detergent>",
"[GRAB] <detergent>",
"[PUTBACK] <detergent> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <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', 'freezer', 'ground_coffee', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'toaster', 'tvstand', 'window', 'oil', 'couch', 'wall', 'nightstand', 'newspaper', 'coffe_maker', 'television', 'coffee_filter', 'water', 'food_donut', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'dirt']
Task:Make coffee
response:
{
"thoughts": Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. 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>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'ceilinglamp', 'floor_lamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'oven', 'photoframe', 'novel', 'television', 'doorjamb', 'dresser', 'cupboard', 'light']
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:['sheets', 'pot', 'filing_cabinet', 'tea', 'chair', 'freezer', 'ground_coffee', 'drawing', 'orchid', 'floor', 'purse', 'faucet', 'balanceball', 'food_noodles', 'food_peanut_butter', 'wall', 'powersocket', 'toy', 'bed', 'food_food', 'check', 'food_donut', 'doorjamb', 'pencil', 'laundry_detergent', 'door', 'bag', 'napkin', 'light', 'table']
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>']
}
|
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>"
]
} |
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', 'microwave', 'toilet', 'jelly', 'freezer', 'bathroom', 'drawing', 'orchid', 'character', 'folder', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'food_noodles', 'couch', 'clothes_hat', 'towel', 'nightstand', 'powersocket', 'rag', 'towel_rack', 'pencil', 'kitchen_counter', 'cupboard', 'pajamas', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']
Task:Wash hands
response:
{
"thoughts": I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel.,
"actions": ['[WALK] <dining_room>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[FIND] <towel>', '[RINSE] <towel>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'coffee_cup']
Task:Type up document
response:
| {
"thoughts": "A person at a computer desk with coffee on the side by the keyboard typing up a document. The person looks relaxed and is typing while looking at the screen which shows a text editor and the content the person was typing.",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <check>",
"[GRAB] <check>",
"[READ] <check>",
"[FIND] <coffee_cup>",
"[GRAB] <coffee_cup>",
"[DRINK] <coffee_cup>",
"[PUTOBJBACK] <coffee_cup>",
"[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:['fork', 'tablelamp', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'needle', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'brush', 'mousepad', 'wall', 'nightstand', 'bed', 'photoframe', 'check', 'food_food', 'doorjamb', 'mouse', 'kitchen_counter', 'headset', 'door', 'table', 'light', 'shoe_rack']
Task:Listen to music
response:
{
"thoughts": I'll walk to my bedroom, where I have my computer. I'll walk to my computer and sit down in front of it. I'll put on my headphones and unlock my computer. I'll then navigate to music stored locally or streamed through the web.,
"actions": ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <headset>', '[GRAB] <headset>', '[PUTON] <headset>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'tablelamp', 'microwave', 'chair', 'freezer', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'stovefan', 'shower', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'cup', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'table', 'dishwasher', 'light']
Task:Wipe down counter
response:
| {
"thoughts": "Clean counter",
"actions": [
"[WALK] <dining_room>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <rag>",
"[SQUEEZE] <rag>",
"[SWITCHOFF] <faucet>",
"[WALK] <kitchen_counter>",
"[WIPE] <kitchen_counter>"
]
} |
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', 'filing_cabinet', 'tablelamp', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'bills', 'floor', 'ceiling', 'character', 'food_cake', 'piano_bench', 'brush', 'ceilinglamp', 'mousepad', 'towel', 'wall', 'bed', 'food_food', 'food_donut', 'ice', 'curtain', 'kettle', 'dresser', 'light', 'soap', 'coffee']
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>']
}
|
Scene_Objects:['pot', 'tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'computer', 'food_bacon', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'deck_of_cards', 'mousepad', 'couch', 'wall', 'nightstand', 'newspaper', 'television', 'mouse', 'door', 'sink', 'home_office']
Task:Read newspaper
response:
| {
"thoughts": "Sit in my chair at my desk. Open up newspaper. Read about current events.",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <newspaper>",
"[GRAB] <newspaper>",
"[OPEN] <newspaper>",
"[READ] <newspaper>"
]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.