instruction
stringlengths 1k
2.35k
| input
stringlengths 351
560
| 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:['sheets', 'filing_cabinet', 'tablelamp', 'tea', 'trashcan', 'drawing', 'orchid', 'floor', 'character', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'stovefan', 'tvstand', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'wall_clock', 'cup', 'bed', 'food_donut', 'curtain', 'towel_rack', 'sink', 'napkin', 'bathtub']
Task:Go to sleep
response:
{
"thoughts": Enter bedroom, turn on the light, and shut door. Change into night clothes. Turn off light. Turn down comforter, climb into bed, lay head on pillow, and cover up with comforter. Close eyes and drift off to sleep.,
"actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <sheets>', '[PULL] <sheets>']
}
|
Scene_Objects:['spectacles', 'sheets', 'filing_cabinet', 'food_salt', 'toilet', 'band-aids', 'walllamp', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'phone', 'computer', 'mop_bucket', 'stovefan', 'tvstand', 'deck_of_cards', 'closetdrawer', 'newspaper', 'coffe_maker', 'doorjamb', 'dresser', 'cupboard', 'door', 'food_steak', 'bag', 'sink', 'table', 'dishwasher', 'bathroom_cabinet']
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', 'food_ice_cream', 'microwave', 'walllamp', 'bathroom', 'cat', 'trashcan', 'knifeblock', 'hanger', 'floor', 'faucet', 'shower', 'clothes_hat', 'wall', 'nightstand', 'tape', 'cup', 'food_food', 'water', 'tray', 'diary', 'pencil', 'kitchen_counter', 'headset', 'hairbrush', 'cupboard', 'hair', 'sink', 'instrument_guitar', 'soap']
Task:Drink
response:
{
"thoughts": Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass.,
"actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']
}
|
Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'window', 'oil', 'mousepad', 'couch', 'closetdrawer', 'food_jam', 'pillow', 'towel', 'dining_room', 'bowl', 'wall', 'nightstand', 'pasta', 'clothes_gloves', 'food_food', 'television', 'tray', 'hairbrush', 'clothes_dress']
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:['filing_cabinet', 'microwave', 'walllamp', 'detergent', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'wall_clock', 'television', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'table', 'light']
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:['food_ice_cream', 'tea', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'folder', 'laptop', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'towel', 'wall', 'box', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'vacuum_cleaner', 'dresser', 'door', 'clothes_scarf', 'light', 'creditcard']
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:['beer', 'microwave', 'dog', 'chair', 'cat', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'phone', 'character', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'closetdrawer', 'oven', 'food_cheese', 'novel', 'toothbrush_holder', 'television', 'food_donut', 'console', 'controller', 'clothes_scarf', 'light', 'colander', 'board_game', 'creditcard']
Task:Pet cat
response:
{
"thoughts": I walk to my cat, and I pet him,
"actions": ['[WALK] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'band-aids', 'drawing', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'button', 'toaster', 'mat', 'clothes_hat', 'wall', 'powersocket', 'oven', 'toy', 'novel', 'toothbrush_holder', 'after_shave', 'doorjamb', 'pencil', 'door', 'light', 'table', 'dishwasher', 'colander']
Task:Put toys away
response:
| {
"thoughts": "Pick up all the toys on the floor and put them in their correct storage bin or shelf.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <toy>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['filing_cabinet', 'measuring_cup', 'microwave', 'milk', 'knifeblock', 'bills', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'keyboard', 'stovefan', 'laptop', 'shoe-shine_kit', 'shower', 'candle', 'clothes_hat', 'towel', 'dining_room', 'wall_clock', 'powersocket', 'newspaper', 'doorjamb', 'shaving_cream', 'vacuum_cleaner', 'dishrack', 'dishwasher', 'instrument_violin', 'creditcard']
Task:Vacuum
response:
| {
"thoughts": "Robot has a vacuum underneath its feat/body that will allow it to clean the surface of the floor.",
"actions": [
"[WALK] <home_office>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[WALK] <dining_room>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[WALK] <home_office>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <vacuum_cleaner> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'spectacles', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'form', 'pillow', 'wall', 'oven', 'box', 'newspaper', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'pencil', 'cupboard', 'maindoor', 'table', 'dishwasher']
Task:Change TV channel
response:
{
"thoughts": Walk to living room. Walk to and sit at the sofa. Grab remote control and switch on TV.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['food_bread', 'beer', 'toilet', 'chair', 'freezer', 'food_butter', 'food_carrot', 'milk', 'drawing', 'floor', 'ceiling', 'toaster', 'mat', 'shower', 'mousepad', 'garbage_can', 'food_dessert', 'wall', 'nightstand', 'powersocket', 'oven', 'food_vegetable', 'food_cheese', 'photoframe', 'food_food', 'food_onion', 'doorjamb', 'laundry_detergent', 'door', 'light']
Task:Rotate stock in refrigerator
response:
| {
"thoughts": "Throw out expired items, put older items in front.",
"actions": [
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_bread>",
"[GRAB] <food_bread>",
"[TURNTO] <food_bread>",
"[LOOKAT] <food_bread>",
"[PUTOBJBACK] <food_bread>",
"[FIND] <food_cheese>",
"[GRAB] <food_cheese>",
"[TURNTO] <food_cheese>",
"[LOOKAT] <food_cheese>",
"[FIND] <garbage_can>",
"[PUTBACK] <food_cheese> <garbage_can>",
"[FIND] <food_cheese>",
"[GRAB] <food_cheese>",
"[TURNTO] <food_cheese>",
"[LOOKAT] <food_cheese>",
"[PUTOBJBACK] <food_cheese>",
"[FIND] <food_dessert>",
"[TURNTO] <food_dessert>",
"[LOOKAT] <food_dessert>",
"[PUSH] <food_dessert>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[TURNTO] <food_vegetable>",
"[LOOKAT] <food_vegetable>",
"[PUTBACK] <food_vegetable> <garbage_can>",
"[FIND] <milk>",
"[GRAB] <milk>",
"[TURNTO] <milk>",
"[LOOKAT] <milk>",
"[PUTOBJBACK] <milk>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'toaster', 'stovefan', 'faucet', 'mousepad', 'couch', 'wall', 'pasta', 'oven', 'box', 'food_food', 'water', 'tray', 'pencil', 'kitchen_counter', 'sauce_pan', 'cupboard', 'instrument_guitar', 'bathroom_cabinet']
Task:Cook some food
response:
{
"thoughts": Cook some pasta on the stove,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pasta>', '[GRAB] <pasta>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <sauce_pan>', '[POUR] <water> <sauce_pan>', '[FIND] <oven>', '[SWITCHON] <oven>', '[PUTBACK] <pasta> <sauce_pan>', '[FIND] <sauce_pan>', '[GRAB] <sauce_pan>', '[PUTBACK] <sauce_pan> <oven>']
}
|
Scene_Objects:['chair', 'ground_coffee', 'nail_polish', 'orchid', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'food_cake', 'bookshelf', 'mail', 'toaster', 'plate', 'homework', 'pillow', 'dining_room', 'wall', 'bed', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Make coffee
response:
| {
"thoughts": "Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[OPEN] <coffe_maker>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[GRAB] <ground_coffee>",
"[PUTOBJBACK] <ground_coffee>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <coffe_maker>",
"[CLOSE] <coffe_maker>",
"[SWITCHON] <coffe_maker>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'iron', 'faucet', 'mousepad', 'bowl', 'wall', 'nightstand', 'oven', 'mouse', 'cupboard', 'door', 'clothes_scarf', 'bathroom_cabinet', 'table', 'instrument_guitar']
Task:Work
response:
{
"thoughts": For doing homework walk to home office. Walk to computer. Switch on Computer. Sit in a chair and do homework in computer.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['pot', 'juice', 'food_ice_cream', 'beer', 'food_oatmeal', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'ground_coffee', 'blow_dryer', 'food_carrot', 'dough', 'milk', 'drawing', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'faucet', 'bowl', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'photoframe', 'coffe_maker', 'food_food', 'check', 'oven_mitts', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'napkin', 'light', 'dishwasher', 'table']
Task:Cook some food
response:
| {
"thoughts": "Put oatmeal into a bowl. Add milk. Heat in a microwave. Put pod of coffee into a coffee maker. Activate. Pour juice into a glass.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <bowl>",
"[GRAB] <bowl>",
"[FIND] <food_oatmeal>",
"[GRAB] <food_oatmeal>",
"[PUTBACK] <food_oatmeal> <bowl>",
"[GRAB] <food_oatmeal>",
"[PUTOBJBACK] <food_oatmeal>",
"[CLOSE] <cupboard>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <milk>",
"[GRAB] <milk>",
"[POUR] <milk> <bowl>",
"[PUTOBJBACK] <milk>",
"[CLOSE] <freezer>",
"[FIND] <microwave>",
"[OPEN] <microwave>",
"[PUTIN] <bowl> <microwave>",
"[CLOSE] <microwave>",
"[SWITCHON] <microwave>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[FIND] <coffe_maker>",
"[OPEN] <coffe_maker>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[CLOSE] <coffe_maker>",
"[SWITCHON] <coffe_maker>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[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:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'tvstand', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'food_jam', 'wall', 'nightstand', 'oven', 'newspaper', 'food_food', 'vacuum_cleaner', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table', 'hands_both']
Task:Wash hands
response:
{
"thoughts": I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>']
}
|
Scene_Objects:['filing_cabinet', 'food_salt', 'chair', 'bathroom', 'orchid', 'cpuscreen', 'bathroom_counter', 'desk', 'keyboard', 'button', 'piano_bench', 'ceilinglamp', 'stereo', 'floor_lamp', 'oil', 'mousepad', 'closetdrawer', 'tape', 'love_seat', 'newspaper', 'bed', 'check', 'video_game_controller', 'mouthwash', 'curtain', 'lighter', 'diary', 'doorjamb', 'dresser', 'sink']
Task:Read
response:
| {
"thoughts": "Sit on an easy chair. Turn on music. Take a book and read. Turn on lamp at night.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <stereo>",
"[FIND] <newspaper>",
"[GRAB] <newspaper>",
"[FIND] <love_seat>",
"[SIT] <love_seat>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>",
"[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:['sheets', 'tablelamp', 'chair', 'freezer', 'cat', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'stereo', 'faucet', 'picture', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'home_office', 'light']
Task:Listen to music
response:
{
"thoughts": I go to the bedroom and sit at my desk. I turn my radio on and listen to music.,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['blender', 'milk', 'drawing', 'orchid', 'needle', 'hanger', 'bathroom_counter', 'floor', 'phone', 'computer', 'bookmark', 'toaster', 'mat', 'tvstand', 'electric_shaver', 'clothes_socks', 'closetdrawer', 'couch', 'nightstand', 'wall', 'bed', 'keys', 'photoframe', 'tray', 'centerpiece', 'dresser', 'bag', 'soap', 'clothes_shirt', 'teeth']
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:['pot', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'stovefan', 'plate', 'shower', 'picture', 'faucet', 'dish_soap', 'pillow', 'wall', 'powersocket', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'food_food', 'television', 'lighter', 'centerpiece', 'mouse', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on.,
"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>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['food_bread', 'filing_cabinet', 'toilet', 'freezer', 'dough', 'drawing', 'hanger', 'floor', 'ceiling', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'powersocket', 'wall_clock', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'razor', 'coffee_filter', 'doorjamb', 'hairbrush', 'door', 'home_office', 'light', 'soap']
Task:Put away groceries
response:
| {
"thoughts": "Place groceries in refrigerator from shopping at the grocery store.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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>']
}
|
Scene_Objects:['food_pizza', 'tablelamp', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'remote_control', 'envelope', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'pasta', 'oven', 'love_seat', 'television', 'razor', 'curtain', 'dresser', 'cupboard', 'bathroom_cabinet', 'table']
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:['food_bread', 'tablelamp', 'blender', 'tea', 'chair', 'freezer', 'drawing', 'orchid', 'hanger', 'floor', 'shampoo', 'stamp', 'bedroom', 'desk', 'computer', 'mat', 'stereo', 'mousepad', 'food_jam', 'dining_room', 'wall', 'wall_clock', 'bench', 'photoframe', 'food_food', 'dresser', 'napkin', 'home_office', 'table', 'spoon']
Task:Eat dinner
response:
{
"thoughts": In our dining room, my family eats dinner. Once the food has been prepared, we gather at the dining room table and prepare to eat.,
"actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'chair', 'bathroom', 'drawing', 'food_egg', 'floor', 'desk', 'bookshelf', 'computer', 'mat', 'stereo', 'shower', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'pajamas', 'controller', 'door', 'clothes_scarf', 'light', 'dishwasher', 'board_game']
Task:Pull up carpet
response:
| {
"thoughts": "Pry up a corner of your old dirty carpet. Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt.",
"actions": [
"[WALK] <home_office>",
"[WALK] <mat>",
"[FIND] <mat>",
"[TOUCH] <mat>",
"[PULL] <mat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'shampoo', 'stovefan', 'mat', 'shower', 'window', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'newspaper', 'food_food', 'drinking_glass', 'water', 'curtain', 'doorjamb', 'dresser', 'food_steak', 'door', 'home_office', 'light']
Task:Drink
response:
{
"thoughts": im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <drinking_glass>', '[DRINK] <drinking_glass>']
}
|
Scene_Objects:['spectacles', 'pot', 'scissors', 'microwave', 'chair', 'walllamp', 'knifeblock', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'toaster', 'plate', 'faucet', 'clothes_socks', 'food_kiwi', 'wall', 'powersocket', 'clothes_gloves', 'coffe_maker', 'after_shave', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Do dishes
response:
| {
"thoughts": "Turn on water, rinse off dishes, put in dishwasher.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <sink>",
"[TURNTO] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[RINSE] <plate>",
"[SWITCHOFF] <faucet>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[PUTBACK] <plate> <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:['pot', 'food_salt', 'microwave', 'ceilingfan', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'stovefan', 'mat', 'iron', 'electric_shaver', 'food_noodles', 'mousepad', 'couch', 'clothes_pants', 'pillow', 'powersocket', 'keys', 'coffe_maker', 'oven_mitts', 'wine', 'shaving_cream', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'light', 'tooth_paste']
Task:Hang up car keys
response:
{
"thoughts": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,
"actions": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']
}
|
Scene_Objects:['filing_cabinet', 'microwave', 'jelly', 'chair', 'detergent', 'food_butter', 'knifeblock', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'button', 'toaster', 'mat', 'plate', 'faucet', 'stereo', 'pillow', 'wall', 'powersocket', 'cup', 'food_food', 'diary', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'light']
Task:Get glass of water
response:
| {
"thoughts": "Get a glass from a cabinet. Hold it under the sink and turn the cold water on. Fill the glass. Turn off the water.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[CLOSE] <kitchen_cabinet>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[PUTBACK] <cup> <sink>",
"[GRAB] <cup>",
"[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:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'deck_of_cards', 'window', 'tvstand', 'mousepad', 'pillow', 'wall', 'pasta', 'light_bulb', 'check', 'mouthwash', 'wooden_spoon', 'mouse', 'door', 'table', 'coffee']
Task:Browse internet
response:
{
"thoughts": Turn on computer, pull up browser, browse the internet,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}
|
Scene_Objects:['fork', 'chair', 'freezer', 'knife', 'drawing', 'needle', 'wallshelf', 'floor', 'phone', 'ceiling', 'dvd_player', 'food_bacon', 'ceilinglamp', 'laptop', 'plate', 'shower', 'tvstand', 'tooth_paste', 'wall', 'tape', 'cup', 'novel', 'food_food', 'television', 'coffee_filter', 'hair', 'cupboard', 'table', 'board_game', 'clothes_shirt']
Task:Eat
response:
| {
"thoughts": "I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[FIND] <table>",
"[PUTBACK] <food_food> <table>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[FIND] <knife>",
"[GRAB] <knife>",
"[FIND] <plate>",
"[EAT] <plate>"
]
} |
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', 'mop', 'toilet', 'ceilingfan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'character', 'video_game_console', 'food_cake', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'couch', 'wall', 'powersocket', 'tape', 'cup', 'video_game_controller', 'television', 'mouthwash', 'curtain', 'hairdryer', 'table', 'coffee']
Task:Play games
response:
{
"thoughts": Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video game remote controller.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['pot', 'food_bread', 'beer', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'toaster', 'mat', 'stovefan', 'shower', 'faucet', 'food_orange', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']
Task:Make toast
response:
| {
"thoughts": "Place slices of bread in a toaster ,wait for the bread to pop up .Set aside.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_bread>",
"[GRAB] <food_bread>",
"[CLOSE] <freezer>",
"[FIND] <toaster>",
"[PLUGIN] <toaster>",
"[PUTBACK] <food_bread> <toaster>",
"[SWITCHON] <toaster>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'dog', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'mat', 'faucet', 'shower', 'couch', 'wall', 'powersocket', 'newspaper', 'keys', 'wooden_spoon', 'doorjamb', 'centerpiece', 'kitchen_counter', 'door', 'home_office', 'light', 'shoe_rack']
Task:Turn on light
response:
{
"thoughts": Switch on light in home office,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[SWITCHON] <light>', '[WALK] <home_office>']
}
|
Scene_Objects:['pot', 'juice', 'microwave', 'freezer', 'blow_dryer', 'ground_coffee', 'cat', 'floor', 'legs_both', 'face', 'toaster', 'laptop', 'homework', 'closetdrawer', 'towel', 'feet_both', 'arms_both', 'basket_for_clothes', 'newspaper', 'photoframe', 'coffe_maker', 'mouthwash', 'centerpiece', 'doorjamb', 'headset', 'dresser', 'cupboard', 'napkin', 'soap', 'clothes_shirt']
Task:Try yourself off
response:
| {
"thoughts": "After your shower, go into your bedroom and use a towel to dry water off of yourself before dressing.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[FIND] <dresser>",
"[OPEN] <dresser>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[CLOSE] <dresser>",
"[FIND] <face>",
"[WIPE] <face>",
"[FIND] <arms_both>",
"[WIPE] <arms_both>",
"[FIND] <legs_both>",
"[WIPE] <legs_both>",
"[FIND] <feet_both>",
"[WIPE] <feet_both>",
"[FIND] <basket_for_clothes>",
"[PUTBACK] <towel> <basket_for_clothes>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'freezer', 'ground_coffee', 'detergent', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'stovefan', 'toaster', 'faucet', 'shower', 'closetdrawer', 'candle', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'coffe_maker', 'coffee_filter', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'table']
Task:Make coffee
response:
{
"thoughts": Make coffee in the kitchen.,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[PLUGIN] <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>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['filing_cabinet', 'tea', 'measuring_cup', 'band-aids', 'knifeblock', 'cpuscreen', 'dvd_player', 'folder', 'desk', 'bookmark', 'stereo', 'faucet', 'dustpan', 'microphone', 'oven', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'television', 'food_rice', 'pencil', 'shredder', 'controller', 'home_office', 'light', 'table', 'scrabble', 'electrical_outlet']
Task:Shred receipts
response:
| {
"thoughts": "Take old receipts and put through the shredder",
"actions": [
"[WALK] <home_office>",
"[WALK] <filing_cabinet>",
"[FIND] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[FIND] <check>",
"[GRAB] <check>",
"[CLOSE] <filing_cabinet>",
"[FIND] <electrical_outlet>",
"[FIND] <shredder>",
"[PLUGIN] <shredder>",
"[SWITCHON] <shredder>",
"[PUTBACK] <check> <shredder>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'chair', 'drawing', 'bills', 'knife', 'floor', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_jam', 'form', 'towel', 'dining_room', 'wall', 'basket_for_clothes', 'photoframe', 'novel', 'food_food', 'check', 'television', 'oven_mitts', 'razor', 'tray', 'pencil', 'dresser', 'pajamas', 'table', 'soap']
Task:Read book
response:
{
"thoughts": Sit and read,
"actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[WALK] <couch>', '[SIT] <couch>', '[READ] <novel>']
}
|
Scene_Objects:['tablelamp', 'chair', 'jelly', 'walllamp', 'bathroom', 'knife', 'wallshelf', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'television', 'toothbrush_holder', 'wooden_spoon', 'kettle', 'shoes', 'cupboard', 'conditioner', 'clothes_dress', 'door', 'napkin', 'light']
Task:Read book
response:
| {
"thoughts": "Pick up a book and open to the last page you were on. Read the book.",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <bookmark>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'food_cake', 'thread', 'computer', 'laptop', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'pasta', 'television', 'tray', 'doorjamb', 'mouse', 'headset', 'chessboard', 'cupboard', 'door']
Task:Watch movie
response:
{
"thoughts": Sit in my deck chair with my laptop, find a good movie on You Tube to watch, plug in earphones and listen to movie quietly so I don't disturb my upstairs neighbor.,
"actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <headset>', '[GRAB] <headset>', '[PUTON] <headset>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']
}
|
Scene_Objects:['fork', 'filing_cabinet', 'scissors', 'juice', 'food_salt', 'microwave', 'chair', 'food_butter', 'toothbrush', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'button', 'brush', 'ceilinglamp', 'plate', 'wall', 'tape', 'food_food', 'check', 'food_donut', 'wooden_spoon', 'rag', 'door', 'clothes_scarf', 'napkin', 'table', 'light', 'dishwasher']
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>"
]
} |
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', 'mop', 'microwave', 'freezer', 'walllamp', 'detergent', 'toothbrush', 'orchid', 'drawing', 'clothes_underwear', 'floor', 'thread', 'mat', 'closetdrawer', 'wall', 'nightstand', 'toy', 'standingmirror', 'light_bulb', 'novel', 'check', 'tray', 'cards', 'mouse', 'pencil', 'vacuum_cleaner', 'headset', 'maindoor', 'napkin', 'light']
Task:Read book
response:
{
"thoughts": Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook.,
"actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[TURNTO] <filing_cabinet>', '[LOOKAT] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['tablelamp', 'crayon', 'chair', 'freezer', 'walllamp', 'bathroom', 'woman', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'child', 'powersocket', 'check', 'coffe_maker', 'television', 'curtain', 'pencil', 'dresser', 'table']
Task:Watch movie
response:
| {
"thoughts": "Sitting and watching a movie with family",
"actions": [
"[WALK] <home_office>",
"[WALK] <child>",
"[FIND] <child>",
"[TURNTO] <child>",
"[LOOKAT] <child>",
"[GREET] <child>",
"[FIND] <woman>",
"[TURNTO] <woman>",
"[LOOKAT] <woman>",
"[GREET] <woman>",
"[WALK] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[TOUCH] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[TOUCH] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[TOUCH] <television>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[WATCH] <television>",
"[WATCH] <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:['sponge', 'pot', 'juice', 'cd_player', 'toilet', 'freezer', 'trashcan', 'bedroom', 'remote_control', 'button', 'clothes_jacket', 'toaster', 'laptop', 'ceilinglamp', 'plate', 'homework', 'dining_room', 'broom', 'bench', 'tape', 'keys', 'coffe_maker', 'television', 'towel_rack', 'hair', 'cupboard', 'maindoor', 'sink', 'clothes_skirt', 'vase']
Task:Listen to music
response:
{
"thoughts": I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton,
"actions": ['[WALK] <home_office>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[PLUGIN] <cd_player>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']
}
|
Scene_Objects:['food_bread', 'toilet', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'bathroom_counter', 'ceiling', 'cleaning_solution', 'mop_bucket', 'table_cloth', 'faucet', 'shower', 'iron', 'clothes_socks', 'pillow', 'wall', 'food_food', 'mirror', 'wine', 'doorjamb', 'coffee_pot', 'paper_towel', 'cupboard', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'dishwasher', 'scrabble']
Task:Clean mirror
response:
| {
"thoughts": "First spray the mirrors with Windex or window type spray. Take paper towels and wipe until sparkly clean. If they have streaks, repeat the process.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <bathroom_cabinet>",
"[OPEN] <bathroom_cabinet>",
"[FIND] <paper_towel>",
"[GRAB] <paper_towel>",
"[CLOSE] <bathroom_cabinet>",
"[WALK] <mirror>",
"[FIND] <cleaning_solution>",
"[RINSE] <cleaning_solution>",
"[WIPE] <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:['food_ice_cream', 'microwave', 'toilet', 'chair', 'bathroom_counter', 'floor', 'laptop', 'faucet', 'shower', 'towel', 'wall', 'wall_clock', 'nightstand', 'cup', 'bed', 'photoframe', 'water', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table', 'soap', 'scrabble', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Go into the bathroom and go over to the sink. Grab soap and turn on the water. Wet your hands and rub them together so that the soap lathers. Rub the soap all over your hands thoroughly. Rinse off the soap with water and turn off the sink. Dry your hands with a towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <hands_both>', '[POUR] <water> <hands_both>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}
|
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>"
]
} |
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', 'water_glass', 'pot', 'tablelamp', 'microwave', 'drawing', 'knife', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'toaster', 'stovefan', 'plate', 'shower', 'dish_soap', 'mousepad', 'wall', 'oven', 'photoframe', 'coffe_maker', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'spoon', 'coffee_cup', 'dishwasher', 'light']
Task:Wash dishes with dishwasher
response:
{
"thoughts": I go to the kitchen and put plates, cutlery and glasses into the dishwasher, put the soap, close the machine and switch it on.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <dishwasher>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <dishwasher>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <dishwasher>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[PUTBACK] <water_glass> <dishwasher>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[PUTBACK] <water_glass> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['spectacles', 'tablelamp', 'microwave', 'chair', 'wallshelf', 'hanger', 'floor', 'phone', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'powersocket', 'television', 'coin', 'food_donut', 'ice', 'rag', 'pencil', 'shoes', 'dresser', 'clothes_dress', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'light', 'home_office']
Task:Hang up jacket
response:
| {
"thoughts": "I put clothes on hangers and hang them in the closet",
"actions": [
"[WALK] <bedroom>",
"[WALK] <clothes_dress>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[WALK] <dresser>",
"[FIND] <hanger>",
"[OPEN] <dresser>",
"[PUTIN] <clothes_dress> <dresser>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[WALK] <dresser>",
"[PUTIN] <clothes_dress> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'fork', 'pot', 'sheets', 'food_salt', 'detergent', 'food_butter', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'shampoo', 'desk', 'food_cake', 'mat', 'faucet', 'food_kiwi', 'wall', 'powersocket', 'toy', 'novel', 'food_food', 'curtain', 'dresser', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Going to the sink and scrubbing hands,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>']
}
|
Scene_Objects:['food_salt', 'toilet', 'freezer', 'ground_coffee', 'milk', 'orchid', 'ceiling', 'phone', 'character', 'keyboard', 'food_bacon', 'stovefan', 'ceilinglamp', 'tvstand', 'closetdrawer', 'couch', 'dining_room', 'bowl', 'nightstand', 'pasta', 'food_cheese', 'bed', 'novel', 'check', 'food_food', 'coin', 'tray', 'doorjamb', 'diary', 'table']
Task:Look out window
response:
| {
"thoughts": "I head into my child's room and look out the window to view the neighborhood from a different area in the house.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <window>",
"[TURNTO] <window>",
"[LOOKAT] <window>"
]
} |
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', 'drawing', 'hanger', 'floor', 'phone', 'ceilinglamp', 'plate', 'iron', 'candle', 'pillow', 'wall', 'bench', 'powersocket', 'oven', 'food_food', 'video_game_controller', 'check', 'wooden_spoon', 'after_shave', 'doorjamb', 'shoes', 'dresser', 'cupboard', 'clothes_dress', 'door', 'conditioner', 'sink', 'table', 'light']
Task:Eat dinner
response:
{
"thoughts": Put food on the table, sit down, and eat the food.,
"actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <plate> <table>', '[FIND] <chair>', '[SIT] <chair>', '[EAT] <plate>']
}
|
Scene_Objects:['food_bread', 'tablelamp', 'microwave', 'chair', 'walllamp', 'floor', 'ceiling', 'character', 'bedroom', 'stovefan', 'ceilinglamp', 'faucet', 'oil', 'closetdrawer', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'nightstand', 'cutting_board', 'photoframe', 'television', 'mouse', 'pencil', 'hairbrush', 'pajamas', 'bathroom_cabinet', 'light', 'teeth']
Task:Read book
response:
| {
"thoughts": "Bring book, lie on the sofa, read book",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[GRAB] <novel>",
"[WALK] <couch>",
"[LIE] <couch>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'ceilingfan', 'drawing', 'food_egg', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'television', 'food_rice', 'curtain', 'kitchen_counter', 'hair', 'home_office', 'table', 'light', 'dishwasher', 'dirt']
Task:Change TV channel
response:
{
"thoughts": I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'drawing', 'needle', 'cpuscreen', 'bills', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'mousepad', 'tooth_paste', 'couch', 'pillow', 'towel', 'wall', 'nightstand', 'powersocket', 'television', 'coin', 'razor', 'doorjamb', 'centerpiece', 'mouse', 'door', 'light', 'board_game']
Task:Re arrange office
response:
| {
"thoughts": "Walk in.Turn on light.Move furniture. Change the room",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <desk>",
"[PUSH] <desk>",
"[WALK] <chair>",
"[PUSH] <chair>",
"[WALK] <couch>",
"[PUSH] <couch>",
"[WALK] <filing_cabinet>",
"[PUSH] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'crayon', 'freezer', 'nail_polish', 'food_carrot', 'milk', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'cup', 'bed', 'food_food', 'doorjamb', 'mouse', 'pajamas', 'controller', 'door', 'spoon', 'napkin', 'light', 'dirt']
Task:Get glass of milk
response:
{
"thoughts": Get an empty glass. Take milk from refrigerator and open it. Pour milk into glass.,
"actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'food_salt', 'tea', 'chair', 'food_carrot', 'drawing', 'floor', 'ceiling', 'phone', 'dvd_player', 'bookshelf', 'stovefan', 'mat', 'mousepad', 'food_noodles', 'dining_room', 'wall', 'powersocket', 'oven', 'cup', 'check', 'rag', 'doorjamb', 'cd', 'hairbrush', 'dresser', 'door', 'light']
Task:Turn on light
response:
| {
"thoughts": "Hit light switch",
"actions": [
"[WALK] <bedroom>",
"[WALK] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'shoe-shine_kit', 'balanceball', 'picture', 'ceilinglamp', 'mousepad', 'wall', 'nightstand', 'newspaper', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light']
Task:Work
response:
{
"thoughts": I need to finish some work on my computer in my home office to meet a deadline for tomorrow.,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[TYPE] <keyboard>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[LOOKAT] <computer>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'mat', 'tvstand', 'faucet', 'couch', 'pillow', 'wall', 'powersocket', 'bed', 'clothes_gloves', 'novel', 'toilet_paper', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'door', 'napkin', 'bathroom_cabinet', 'light']
Task:Turn off light
response:
| {
"thoughts": "Hit the switch.",
"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:['beer', 'tea', 'chair', 'walllamp', 'ground_coffee', 'bills', 'orchid', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'mail', 'ceilinglamp', 'mat', 'iron', 'stereo', 'faucet', 'clothes_socks', 'clothes_hat', 'basket_for_clothes', 'food_rice', 'curtain', 'lighter', 'doorjamb', 'towel_rack', 'vacuum_cleaner', 'dishrack', 'cd', 'napkin', 'home_office']
Task:Turn on light
response:
{
"thoughts": I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it.,
"actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TOUCH] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'detergent', 'knife', 'bills', 'bathroom_counter', 'phone', 'folder', 'bedroom', 'character', 'computer', 'toaster', 'stovefan', 'mat', 'window', 'mousepad', 'pillow', 'oven', 'check', 'coffe_maker', 'razor', 'after_shave', 'mouse', 'kitchen_counter', 'shoes', 'dresser', 'pajamas', 'sink', 'bag']
Task:Get dressed
response:
| {
"thoughts": "I get dressed in my bedroom in the mornings.",
"actions": [
"[WALK] <bedroom>",
"[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:['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:['filing_cabinet', 'tablelamp', 'band-aids', 'bathroom', 'cat', 'orchid', 'wallshelf', 'hanger', 'floor', 'phone', 'character', 'bedroom', 'purse', 'computer', 'table_cloth', 'tvstand', 'powersocket', 'toy', 'clothes_gloves', 'coffe_maker', 'razor', 'food_onion', 'centerpiece', 'headset', 'chessboard', 'cupboard', 'door', 'home_office', 'table', 'laser_pointer']
Task:Open door
response:
| {
"thoughts": "I walk up to the door. I use my hand to turn the door knob to the left. I pull the door open with the same hand I used to turn the door knob",
"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:['pot', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'faucet', 'picture', 'window', 'dustpan', 'towel', 'wall', 'nightstand', 'photoframe', 'keys', 'toothbrush_holder', 'food_donut', 'mouse', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Cleaning hands,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'ground_coffee', 'woman', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'shampoo', 'floor', 'ceiling', 'bookshelf', 'food_noodles', 'closetdrawer', 'mousepad', 'couch', 'towel', 'wall', 'food_food', 'television', 'kettle', 'mouse', 'cards', 'vacuum_cleaner', 'dresser', 'door', 'hairdryer', 'dishwasher', 'clothes_shirt']
Task:Greet guests
response:
| {
"thoughts": "Greet people into my home",
"actions": [
"[WALK] <home_office>",
"[WALK] <woman>",
"[FIND] <woman>",
"[GREET] <woman>",
"[FIND] <woman>",
"[GREET] <woman>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'fork', 'filing_cabinet', 'chair', 'cat', 'drawing', 'hanger', 'floor', 'character', 'tea_bag', 'mat', 'picture', 'electric_shaver', 'couch', 'food_jam', 'towel', 'dining_room', 'wall', 'oven', 'coffe_maker', 'tray', 'curtain', 'doorjamb', 'diary', 'cards', 'cupboard', 'door', 'bathroom_cabinet', 'light', 'tooth_paste']
Task:Read book
response:
{
"thoughts": pick up the book open the book and read,
"actions": ['[WALK] <bedroom>', '[WALK] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'window', 'deck_of_cards', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'food_kiwi', 'nightstand', 'wall', 'cup', 'coffe_maker', 'television', 'food_rice', 'curtain', 'dresser', 'napkin', 'table', 'light']
Task:Watch TV
response:
| {
"thoughts": "I sit on my couch and watch TV in my living room",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[TOUCH] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[TOUCH] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[WATCH] <television>",
"[WATCH] <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', '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>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'freezer', 'ground_coffee', 'drawing', 'knifeblock', 'clothes_underwear', 'hanger', 'floor', 'desk', 'stamp', 'bookshelf', 'food_cake', 'table_cloth', 'bookmark', 'mat', 'clothes_hat', 'wall', 'pasta', 'powersocket', 'toy', 'box', 'food_cheese', 'light_bulb', 'doorjamb', 'lighter', 'kitchen_counter', 'door', 'light']
Task:Clean
response:
| {
"thoughts": "Enter inside kid's room, begin picking up toys from the floor and putting them in a toy box, leave once once.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <toy>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'box', 'novel', 'toilet_paper', 'television', 'mouse', 'dresser', 'door', 'food_steak', 'clothes_skirt', 'tooth_paste']
Task:Read book
response:
{
"thoughts": "walk to entrance" "walk to living room" "look for book" "find book" "pick up book" "look for chair" "find chair" "sit in chair" "read book",
"actions": ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[FIND] <novel>', '[FIND] <chair>', '[TURNTO] <chair>', '[LOOKAT] <chair>', '[SIT] <chair>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['sheets', 'sponge', 'crayon', 'microwave', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'floor', 'bookshelf', 'button', 'stovefan', 'mat', 'stereo', 'mousepad', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'bed', 'photoframe', 'light_bulb', 'food_food', 'television', 'kitchen_counter', 'dresser', 'door', 'sink', 'clothes_skirt', 'scrabble']
Task:Breakfast
response:
| {
"thoughts": "I have breakfast in bed, watching tv.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[GRAB] <food_food>",
"[WALK] <bedroom>",
"[WALK] <television>",
"[SWITCHON] <television>",
"[WALK] <bed>",
"[LIE] <bed>",
"[TURNTO] <television>",
"[WATCH] <television>",
"[EAT] <food_food>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'plate', 'stereo', 'mousepad', 'wall', 'bench', 'television', 'wine', 'rag', 'lighter', 'shaving_cream', 'mouse', 'hairbrush', 'door', 'table']
Task:Write an email
response:
{
"thoughts": walk to living room, look at computer, find chair, sit in chair, grab keyboard, grab mouse, type using keyboard and mouse,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TYPE] <keyboard>']
}
|
Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'beer', 'crayon', 'chair', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'bedroom', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cup', 'bed', 'keys', 'food_food', 'television', 'food_onion', 'doorjamb', 'mouse', 'home_office']
Task:Lock door
response:
| {
"thoughts": "Turn the lock.",
"actions": [
"[WALK] <bedroom>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'walllamp', 'bathroom', 'cat', 'ceilingfan', 'knifeblock', 'phone', 'character', 'brush', 'toaster', 'mat', 'faucet', 'ceilinglamp', 'shower', 'window', 'couch', 'wall_clock', 'cup', 'newspaper', 'food_onion', 'lighter', 'towel_rack', 'mouse', 'kitchen_counter', 'headset', 'cupboard', 'table', 'vase', 'laser_pointer']
Task:Pet cat
response:
{
"thoughts": Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner.,
"actions": ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <bedroom>', '[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[FIND] <brush>', '[GRAB] <brush>']
}
|
Scene_Objects:['sponge', 'microwave', 'chair', 'jelly', 'knifeblock', 'floor', 'ceiling', 'character', 'alcohol', 'toaster', 'plate', 'faucet', 'drying_rack', 'window', 'tvstand', 'dish_soap', 'closetdrawer', 'couch', 'towel', 'pillow', 'food_kiwi', 'wall', 'toy', 'novel', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'shoe_rack']
Task:Do dishes
response:
| {
"thoughts": "Wash dirty dishes, dry them and then put them away",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[POUR] <dish_soap> <sink>",
"[PUTOBJBACK] <dish_soap>",
"[FIND] <sponge>",
"[GRAB] <sponge>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[SCRUB] <plate>",
"[RINSE] <plate>",
"[FIND] <drying_rack>",
"[PUTBACK] <plate> <drying_rack>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[SCRUB] <plate>",
"[RINSE] <plate>",
"[PUTBACK] <plate> <drying_rack>",
"[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:['pot', 'crayon', 'detergent', 'ceilingfan', 'food_carrot', 'milk', 'drawing', 'knifeblock', 'food_egg', 'floor', 'phone', 'desk', 'bookshelf', 'envelope', 'ceilinglamp', 'window', 'mousepad', 'couch', 'wall', 'food_cheese', 'novel', 'television', 'food_rice', 'after_shave', 'towel_rack', 'kitchen_counter', 'comb', 'table', 'dishwasher', 'creditcard']
Task:Relax on sofa
response:
{
"thoughts": I walk to the living room and find the sofa. I sit on the sofa and get comfortable.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['sheets', 'scissors', 'chair', 'dog', 'ground_coffee', 'knife', 'needle', 'bills', 'bathroom_counter', 'floor', 'phone', 'bookshelf', 'bookmark', 'ceilinglamp', 'faucet', 'shower', 'picture', 'food_noodles', 'clothes_socks', 'mousepad', 'pillow', 'wall', 'photoframe', 'food_food', 'tray', 'kitchen_counter', 'sink', 'bag', 'home_office', 'table']
Task:Sit
response:
| {
"thoughts": "We sit at the dining room table",
"actions": [
"[WALK] <dining_room>",
"[WALK] <chair>",
"[FIND] <chair>",
"[PULL] <chair>",
"[SIT] <chair>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['tablelamp', 'scissors', 'food_carrot', 'hanger', 'phone', 'desk', 'keyboard', 'computer', 'stovefan', 'deck_of_cards', 'faucet', 'window', 'closetdrawer', 'microphone', 'pillow', 'box', 'bed', 'photoframe', 'check', 'food_onion', 'diary', 'pencil', 'shoes', 'dishrack', 'dresser', 'laundry_detergent', 'spoon', 'soap', 'tooth_paste', 'shoe_rack']
Task:Take off shoes
response:
| {
"thoughts": "Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <shoes>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PULL] <shoes>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[PUTIN] <shoes> <dresser>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PULL] <shoes>",
"[WALK] <dresser>",
"[PUTIN] <shoes> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'filing_cabinet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'shoe-shine_kit', 'mousepad', 'pillow', 'wall', 'powersocket', 'cup', 'bed', 'wooden_spoon', 'coffee_pot', 'mouse', 'kitchen_counter', 'door', 'home_office', 'table']
Task:Write an email
response:
{
"thoughts": I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer off.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <computer>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'food_pizza', 'tablelamp', 'beer', 'freezer', 'blow_dryer', 'drawing', 'needle', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'mat', 'mousepad', 'form', 'wall', 'powersocket', 'food_cheese', 'food_food', 'check', 'doorjamb', 'mouse', 'chessboard', 'dresser', 'laundry_detergent', 'door', 'hairdryer', 'light', 'board_game']
Task:Put clothes away
response:
| {
"thoughts": "I take clean clothes and either place them in dresser drawers or hang them in a closet.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'chair', 'freezer', 'walllamp', 'food_butter', 'bills', 'cpuscreen', 'bathroom_counter', 'phone', 'ceiling', 'character', 'bedroom', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'floor_lamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'oven', 'cup', 'photoframe', 'television', 'kitchen_counter', 'dresser', 'bathroom_cabinet', 'table', 'light']
Task:Turn on light
response:
{
"thoughts": Walk over to light switch, flip the switch to the on position,
"actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}
|
Scene_Objects:['pot', 'food_pizza', 'ground_coffee', 'walllamp', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'character', 'computer', 'piano_bench', 'stovefan', 'toaster', 'tvstand', 'faucet', 'oil', 'pillow', 'wall', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'after_shave', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'dishwasher']
Task:Make coffee
response:
| {
"thoughts": "Get my coffee pot going",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffee_pot>",
"[FIND] <coffee_pot>",
"[GRAB] <coffee_pot>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <coffee_pot>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[PUTBACK] <ground_coffee> <coffee_pot>",
"[GRAB] <ground_coffee>",
"[PUTOBJBACK] <ground_coffee>",
"[WALK] <oven>",
"[PUTBACK] <coffee_pot> <oven>",
"[SWITCHON] <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'chair', 'knifeblock', 'knife', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'mail', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'stereo', 'pillow', 'dining_room', 'wall', 'cup', 'bed', 'novel', 'coffe_maker', 'doorjamb', 'kitchen_counter', 'cupboard', 'controller', 'laundry_detergent', 'hairdryer', 'sink', 'home_office', 'dishwasher']
Task:Make coffee
response:
{
"thoughts": Making coffee,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['spectacles', 'tablelamp', 'beer', 'measuring_cup', 'band-aids', 'woman', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'ceiling', 'character', 'desk', 'man', 'thread', 'clothes_jacket', 'tvstand', 'stereo', 'faucet', 'window', 'shower', 'couch', 'form', 'cutting_board', 'novel', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'instrument_violin']
Task:Greet guests
response:
| {
"thoughts": "Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.",
"actions": [
"[WALK] <home_office>",
"[WALK] <man>",
"[FIND] <man>",
"[GREET] <man>",
"[FIND] <woman>",
"[GREET] <woman>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'scissors', 'tablelamp', 'crayon', 'microwave', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'longboard', 'shampoo', 'dvd_player', 'folder', 'mail', 'bookmark', 'toaster', 'shower', 'homework', 'couch', 'bed', 'clothes_gloves', 'towel_rack', 'mouse', 'pencil', 'cupboard', 'maindoor', 'table', 'laser_pointer']
Task:Pet cat
response:
{
"thoughts": I walk into the living room and I pet the cat,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['sheets', 'food_pizza', 'tablelamp', 'chair', 'walllamp', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'man', 'food_bacon', 'stovefan', 'ceilinglamp', 'brush', 'mat', 'oil', 'couch', 'food_jam', 'pillow', 'wall', 'nightstand', 'newspaper', 'novel', 'coffe_maker', 'television', 'mouse', 'chessboard', 'soap', 'instrument_violin', 'teeth']
Task:Have conversation with boyfriend
response:
| {
"thoughts": "Sit on sofa, talk",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[WALK] <couch>",
"[SIT] <couch>",
"[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', 'tablelamp', 'blender', 'microwave', 'toilet', 'dog', 'freezer', 'drawing', 'knifeblock', 'longboard', 'floor', 'folder', 'computer', 'ceilinglamp', 'window', 'couch', 'wall', 'nightstand', 'bench', 'cup', 'bed', 'clothes_gloves', 'novel', 'television', 'curtain', 'towel_rack', 'cupboard', 'sink', 'home_office', 'table']
Task:Relax on sofa
response:
{
"thoughts": I'm tired and want to relax on the sofa,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'walllamp', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'thread', 'bookshelf', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'clothes_socks', 'wall', 'pasta', 'powersocket', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'television', 'rag', 'doorjamb', 'shoes', 'door', 'table', 'dishwasher']
Task:Watch TV
response:
{
"thoughts": turn on the tv,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']
}
|
Scene_Objects:['sheets', 'sponge', 'mop', 'chair', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'window', 'mousepad', 'clothes_socks', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'pasta', 'nightstand', 'light_bulb', 'coffe_maker', 'television', 'wooden_spoon', 'mouse', 'shoes', 'vacuum_cleaner', 'sink']
Task:Check email
response:
| {
"thoughts": "Sit in teak deck chair, have wooden drawing board on lap, laptop on wooden drawing board, log in to my two email accounts, go through new emails and respond.",
"actions": [
"[WALK] <home_office>",
"[WALK] <laptop>",
"[FIND] <laptop>",
"[GRAB] <laptop>",
"[WALK] <chair>",
"[SIT] <chair>",
"[SWITCHON] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[TOUCH] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[TOUCH] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[TOUCH] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[TOUCH] <laptop>"
]
} |
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', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'laptop', 'faucet', 'mousepad', 'candle', 'microphone', 'food_orange', 'wall', 'photoframe', 'check', 'mouthwash', 'after_shave', 'doorjamb', 'cupboard', 'pajamas', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'light', 'soap', 'clothes_shirt', 'hands_both']
Task:Wash hands
response:
{
"thoughts": I go into the bathroom and turn on the light. I walk to the sink and turn on the water. I grab the soap and wash my hands,
"actions": ['[WALK] <bathroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[PUTOBJBACK] <soap>', '[SWITCHOFF] <faucet>']
}
|
Scene_Objects:['microwave', 'toilet', 'jelly', 'walllamp', 'detergent', 'knifeblock', 'orchid', 'floor', 'ceiling', 'toaster', 'plate', 'faucet', 'dish_soap', 'wall', 'nightstand', 'powersocket', 'oven', 'food_food', 'television', 'coffee_filter', 'wine', 'curtain', 'rag', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bag']
Task:Wash dishes
response:
| {
"thoughts": "Run hot water into tub of dirty dishes in the sink. Add liquid soap. Scrub dishes with wash rag. Rinse and place on drying rack.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[POUR] <dish_soap> <sink>",
"[PUTOBJBACK] <dish_soap>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[SCRUB] <plate>",
"[RINSE] <plate>",
"[FIND] <dishrack>",
"[PUTBACK] <plate> <dishrack>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[SCRUB] <plate>",
"[RINSE] <plate>",
"[PUTBACK] <plate> <dishrack>",
"[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:['sheets', 'filing_cabinet', 'food_pizza', 'tablelamp', 'blender', 'food_salt', 'blow_dryer', 'trashcan', 'toothbrush', 'cpuscreen', 'hanger', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'purse', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'microphone', 'oven', 'food_food', 'check', 'tray', 'dresser', 'napkin', 'bathroom_cabinet', 'clothes_shirt']
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>']
}
|
Scene_Objects:['tablelamp', 'jelly', 'freezer', 'detergent', 'woman', 'orchid', 'drawing', 'phone', 'character', 'man', 'bookshelf', 'toaster', 'ceilinglamp', 'tvstand', 'stereo', 'food_orange', 'nightstand', 'box', 'food_cheese', 'coffe_maker', 'food_food', 'check', 'video_game_controller', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'sink', 'table', 'tooth_paste']
Task:Greet people
response:
| {
"thoughts": "Say HI to those that come in.",
"actions": [
"[WALK] <home_office>",
"[WALK] <woman>",
"[FIND] <woman>",
"[GREET] <woman>",
"[FIND] <woman>",
"[GREET] <woman>",
"[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:['fork', 'chair', 'walllamp', 'knife', 'food_egg', 'floor', 'food_cake', 'toaster', 'plate', 'tvstand', 'window', 'dish_soap', 'wall', 'nightstand', 'oven', 'cutting_board', 'coffe_maker', 'check', 'razor', 'television', 'food_donut', 'tray', 'centerpiece', 'doorjamb', 'dishrack', 'food_steak', 'spoon', 'light', 'dishwasher', 'colander']
Task:Wash dishes with dishwasher
response:
{
"thoughts": put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <dishrack>', '[PUTBACK] <fork> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishrack>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishrack>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['blender', 'freezer', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'brush', 'tvstand', 'stereo', 'window', 'closetdrawer', 'towel', 'wall', 'powersocket', 'tape', 'food_food', 'television', 'curtain', 'doorjamb', 'vacuum_cleaner', 'dresser', 'door', 'clothes_scarf', 'dishwasher', 'board_game']
Task:vacuum carpet
response:
| {
"thoughts": "I bring my vacuum cleaner into the living room. I plug it into the wall. I press the on switch on the vacuum cleaner. I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet. I turn the vacuum cleaner off. I take the vacuum cleaner back to the hall closet.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[WALK] <dresser>",
"[PUTIN] <vacuum_cleaner> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'longboard', 'character', 'bedroom', 'computer', 'faucet', 'homework', 'clothes_socks', 'food_noodles', 'dining_room', 'photoframe', 'check', 'television', 'after_shave', 'rag', 'lighter', 'towel_rack', 'kitchen_counter', 'dresser', 'clothes_dress', 'home_office', 'light', 'laser_pointer', 'scrabble']
Task:Pick up phone
response:
{
"thoughts": I walk to the home office. I find the telephone. I pick up the telephone handset.,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['tablelamp', 'scissors', 'chair', 'bathroom', 'toothbrush', 'drawing', 'cpuscreen', 'floor', 'keyboard', 'piano_bench', 'ceilinglamp', 'oil', 'form', 'food_orange', 'wall', 'nightstand', 'oven', 'photoframe', 'check', 'food_food', 'television', 'coffee_filter', 'tray', 'mouse', 'cd', 'cupboard', 'door', 'table', 'light', 'creditcard']
Task:Eat dinner
response:
| {
"thoughts": "In our dining room, my family eats dinner. Once the food has been prepared, we gather at the dining room table and prepare to eat.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <food_food> <table>",
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <food_food> <table>",
"[WALK] <chair>",
"[PULL] <chair>",
"[SIT] <chair>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'microwave', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'stovefan', 'deck_of_cards', 'shower', 'pillow', 'wall', 'powersocket', 'cup', 'coffe_maker', 'check', 'wine', 'food_onion', 'curtain', 'lighter', 'kitchen_counter', 'cupboard', 'hair', 'controller', 'table', 'dishwasher', 'colander']
Task:Take dishes out of dishwasher
response:
{
"thoughts": Take clean dishes out of the dishwasher and put away,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'ground_coffee', 'walllamp', 'milk', 'cpuscreen', 'ceiling', 'phone', 'keyboard', 'stovefan', 'plate', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'wine', 'tray', 'food_onion', 'mouse', 'kitchen_counter', 'headset', 'comb', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher']
Task:Get out dish
response:
| {
"thoughts": "Open cupboard. Get out the dish.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[CLOSE] <cupboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['sheets', 'pot', 'food_salt', 'cpuscreen', 'clothes_underwear', 'floor', 'bedroom', 'food_cake', 'computer', 'stovefan', 'ceilinglamp', 'oil', 'couch', 'powersocket', 'cutting_board', 'food_cheese', 'photoframe', 'food_food', 'razor', 'oven_mitts', 'coffee_pot', 'mouse', 'shoes', 'dishrack', 'chessboard', 'cupboard', 'controller', 'food_steak', 'hairdryer', 'spoon']
Task:Clean
response:
| {
"thoughts": "Clean the welcome mat",
"actions": [
"[WALK] <home_office>",
"[WALK] <vacuum_cleaner>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'food_ice_cream', 'mop', 'microwave', 'detergent', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'candle', 'wall', 'bed', 'television', 'curtain', 'dresser', 'maindoor', 'table', 'dishwasher', 'vase', 'coffee']
Task:Watch TV
response:
{
"thoughts": Walk to livingroom, sit on couch, grab remote and turn on tv.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['sheets', 'measuring_cup', 'microwave', 'jelly', 'ground_coffee', 'drawing', 'knifeblock', 'bathroom_counter', 'character', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'brush', 'faucet', 'picture', 'mat', 'closetdrawer', 'powersocket', 'oven', 'cup', 'basket_for_clothes', 'clothes_gloves', 'novel', 'television', 'kettle', 'cupboard', 'sink', 'spoon', 'table']
Task:Read book
response:
| {
"thoughts": "Go to the book shelf, get a book, open the book and read the book.",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'tablelamp', 'crayon', 'tea', 'mop', 'ground_coffee', 'detergent', 'drawing', 'floor', 'phone', 'ceilinglamp', 'laptop', 'shower', 'iron', 'window', 'oil', 'couch', 'pillow', 'wall', 'oven', 'cup', 'coffe_maker', 'toilet_paper', 'television', 'door', 'sink', 'table', 'scrabble', 'dirt']
Task:Read book
response:
{
"thoughts": Bring book, lie on the sofa, read book,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[LIE] <couch>', '[READ] <novel>']
}
|
Scene_Objects:['dry_pasta', 'food_pizza', 'blender', 'tea', 'toilet', 'chair', 'freezer', 'bathroom', 'woman', 'knifeblock', 'drawing', 'wallshelf', 'floor', 'phone', 'character', 'desk', 'man', 'button', 'deck_of_cards', 'mousepad', 'clothes_pants', 'child', 'coffe_maker', 'tray', 'comb', 'dresser', 'cupboard', 'hairbrush', 'soap', 'tooth_paste']
Task:Greet guests
response:
| {
"thoughts": "Greet guests when they knock on the door and invite them to enter my home",
"actions": [
"[WALK] <home_office>",
"[WALK] <child>",
"[FIND] <child>",
"[GREET] <child>",
"[FIND] <man>",
"[GREET] <man>",
"[FIND] <woman>",
"[GREET] <woman>"
]
} |
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', 'sheets', 'tablelamp', 'toilet', 'chair', 'walllamp', 'nail_polish', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'ceilinglamp', 'mat', 'tvstand', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'novel', 'coffe_maker', 'check', 'television', 'curtain', 'lighter', 'bathroom_cabinet', 'table']
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:['pot', 'food_bread', 'beer', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'mat', 'toaster', 'shower', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'food_vegetable', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'tooth_paste']
Task:Cook some food
response:
| {
"thoughts": "I prepare meals and cook them on the stove.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[CLOSE] <freezer>",
"[FIND] <oven>",
"[SWITCHON] <oven>",
"[SWITCHOFF] <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'chair', 'knifeblock', 'knife', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'mail', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'stereo', 'pillow', 'dining_room', 'wall', 'cup', 'bed', 'novel', 'coffe_maker', 'doorjamb', 'kitchen_counter', 'cupboard', 'controller', 'laundry_detergent', 'hairdryer', 'sink', 'home_office', 'dishwasher']
Task:Make coffee
response:
{
"thoughts": Making coffee,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'food_carrot', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'oven_mitts', 'wooden_spoon', 'doorjamb', 'mouse', 'pajamas', 'door', 'light', 'table']
Task:Write an email
response:
| {
"thoughts": "Compose an email in the home office.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'toaster', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'love_seat', 'clothes_gloves', 'television', 'tray', 'curtain', 'food_onion', 'dresser', 'cupboard', 'instrument_guitar', 'table', 'light']
Task:Watch TV
response:
{
"thoughts": I'll watch TV,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['spectacles', 'sheets', 'tablelamp', 'toilet', 'chair', 'walllamp', 'nail_polish', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'ceilinglamp', 'mat', 'tvstand', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'novel', 'coffe_maker', 'check', 'television', 'curtain', 'lighter', 'bathroom_cabinet', 'table']
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>"
]
} |
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:['beer', 'microwave', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'keyboard', 'ceilinglamp', 'mat', 'picture', 'window', 'couch', 'dining_room', 'wall', 'oven', 'powersocket', 'toy', 'photoframe', 'television', 'oven_mitts', 'tray', 'centerpiece', 'kettle', 'towel_rack', 'pencil', 'dishrack', 'table', 'vase']
Task:Relax on sofa
response:
{
"thoughts": go to the living room and sit on the couch, ease into the sofa and relax.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'food_butter', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'button', 'table_cloth', 'stovefan', 'mat', 'brush', 'stereo', 'picture', 'mousepad', 'couch', 'clothes_pants', 'food_jam', 'powersocket', 'oven', 'newspaper', 'cards', 'shoes', 'controller', 'clothes_skirt', 'board_game']
Task:Listen to music
response:
| {
"thoughts": "I go into the living room and turn on the radio. Then, I select the station I want, which is usually a preset.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[FIND] <button>",
"[PUSH] <button>",
"[FIND] <button>",
"[PUSH] <button>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'video_game_console', 'desk', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'video_game_controller', 'television', 'food_rice', 'ice', 'curtain', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet', 'table', 'laser_pointer']
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:['sponge', 'glue', 'toilet', 'chair', 'detergent', 'dough', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'keyboard', 'alcohol', 'stovefan', 'ceilinglamp', 'couch', 'microphone', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'doorjamb', 'kitchen_counter', 'hairbrush', 'cupboard', 'home_office', 'dishwasher', 'coffee', 'shoe_rack']
Task:Make coffee
response:
| {
"thoughts": "Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[OPEN] <coffe_maker>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[FIND] <coffee>",
"[GRAB] <coffee>",
"[PUTBACK] <coffee> <coffe_maker>"
]
} |
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', '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>']
}
|
Scene_Objects:['microwave', 'dog', 'walllamp', 'cat', 'knifeblock', 'drawing', 'bills', 'floor', 'ceiling', 'clothes_jacket', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'iron', 'dish_soap', 'food_noodles', 'mousepad', 'couch', 'wall', 'nightstand', 'mouthwash', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'conditioner', 'door', 'sink', 'dishwasher']
Task:Wash dishes by hand
response:
| {
"thoughts": "Walk to Kitchen, find sink, find dishes and dish soap. Put soap on plate. open faucet, rinse dishes close faucet.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <sink>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <plate>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <plate>"
]
} |
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', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'keys', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'light', 'table']
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:['sponge', 'toilet', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'mat', 'shower', 'food_noodles', 'couch', 'towel', 'wall', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'newspaper', 'water', 'food_donut', 'curtain', 'doorjamb', 'headset', 'door', 'bathroom_cabinet', 'light', 'soap', 'tooth_paste']
Task:Take shower
response:
| {
"thoughts": "Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <shower>",
"[FIND] <shower>",
"[TURNTO] <shower>",
"[FIND] <water>",
"[RINSE] <water>",
"[FIND] <soap>",
"[WASH] <soap>",
"[RINSE] <water>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[SCRUB] <towel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'pot', 'water_glass', 'tablelamp', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'tea_bag', 'toaster', 'stovefan', 'mat', 'shower', 'faucet', 'ceilinglamp', 'oil', 'wall', 'oven', 'powersocket', 'coffe_maker', 'food_food', 'water', 'ice', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bag', 'table', 'dishwasher', 'light']
Task:Drink
response:
{
"thoughts": Going to the kitchen to get a drink of water.,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <water_glass> <sink>', '[GRAB] <water_glass>', '[SWITCHOFF] <faucet>', '[DRINK] <water_glass>', '[FIND] <kitchen_counter>', '[PUTBACK] <water_glass> <kitchen_counter>']
}
|
Scene_Objects:['dry_pasta', 'toilet', 'chair', 'freezer', 'detergent', 'food_butter', 'wallshelf', 'hanger', 'phone', 'character', 'desk', 'remote_control', 'button', 'piano_bench', 'toaster', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'clothes_pants', 'pillow', 'towel', 'wall', 'novel', 'razor', 'diary', 'conditioner', 'table', 'coffee']
Task:Change TV channel
response:
| {
"thoughts": "Take the Tv Remote Control in the Living Room table And Press the Channel Change Button to change the channel",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <button>",
"[PUSH] <button>",
"[PUTOBJBACK] <remote_control>"
]
} |
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', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'thread', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'mousepad', 'couch', 'wall', 'photoframe', 'bed', 'toilet_paper', 'food_onion', 'towel_rack', 'mouse', 'kitchen_counter', 'cd', 'hairbrush', 'bathroom_cabinet', 'light']
Task:Go to toilet
response:
{
"thoughts": walk to bathroom , run to toilet,
"actions": ['[WALK] <bathroom>', '[RUN] <toilet>']
}
|
Scene_Objects:['pot', 'food_pizza', 'food_salt', 'microwave', 'freezer', 'orchid', 'drawing', 'hanger', 'button', 'table_cloth', 'tvstand', 'homework', 'couch', 'dining_room', 'nightstand', 'keys', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'diary', 'cards', 'kitchen_counter', 'comb', 'dresser', 'food_steak', 'home_office', 'light', 'clothes_skirt']
Task:Pet cat
response:
| {
"thoughts": "I go to the living room then go to the cat and touch it.",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'light', 'table']
Task:Watch TV
response:
{
"thoughts": walk to living room. look at remote control. grab remote control. plug in television. switch on television. lie in sofa. point at remote control. watch television.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['sponge', 'spectacles', 'pot', 'microwave', 'knifeblock', 'floor', 'ceiling', 'folder', 'character', 'toaster', 'plate', 'drying_rack', 'faucet', 'dish_soap', 'couch', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'hairdryer', 'light', 'dirt', 'coffee']
Task:Wash dishes by hand
response:
| {
"thoughts": "I walk in to the Kitchen. I find a plate, a sponge, and the dish soap. I find the faucet. I turn the faucet on. I pour water on the sponge and plate. I add dish soap to the sponge. I put the dish soap back. I scrub the plate. I rinse the plate. I place the plate on the drying rack. I rinse the sponge. I turn the faucet off.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <faucet>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <sponge>",
"[GRAB] <sponge>",
"[RINSE] <sponge>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[POUR] <dish_soap> <sponge>",
"[PUTOBJBACK] <dish_soap>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WASH] <plate>",
"[RINSE] <plate>",
"[FIND] <drying_rack>",
"[PUTBACK] <plate> <plate>",
"[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:['pot', 'filing_cabinet', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'floor', 'desk', 'bookshelf', 'plate', 'faucet', 'picture', 'iron', 'window', 'dish_soap', 'food_jam', 'wall', 'nightstand', 'toy', 'cutting_board', 'food_food', 'television', 'curtain', 'pajamas', 'conditioner', 'light', 'dishwasher', 'tooth_paste', 'shoe_rack']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Go to the kitchen. Find the dishwasher. Open the dishwasher. Find the plates. Load the plates into the dishwasher. Find the soap. Load the soap into the dishwasher. Close the dishwasher. Turn on the dishwasher.,
"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] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['sponge', 'sheets', 'filing_cabinet', 'crayon', 'toilet', 'bathroom_counter', 'ceiling', 'folder', 'shower', 'iron', 'window', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'toy', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'food_food', 'tray', 'cd', 'dishrack', 'door', 'napkin', 'light', 'dishwasher', 'board_game']
Task:Read book
response:
| {
"thoughts": "pick up your book and read it",
"actions": [
"[WALK] <bedroom>",
"[WALK] <novel>",
"[GRAB] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'laptop', 'faucet', 'mat', 'closetdrawer', 'teeth', 'dining_room', 'wall', 'pasta', 'toy', 'shelf', 'standingmirror', 'novel', 'check', 'television', 'curtain', 'console', 'dresser', 'napkin', 'table', 'light', 'scrabble', 'coffee']
Task:Look at painting
response:
{
"thoughts": Walk to the painting. Look up at the painting. Admire it on the wall.,
"actions": ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']
}
|
Scene_Objects:['tablelamp', 'microwave', 'chair', 'dog', 'toothbrush', 'knifeblock', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'character', 'desk', 'mat', 'tvstand', 'shower', 'homework', 'dining_room', 'wall', 'bed', 'clothes_gloves', 'toothbrush_holder', 'after_shave', 'doorjamb', 'mouse', 'pencil', 'cd', 'tooth_paste', 'shoe_rack']
Task:Wash teeth
response:
| {
"thoughts": "WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR TEETH",
"actions": [
"[WALK] <bathroom>",
"[WALK] <toothbrush_holder>",
"[FIND] <toothbrush_holder>",
"[FIND] <tooth_paste>",
"[GRAB] <tooth_paste>",
"[FIND] <toothbrush>",
"[GRAB] <toothbrush>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'scissors', 'walllamp', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'bookmark', 'stovefan', 'shower', 'oil', 'dining_room', 'wall', 'powersocket', 'bench', 'love_seat', 'standingmirror', 'novel', 'coffe_maker', 'check', 'after_shave', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'maindoor', 'bathtub', 'soap']
Task:Read book
response:
{
"thoughts": Obtain a book from the book shelf. Sit in the easy chair. Read the book. Mark the stopping point with a bookmark. Put the book back on the book shelf.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']
}
|
Scene_Objects:['fork', 'juice', 'food_salt', 'measuring_cup', 'chair', 'detergent', 'milk', 'drawing', 'kitchen_cabinet', 'floor', 'shampoo', 'dvd_player', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'plate', 'tvstand', 'candle', 'towel', 'food_cheese', 'light_bulb', 'television', 'razor', 'curtain', 'kitchen_counter', 'headset', 'table', 'soap']
Task:Set up table
response:
| {
"thoughts": "Walk into kitchen. Grab plates and forks. Walk into dining room. Put plates and forks on table.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[FIND] <table>",
"[PUTBACK] <fork> <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:['filing_cabinet', 'food_pizza', 'tablelamp', 'food_ice_cream', 'crayon', 'shampoo', 'keyboard', 'mail', 'bookmark', 'stovefan', 'faucet', 'pillow', 'dining_room', 'broom', 'wall', 'love_seat', 'photoframe', 'novel', 'food_food', 'wine', 'tray', 'after_shave', 'shaving_cream', 'kettle', 'headset', 'pajamas', 'laundry_detergent', 'door', 'bathroom_cabinet', 'shoe_rack']
Task:Read book
response:
{
"thoughts": Obtain a book from the book shelf. Sit in the easy chair. Read the book. Mark the stopping point with a bookmark. Put the book back on the book shelf.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']
}
|
Scene_Objects:['food_salt', 'ceiling', 'phone', 'bookshelf', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'homework', 'mousepad', 'food_jam', 'form', 'pillow', 'dining_room', 'wall', 'powersocket', 'bed', 'television', 'tray', 'curtain', 'doorjamb', 'pencil', 'dresser', 'controller', 'laundry_detergent', 'door', 'napkin', 'light', 'dishwasher', 'table', 'teeth']
Task:Pick up phone
response:
| {
"thoughts": "I walk to the home office. I find the telephone. I pick up the telephone handset.",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tea', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'piano_bench', 'mat', 'shoe-shine_kit', 'balanceball', 'oil', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouthwash', 'doorjamb', 'towel_rack', 'vacuum_cleaner', 'door', 'home_office', 'light', 'soap']
Task:Turn on light
response:
{
"thoughts": switching on the light,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['sheets', 'food_pizza', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'alcohol', 'mat', 'shower', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'coffee']
Task:Put groceries in Fridge
response:
| {
"thoughts": "I get my groceries and go to the fridge. I open the fridge and put the groceries there.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'cutting_board', 'novel', 'check', 'television', 'curtain', 'conditioner', 'hairdryer', 'clothes_dress', 'table']
Task:Watch TV
response:
{
"thoughts": watching TV from sofa,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[DROP] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']
}
|
Scene_Objects:['pot', 'mop', 'microwave', 'walllamp', 'detergent', 'food_carrot', 'knifeblock', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'stereo', 'window', 'oil', 'clothes_socks', 'wall', 'oven', 'food_vegetable', 'bed', 'photoframe', 'television', 'food_donut', 'water', 'tray', 'kitchen_counter', 'cupboard', 'dishwasher']
Task:Cook some food
response:
| {
"thoughts": "walk to kicthen , find stove , find cooking pot , find vegetables , find water ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove",
"actions": [
"[WALK] <dining_room>",
"[WALK] <oven>",
"[FIND] <oven>",
"[FIND] <pot>",
"[FIND] <food_vegetable>",
"[FIND] <water>",
"[GRAB] <water>",
"[WASH] <food_vegetable>",
"[POUR] <water> <pot>",
"[FIND] <pot>",
"[GRAB] <pot>",
"[PUTBACK] <pot> <oven>",
"[SWITCHON] <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'mousepad', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'curtain', 'mouse', 'door', 'hairdryer', 'sink', 'food_steak', 'light', 'dishwasher', 'spoon', 'table', 'board_game']
Task:Write school paper
response:
{
"thoughts": Writing and drafting a paper for class work,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'cat', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'ceilinglamp', 'homework', 'mousepad', 'wall', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'shoes', 'comb', 'dresser', 'hairdryer']
Task:Write an email
response:
| {
"thoughts": "I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email",
"actions": [
"[WALK] <laptop>",
"[SWITCHON] <laptop>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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', 'filing_cabinet', 'blender', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'floor', 'bedroom', 'bookshelf', 'stovefan', 'food_peanut_butter', 'clothes_hat', 'clothes_pants', 'dining_room', 'nightstand', 'wall_clock', 'video_game_controller', 'food_donut', 'curtain', 'kettle', 'shoes', 'dresser', 'cupboard', 'hairbrush', 'controller', 'home_office', 'light', 'clothes_skirt', 'soap']
Task:Listen to music
response:
| {
"thoughts": "Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[SWITCHON] <stereo>"
]
} |
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', 'orchid', 'drawing', 'hanger', 'floor', 'phone', 'character', 'keyboard', 'toaster', 'plate', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'dining_room', 'oven', 'powersocket', 'cup', 'bed', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'dresser', 'sink', 'bathtub', 'home_office', 'table']
Task:Drink
response:
{
"thoughts": I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass.,
"actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'bathroom', 'knifeblock', 'cpuscreen', 'hanger', 'bathroom_counter', 'ceiling', 'folder', 'character', 'keyboard', 'bookshelf', 'envelope', 'computer', 'dining_room', 'wall', 'nightstand', 'cup', 'clothes_gloves', 'light_bulb', 'check', 'curtain', 'pencil', 'kitchen_counter', 'controller', 'sink', 'napkin', 'clothes_skirt', 'tooth_paste']
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>"
]
} |
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', 'cat', 'drawing', 'knife', 'knifeblock', 'hanger', 'floor', 'bedroom', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'faucet', 'iron', 'window', 'mousepad', 'couch', 'form', 'dining_room', 'wall', 'oven', 'box', 'newspaper', 'bed', 'novel', 'toilet_paper', 'television', 'tray', 'sink', 'table']
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', 'tablelamp', 'beer', 'measuring_cup', 'microwave', 'dog', 'orchid', 'wallshelf', 'floor', 'bedroom', 'computer', 'mop_bucket', 'ceilinglamp', 'faucet', 'electric_shaver', 'couch', 'food_peanut_butter', 'broom', 'cutting_board', 'photoframe', 'newspaper', 'mouthwash', 'ice', 'tray', 'curtain', 'kitchen_counter', 'shoes', 'headset', 'bathroom_cabinet', '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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'crayon', 'toilet', 'chair', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'computer', 'tvstand', 'faucet', 'stereo', 'food_orange', 'photoframe', 'novel', 'television', 'curtain', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'home_office']
Task:Get dressed
response:
{
"thoughts": I get dressed in my bedroom in the mornings.,
"actions": ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']
}
|
Scene_Objects:['sponge', 'microwave', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'folder', 'desk', 'alcohol', 'stovefan', 'plate', 'mousepad', 'wall', 'oven', 'food_food', 'check', 'tray', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'sink', 'clothes_scarf', 'light', 'clothes_shirt', 'teeth']
Task:Pick up phone
response:
| {
"thoughts": "walk over and pick up the phone",
"actions": [
"[WALK] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'mop', 'microwave', 'freezer', 'walllamp', 'detergent', 'toothbrush', 'orchid', 'drawing', 'clothes_underwear', 'floor', 'thread', 'mat', 'closetdrawer', 'wall', 'nightstand', 'toy', 'standingmirror', 'light_bulb', 'novel', 'check', 'tray', 'cards', 'mouse', 'pencil', 'vacuum_cleaner', 'headset', 'maindoor', 'napkin', 'light']
Task:Read book
response:
{
"thoughts": Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook.,
"actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[TURNTO] <filing_cabinet>', '[LOOKAT] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['pot', 'freezer', 'blow_dryer', 'bathroom', 'nail_polish', 'drawing', 'knife', 'cpuscreen', 'character', 'bookshelf', 'table_cloth', 'mop_bucket', 'bookmark', 'faucet', 'homework', 'nightstand', 'wall', 'novel', 'check', 'coffee_filter', 'coffee_pot', 'shaving_cream', 'kitchen_counter', 'pajamas', 'cupboard', 'clothes_dress', 'laundry_detergent', 'napkin', 'table', 'washing_machine']
Task:Wash clothes
response:
| {
"thoughts": "walk to kitchen. grab clothes_dress. look at washing machine. open washing machine. put clothes_dress on washing machine. close washing machine. switch on washing machine. switch off washing machine.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <clothes_dress>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[FIND] <washing_machine>",
"[TURNTO] <washing_machine>",
"[LOOKAT] <washing_machine>",
"[OPEN] <washing_machine>",
"[PUTBACK] <clothes_dress> <washing_machine>",
"[CLOSE] <washing_machine>",
"[SWITCHON] <washing_machine>",
"[SWITCHOFF] <washing_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:['measuring_cup', 'mop', 'walllamp', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'tvstand', 'window', 'clothes_socks', 'closetdrawer', 'oil', 'dining_room', 'wall', 'toy', 'photoframe', 'television', 'curtain', 'rag', 'doorjamb', 'console', 'kitchen_counter', 'shoes', 'dresser', 'pajamas', 'bathroom_cabinet', 'table', 'tooth_paste']
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>']
}
|
Scene_Objects:['sheets', 'filing_cabinet', 'mop', 'bathroom', 'dough', 'knifeblock', 'hanger', 'keyboard', 'alcohol', 'toaster', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'pasta', 'basket_for_clothes', 'check', 'television', 'razor', 'tray', 'doorjamb', 'chessboard', 'dishrack', 'hairbrush', 'napkin', 'bathroom_cabinet', 'light', 'dishwasher', 'table']
Task:Pick up phone
response:
| {
"thoughts": "go to living room, find phone, pick up phone",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'video_game_console', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'cup', 'video_game_controller', 'television', 'curtain', 'dishrack', 'napkin', 'table', 'vase', 'scrabble', 'shoe_rack']
Task:Play games
response:
{
"thoughts": Turn on game. Use controller,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[PLUGIN] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'toaster', 'shower', 'food_noodles', 'oil', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']
Task:Cook some food
response:
| {
"thoughts": "I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_chicken>",
"[GRAB] <food_chicken>",
"[FIND] <pot>",
"[GRAB] <pot>",
"[FIND] <oven>",
"[PUTBACK] <pot> <oven>",
"[PUTBACK] <food_chicken> <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'tvstand', 'dish_soap', 'wall', 'pasta', 'coffee_filter', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'scrabble']
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>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[SWITCHON] <faucet>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[GRAB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'chair', 'walllamp', 'blow_dryer', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'ceiling', 'thread', 'ceilinglamp', 'laptop', 'faucet', 'mousepad', 'couch', 'candle', 'food_jam', 'pillow', 'wall', 'nightstand', 'tape', 'television', 'tray', 'after_shave', 'food_onion', 'shoes', 'cupboard']
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>"
]
} |
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', 'band-aids', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'stamp', 'desk', 'cleaning_solution', 'computer', 'stovefan', 'deck_of_cards', 'faucet', 'tvstand', 'window', 'couch', 'wall', 'nightstand', 'coffe_maker', 'television', 'mirror', 'after_shave', 'paper_towel', 'clothes_dress', 'sink', 'bag', 'bathroom_cabinet', 'dishwasher', 'laser_pointer']
Task:Clean mirror
response:
{
"thoughts": First spray the mirrors with Windex or window type spray. Take paper towels and wipe until sparkly clean. If they have streaks, repeat the process.,
"actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[FIND] <cleaning_solution>', '[RINSE] <cleaning_solution>', '[WIPE] <mirror>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'chair', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'bedroom', 'button', 'plate', 'dish_soap', 'wall', 'nightstand', 'food_cheese', 'photoframe', 'newspaper', 'coffe_maker', 'check', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'door', 'table', 'dishwasher', 'light']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes",
"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>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <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:['sponge', 'spectacles', 'microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'character', 'desk', 'alcohol', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'photoframe', 'light_bulb', 'television', 'curtain', 'kettle', 'napkin', 'bathroom_cabinet', 'table', 'creditcard']
Task:Relax on sofa
response:
{
"thoughts": walk to living room, walk to sofa, sit on sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['spectacles', 'food_salt', 'microwave', 'walllamp', 'dough', 'hanger', 'ceiling', 'phone', 'character', 'keyboard', 'bookmark', 'toaster', 'mat', 'tvstand', 'stereo', 'window', 'oil', 'food_peanut_butter', 'tape', 'check', 'video_game_controller', 'razor', 'oven_mitts', 'food_rice', 'curtain', 'kitchen_counter', 'hairbrush', 'food_steak', 'bathroom_cabinet', 'home_office']
Task:Listen to music
response:
| {
"thoughts": "I walk into the bedroom. I walk to stereo. I turn on stereo.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <stereo>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'stereo', 'shower', 'mousepad', 'closetdrawer', 'dustpan', 'wall', 'powersocket', 'box', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'light', 'table', 'printing_paper']
Task:Print out papers
response:
{
"thoughts": Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.,
"actions": ['[WALK] <home_office>', '[WALK] <fax_machine>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[PUTBACK] <printing_paper> <fax_machine>', '[FIND] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <printing_paper>']
}
|
Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'blender', 'beer', 'toilet', 'jelly', 'freezer', 'blow_dryer', 'detergent', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'mail', 'computer', 'bookmark', 'stereo', 'window', 'couch', 'microphone', 'check', 'television', 'rag', 'pencil', 'controller', 'dishwasher']
Task:Pet cat
response:
| {
"thoughts": "Pet Cat",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[WALK] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'bathroom', 'knife', 'bathroom_counter', 'floor', 'shampoo', 'ceiling', 'stovefan', 'mat', 'faucet', 'mousepad', 'couch', 'food_peanut_butter', 'dustpan', 'towel', 'wall', 'wall_clock', 'oven', 'novel', 'ice', 'tray', 'rag', 'shoes', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'tooth_paste', 'hands_both']
Task:Wash hands
response:
{
"thoughts": I go to the sink, turn on the water, put soap on my hands, rub them together, then rinse them off and turn off the water. I then towel off my hands.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[WIPE] <hands_both>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'walllamp', 'detergent', 'orchid', 'floor', 'ceiling', 'keyboard', 'remote_control', 'computer', 'button', 'alcohol', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'check', 'mouthwash', 'television', 'coffe_maker', 'curtain', 'dresser', 'clothes_dress', 'door', 'sink', 'table']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'filing_cabinet', 'chair', 'walllamp', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'computer', 'ceilinglamp', 'deck_of_cards', 'stereo', 'window', 'couch', 'clothes_pants', 'wall', 'cup', 'novel', 'toilet_paper', 'television', 'wine', 'kitchen_counter', 'dishrack', 'comb', 'dresser', 'coffee_cup', 'table', 'teeth']
Task:Relax on sofa
response:
{
"thoughts": you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[DRINK] <coffee_cup>']
}
|
Scene_Objects:['tablelamp', 'beer', 'crayon', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'food_cake', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'food_food', 'television', 'curtain', 'pencil', 'kitchen_counter', 'door']
Task:Relax on sofa
response:
| {
"thoughts": "I walk to the sofa, and lie down on the sofa.",
"actions": [
"[WALK] <couch>",
"[LIE] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'mop', 'toilet', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'floor', 'ceiling', 'computer', 'clothes_jacket', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'food_food', 'mouthwash', 'television', 'food_donut', 'curtain', 'after_shave', 'dresser', '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>']
}
|
Scene_Objects:['tablelamp', 'juice', 'toilet', 'freezer', 'walllamp', 'detergent', 'milk', 'drawing', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'mat', 'ceilinglamp', 'shower', 'food_orange', 'pillow', 'dining_room', 'nightstand', 'wall', 'powersocket', 'photoframe', 'newspaper', 'food_food', 'toothbrush_holder', 'doorjamb', 'door', 'sink', 'light']
Task:Put groceries in Fridge
response:
| {
"thoughts": "I walk to the kitchen, open the fridge and put the groceries in the fridge. Then I close the fridge.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
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', 'food_ice_cream', 'walllamp', 'nail_polish', 'cat', 'orchid', 'drawing', 'floor', 'ceiling', 'purse', 'alcohol', 'mail', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'towel', 'wall', 'oven', 'cup', 'food_cheese', 'television', 'curtain', 'doorjamb', 'door', 'table', 'clothes_shirt']
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>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'orchid', 'knifeblock', 'wallshelf', 'character', 'keyboard', 'stovefan', 'mat', 'closetdrawer', 'dining_room', 'food_kiwi', 'box', 'cup', 'bed', 'coffe_maker', 'television', 'water', 'colander', 'tray', 'curtain', 'kitchen_counter', 'cd', 'cupboard', 'door', 'bag', 'soap', 'creditcard']
Task:Wash hands
response:
| {
"thoughts": "put soap on hands, scrub it and rinse with water",
"actions": [
"[WALK] <bathroom>",
"[WALK] <soap>",
"[FIND] <soap>",
"[SCRUB] <soap>",
"[FIND] <water>",
"[RINSE] <water>"
]
} |
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', 'chair', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'drawing', 'bathroom_counter', 'bedroom', 'keyboard', 'button', 'toaster', 'tvstand', 'food_noodles', 'pillow', 'check', 'television', 'oven_mitts', 'wine', 'curtain', 'rag', 'doorjamb', 'kettle', 'mouse', 'pencil', 'hairbrush', 'food_steak', 'home_office', 'dishwasher']
Task:Pet cat
response:
{
"thoughts": Find the cat; pet the cat by touching it,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['food_bread', 'microwave', 'toilet', 'walllamp', 'knifeblock', 'wallshelf', 'floor', 'shampoo', 'character', 'computer', 'bookmark', 'toaster', 'plate', 'faucet', 'shoe-shine_kit', 'dish_soap', 'wall', 'toy', 'light_bulb', 'coffe_maker', 'rag', 'kitchen_counter', 'hairbrush', 'cupboard', 'dresser', 'controller', 'sink', 'home_office', 'table', 'dishwasher']
Task:Wash dishes by hand
response:
| {
"thoughts": "Make some dish water, grab a dish rag, put dishes in dish water and wash.",
"actions": [
"[RUN] <sink>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[FIND] <plate>",
"[PUTBACK] <dish_soap> <plate>",
"[RINSE] <dish_soap>",
"[FIND] <plate>",
"[WASH] <plate>"
]
} |
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', 'ground_coffee', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'keyboard', 'mail', 'mat', 'faucet', 'wall', 'nightstand', 'powersocket', 'oven', 'cup', 'photoframe', 'bed', 'novel', 'curtain', 'doorjamb', 'diary', 'cupboard', 'door', 'sink', 'instrument_guitar']
Task:Read book
response:
{
"thoughts": Walk over to the bookshelf. Pick storybook off the shelf. Sit on bed. Open storybook and read out loud.,
"actions": ['[WALK] <bedroom>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[WALK] <bed>', '[SIT] <bed>', '[READ] <novel>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'food_ice_cream', 'jelly', 'bathroom', 'orchid', 'knifeblock', 'wallshelf', 'bathroom_counter', 'desk', 'keyboard', 'ceilinglamp', 'iron', 'stereo', 'closetdrawer', 'clothes_pants', 'food_jam', 'cup', 'photoframe', 'toothbrush_holder', 'tray', 'curtain', 'centerpiece', 'coffee_pot', 'kitchen_counter', 'door', 'spoon', 'dishwasher', 'clothes_shirt']
Task:Pick up phone
response:
| {
"thoughts": "Enter living room. Walk to telephone. Pick up from hook.",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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>']
}
|
Scene_Objects:['sheets', 'water_glass', 'pot', 'glue', 'filing_cabinet', 'knife', 'wallshelf', 'bathroom_counter', 'stamp', 'bedroom', 'keyboard', 'clothes_jacket', 'piano_bench', 'electric_shaver', 'food_jam', 'cutting_board', 'novel', 'check', 'coffee_filter', 'water', 'ice', 'curtain', 'food_onion', 'pencil', 'kitchen_counter', 'cd', 'headset', 'dresser', 'door', 'light']
Task:Drink
response:
| {
"thoughts": "Drinking a glass of water",
"actions": [
"[WALK] <dining_room>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[FIND] <water_glass>",
"[POUR] <water> <water_glass>",
"[FIND] <water_glass>",
"[GRAB] <water_glass>",
"[DRINK] <water_glass>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'food_bread', 'tablelamp', 'scissors', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'tvstand', 'faucet', 'dish_soap', 'bowl', 'wall', 'oven', 'cup', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'curtain', 'maindoor', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Using dishwasher to wash dishes,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['sheets', 'blender', 'food_salt', 'crayon', 'tea', 'cat', 'milk', 'knifeblock', 'hanger', 'shampoo', 'bedroom', 'bookshelf', 'computer', 'brush', 'stovefan', 'toaster', 'foundation', 'window', 'mousepad', 'clothes_pants', 'clothes_hat', 'tape', 'bed', 'coffe_maker', 'food_onion', 'after_shave', 'dresser', 'light', 'dishwasher', 'laser_pointer']
Task:Pet cat
response:
| {
"thoughts": "Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner.",
"actions": [
"[WALK] <home_office>",
"[WALK] <bedroom>",
"[WALK] <bedroom>",
"[WALK] <home_office>",
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[FIND] <brush>",
"[GRAB] <brush>"
]
} |
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', 'bathroom', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'keyboard', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'cupboard', 'door', 'light', 'table']
Task:Gaze out window
response:
{
"thoughts": Look at the yard from the window,
"actions": ['[WALK] <home_office>', '[WALK] <window>', '[FIND] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']
}
|
Scene_Objects:['fork', 'filing_cabinet', 'food_pizza', 'knifeblock', 'food_egg', 'hanger', 'phone', 'desk', 'tea_bag', 'purse', 'envelope', 'clothes_jacket', 'table_cloth', 'faucet', 'window', 'closetdrawer', 'clothes_pants', 'food_jam', 'wall', 'basket_for_clothes', 'bed', 'cd', 'comb', 'laundry_detergent', 'clothes_scarf', 'napkin', 'home_office', 'bathroom_cabinet', 'washing_machine', 'teeth']
Task:Wash clothes
response:
| {
"thoughts": "Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <washing_machine>",
"[FIND] <washing_machine>",
"[OPEN] <washing_machine>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[PUTBACK] <clothes_pants> <washing_machine>",
"[WALK] <laundry_detergent>",
"[FIND] <laundry_detergent>",
"[GRAB] <laundry_detergent>",
"[POUR] <laundry_detergent> <washing_machine>",
"[CLOSE] <washing_machine>",
"[PLUGIN] <washing_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:['sponge', 'pot', 'food_bread', 'tablelamp', 'scissors', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'tvstand', 'faucet', 'dish_soap', 'bowl', 'wall', 'oven', 'cup', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'curtain', 'maindoor', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Using dishwasher to wash dishes,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['toilet', 'chair', 'dog', 'ground_coffee', 'detergent', 'floor', 'ceiling', 'shampoo', 'envelope', 'clothes_jacket', 'piano_bench', 'ceilinglamp', 'mat', 'couch', 'dining_room', 'wall', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'coffee_pot', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'pajamas', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Make coffee
response:
| {
"thoughts": "Making Coffee",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[FIND] <water>",
"[GRAB] <water>",
"[OPEN] <coffe_maker>",
"[POUR] <water> <coffe_maker>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[FIND] <coffee_pot>",
"[GRAB] <coffee_pot>",
"[PUTBACK] <coffee_pot> <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:['food_bread', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'beer', 'crayon', 'chair', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'bedroom', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cup', 'bed', 'keys', 'food_food', 'television', 'food_onion', 'doorjamb', 'mouse', 'home_office']
Task:Lock door
response:
{
"thoughts": Turn the lock.,
"actions": ['[WALK] <bedroom>']
}
|
Scene_Objects:['fork', 'tablelamp', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'envelope', 'toaster', 'ceilinglamp', 'stereo', 'faucet', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'clothes_gloves', 'novel', 'check', 'video_game_controller', 'television', 'kitchen_counter', 'hairdryer', 'light', 'table']
Task:Relax on sofa
response:
| {
"thoughts": "Walk to the living room. Walk to the sofa and sit on the sofa.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'food_cake', 'mat', 'faucet', 'mousepad', 'couch', 'wall', 'oven', 'bench', 'toilet_paper', 'television', 'water', 'drinking_glass', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'table']
Task:Drink
response:
{
"thoughts": I go to the kitchen to get a glass from the cabinet. I turn on the faucet and fill up the glass. I take a drink.,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <drinking_glass> <sink>', '[FIND] <water>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>']
}
|
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'milk', 'orchid', 'drawing', 'knifeblock', 'floor', 'ceiling', 'folder', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'cup', 'bed', 'television', 'razor', 'toothbrush_holder', 'tray', 'curtain', 'dresser', 'laundry_detergent', 'table']
Task:Watch TV
response:
| {
"thoughts": "go to the living room to watch TV",
"actions": [
"[RUN] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[TURNTO] <television>",
"[POINTAT] <television>",
"[TOUCH] <remote_control>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[WATCH] <television>",
"[DROP] <remote_control>",
"[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:['sheets', 'filing_cabinet', 'food_pizza', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'bathroom_counter', 'shampoo', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'faucet', 'couch', 'dining_room', 'cup', 'bed', 'tray', 'curtain', 'wooden_spoon', 'pencil', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'table']
Task:Pick up phone
response:
{
"thoughts": I walk to the home office. I find the telephone. I pick up the telephone handset.,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['dry_pasta', 'tablelamp', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'oil', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'bed', 'coffe_maker', 'television', 'curtain', 'dresser', 'door', 'instrument_guitar', 'table']
Task:Watch TV
response:
| {
"thoughts": "I go to the living room, switch on the tv, take the remote and sit on the sofa.",
"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:['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>']
}
|
Scene_Objects:['chair', 'detergent', 'food_butter', 'clothes_underwear', 'hanger', 'floor', 'stamp', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'shoe-shine_kit', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_pants', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'vacuum_cleaner', 'laundry_detergent', 'clothes_dress', 'bathroom_cabinet', 'light', 'dishwasher', 'clothes_shirt', 'washing_machine', 'creditcard']
Task:Wash clothes
response:
| {
"thoughts": "I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <basket_for_clothes>",
"[FIND] <basket_for_clothes>",
"[GRAB] <basket_for_clothes>",
"[WALK] <washing_machine>",
"[DROP] <basket_for_clothes>",
"[OPEN] <washing_machine>",
"[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>",
"[FIND] <laundry_detergent>",
"[GRAB] <laundry_detergent>",
"[PUTBACK] <laundry_detergent> <washing_machine>",
"[GRAB] <laundry_detergent>",
"[PUTOBJBACK] <laundry_detergent>",
"[CLOSE] <washing_machine>",
"[SWITCHON] <washing_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:['filing_cabinet', 'food_ice_cream', 'chair', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'mousepad', 'couch', 'towel', 'wall', 'bed', 'photoframe', 'curtain', 'after_shave', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both', 'shoe_rack']
Task:Wash hands
response:
{
"thoughts": Wash hands with soap and hot water,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['juice', 'microwave', 'toilet', 'ground_coffee', 'bathroom', 'cpuscreen', 'hanger', 'floor', 'phone', 'character', 'bookshelf', 'computer', 'table_cloth', 'mat', 'tvstand', 'shower', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'novel', 'food_food', 'video_game_controller', 'check', 'food_onion', 'doorjamb', 'napkin', 'home_office', 'coffee']
Task:Listen to music
response:
| {
"thoughts": "I walk into the living room. I find the stereo and turn it on, and I listen to the music.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'alcohol', 'toaster', 'tvstand', 'shower', 'closetdrawer', 'nightstand', 'wall_clock', 'bench', 'powersocket', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'sink', 'home_office', 'table', 'light', 'coffee']
Task:Walk through
response:
{
"thoughts": Walk through the hallway.,
"actions": ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'microwave', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'keyboard', 'food_cake', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'oil', 'tooth_paste', 'couch', 'closetdrawer', 'dining_room', 'toy', 'basket_for_clothes', 'light_bulb', 'check', 'centerpiece', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'light', 'board_game']
Task:Brush teeth
response:
| {
"thoughts": "EARLY MORNING AND BEFORE GOING TO BED",
"actions": [
"[WALK] <bathroom>",
"[WALK] <tooth_paste>",
"[FIND] <tooth_paste>",
"[GRAB] <tooth_paste>",
"[FIND] <toothbrush>",
"[GRAB] <toothbrush>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'crayon', 'tea', 'beer', 'microwave', 'toilet', 'trashcan', 'food_carrot', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'bedroom', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'bed', 'photoframe', 'doorjamb', 'dishrack', 'cupboard', 'sink', 'home_office']
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:['blender', 'toilet', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'faucet', 'mat', 'oil', 'food_peanut_butter', 'towel', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'sink', 'bathroom_cabinet', 'light', 'colander']
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>"
]
} |
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', 'toilet', 'freezer', 'band-aids', 'knifeblock', 'food_egg', 'shampoo', 'phone', 'bookshelf', 'purse', 'thread', 'deck_of_cards', 'shower', 'picture', 'clothes_socks', 'oven', 'food_cheese', 'novel', 'food_food', 'check', 'coffe_maker', 'tray', 'after_shave', 'curtain', 'doorjamb', 'cupboard', 'controller', 'bag', 'table', 'scrabble']
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:['pot', 'filing_cabinet', 'freezer', 'walllamp', 'drawing', 'needle', 'orchid', 'floor', 'stamp', 'keyboard', 'plate', 'faucet', 'shower', 'dish_soap', 'oil', 'wall', 'keys', 'coffe_maker', 'coffee_filter', 'pencil', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'controller', 'pajamas', 'food_steak', 'spoon', 'light', 'dishwasher']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[WALK] <dishwasher>",
"[OPEN] <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <spoon>",
"[GRAB] <spoon>",
"[PUTBACK] <spoon> <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
Subsets and Splits