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:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'computer', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'clothes_socks', 'closetdrawer', 'couch', 'pillow', 'towel', 'wall', 'powersocket', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet']
Task:Watch TV
response:
{
"thoughts": Sit on the couch and use the remote control to turn on the TV,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['food_bread', 'toilet', 'jelly', 'walllamp', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'stereo', 'electric_shaver', 'microphone', 'wall', 'pasta', 'powersocket', 'oven', 'bed', 'television', 'doorjamb', 'mouse', 'hair', 'door', 'table', 'colander', 'instrument_violin']
Task:Change TV channel
response:
| {
"thoughts": "first i will go to living room and then take the remote and swtitch on television after that il change the channel",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <remote_control>",
"[TURNTO] <remote_control>",
"[POINTAT] <remote_control>",
"[TOUCH] <remote_control>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'comb', 'door', 'light']
Task:Read book
response:
{
"thoughts": Find book, grab book, fin bookmark, sit down somewhere comfortable, open book, read book, close book after reading.,
"actions": ['[WALK] <desk>', '[FIND] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[FIND] <couch>', '[SIT] <couch>', '[GRAB] <novel>', '[READ] <novel>', '[PUTBACK] <bookmark> <novel>']
}
|
Scene_Objects:['freezer', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bedroom', 'keyboard', 'food_cake', 'computer', 'button', 'ceilinglamp', 'mousepad', 'wall', 'nightstand', 'powersocket', 'cup', 'food_food', 'check', 'doorjamb', 'lighter', 'mouse', 'shoes', 'dishrack', 'controller', 'door', 'light', 'scrabble']
Task:Put groceries in Fridge
response:
| {
"thoughts": "put away groceries in fridge. open the door, put on shelf, close the door.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'food_salt', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'mousepad', 'microphone', 'dining_room', 'nightstand', 'basket_for_clothes', 'bed', 'newspaper', 'coffe_maker', 'check', 'tray', 'curtain', 'doorjamb', 'mouse', 'headset', 'laundry_detergent', 'maindoor', 'bathroom_cabinet', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": Walk to laundry room. Find laundry basket. Grab laundry basket. Find washing machine. Walk to washing machine. Open washing machine. Find detergent. Grab detergent. Put in detergent. Put in clothes. Close washing machine. Turn on machine.,
"actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[PUTOBJBACK] <laundry_detergent>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['filing_cabinet', 'knifeblock', 'bills', 'bathroom_counter', 'ceiling', 'character', 'desk', 'bedroom', 'computer', 'bookmark', 'shoe-shine_kit', 'pillow', 'towel', 'pasta', 'oven', 'powersocket', 'toy', 'cup', 'photoframe', 'light_bulb', 'television', 'kitchen_counter', 'chessboard', 'comb', 'pajamas', 'food_steak', 'sink', 'instrument_violin', 'bag', 'tooth_paste']
Task:Pick up phone
response:
| {
"thoughts": "Walk into the home office. Pick up the 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', 'microwave', 'walllamp', 'knifeblock', 'orchid', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'food_bacon', 'stovefan', 'toaster', 'plate', 'faucet', 'window', 'homework', 'closetdrawer', 'wall', 'oven', 'ice', 'tray', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'hairdryer', 'sink', 'bathroom_cabinet', 'coffee']
Task:Wash dishes by hand
response:
{
"thoughts": Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry.,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[TURNTO] <plate>', '[LOOKAT] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WASH] <plate>', '[PUTBACK] <plate> <kitchen_counter>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[OPEN] <dishwasher>",
"[WALK] <kitchen_counter>",
"[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:['microwave', 'freezer', 'walllamp', 'blow_dryer', 'milk', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'food_cake', 'alcohol', 'stovefan', 'homework', 'closetdrawer', 'pillow', 'broom', 'wall', 'oven', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'kitchen_counter', 'shoes', 'sink', 'light', 'table']
Task:Drink
response:
{
"thoughts": Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']
}
|
Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'iron', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'video_game_controller', 'television', 'doorjamb', 'kettle', 'mouse', 'door', 'table']
Task:Browse internet
response:
| {
"thoughts": "Walk to home office. Walk to computer. Switch on Computer.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[SWITCHON] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'toilet', 'blow_dryer', 'bathroom', 'trashcan', 'orchid', 'dvd_player', 'keyboard', 'mail', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'picture', 'window', 'couch', 'clothes_pants', 'oven', 'photoframe', 'coffe_maker', 'food_food', 'television', 'food_onion', 'coffee_pot', 'sink', 'bathroom_cabinet', 'light', 'dishwasher', 'vase']
Task:Wash dishes with dishwasher
response:
{
"thoughts": grab the vesseles and wash,
"actions": ['[WALK] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dining_room>', '[WASH] <bowl>', '[WALK] <detergent>', '[FIND] <detergent>', '[RINSE] <detergent>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'trashcan', 'floor', 'tea_bag', 'thread', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'wall', 'bed', 'coffe_maker', 'food_food', 'check', 'oven_mitts', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'hairbrush', 'cupboard', 'hair', 'controller', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'faucet', 'shower', 'tooth_paste', 'towel', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'clothes_gloves', 'light_bulb', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'vase', 'soap', 'home_office', 'hands_both']
Task:Wash hands
response:
{
"thoughts": I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']
}
|
Scene_Objects:['tablelamp', 'chair', 'dough', 'bills', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'shampoo', 'bookshelf', 'computer', 'mat', 'window', 'food_noodles', 'bowl', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'cup', 'bed', 'toilet_paper', 'mouthwash', 'ice', 'doorjamb', 'vacuum_cleaner', 'dishrack', 'door', 'napkin', 'home_office']
Task:Go to sleep
response:
| {
"thoughts": "Walk to bedroom. Walk to bed, lie in bed.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <bed>",
"[LIE] <bed>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'band-aids', 'freezer', 'nail_polish', 'bathroom', 'cat', 'orchid', 'cpuscreen', 'phone', 'character', 'keyboard', 'mat', 'faucet', 'wall', 'oven', 'bed', 'keys', 'coffe_maker', 'mouthwash', 'food_onion', 'curtain', 'centerpiece', 'console', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'home_office']
Task:Pet cat
response:
{
"thoughts": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['food_pizza', 'tea', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'phone', 'keyboard', 'food_cake', 'toaster', 'stovefan', 'plate', 'mat', 'dish_soap', 'oil', 'pillow', 'wall', 'cup', 'photoframe', 'coffe_maker', 'curtain', 'centerpiece', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'bathroom_cabinet', '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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'mop', 'dog', 'jelly', 'drawing', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'computer', 'stovefan', 'faucet', 'oil', 'dining_room', 'wall', 'nightstand', 'oven', 'cutting_board', 'photoframe', 'check', 'tray', 'sink', 'napkin', 'bathroom_cabinet', 'soap', 'dirt', 'hands_both']
Task:Wash hands
response:
{
"thoughts": go to the bathroom and wash your hands,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[SQUEEZE] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>']
}
|
Scene_Objects:['sheets', 'sponge', 'tablelamp', 'food_ice_cream', 'crayon', 'measuring_cup', 'toilet', 'knifeblock', 'orchid', 'bathroom_counter', 'dvd_player', 'keyboard', 'computer', 'stovefan', 'mat', 'toaster', 'picture', 'window', 'microphone', 'pillow', 'bench', 'toy', 'novel', 'tray', 'curtain', 'chessboard', 'controller', 'conditioner', 'sink', 'dishwasher']
Task:Pet cat
response:
| {
"thoughts": "Walk to living room. Find cat. Walk to cat. Pull cat.",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[WALK] <cat>",
"[PULL] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table']
Task:Watch TV
response:
{
"thoughts": Watching TV,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['pot', 'band-aids', 'detergent', 'cat', 'knife', 'bathroom_counter', 'shampoo', 'floor', 'character', 'computer', 'bookmark', 'stovefan', 'mousepad', 'form', 'pillow', 'wall', 'pasta', 'oven', 'cup', 'keys', 'coffe_maker', 'television', 'food_onion', 'curtain', 'centerpiece', 'dishrack', 'sink', 'light', 'clothes_skirt', 'scrabble']
Task:Pick up phone
response:
| {
"thoughts": "walk into living room, look at the phone when it ringing, grab the phone or pickup the phone",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>",
"[TURNTO] <phone>",
"[LOOKAT] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'measuring_cup', 'walllamp', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'face', 'computer', 'bookmark', 'mat', 'faucet', 'mousepad', 'clothes_hat', 'towel', 'dining_room', 'wall', 'wall_clock', 'nightstand', 'face_soap', 'basket_for_clothes', 'newspaper', 'tray', 'rag', 'mouse', 'dishrack', 'sink', 'bathroom_cabinet']
Task:Wash face
response:
{
"thoughts": Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <rag>', '[GRAB] <rag>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[WASH] <rag>', '[FIND] <face_soap>', '[GRAB] <face_soap>', '[POUR] <face_soap> <rag>', '[PUTOBJBACK] <face_soap>', '[FIND] <face>', '[SCRUB] <face>', '[PUTBACK] <rag> <sink>', '[RINSE] <face>', '[RINSE] <rag>', '[SWITCHOFF] <faucet>', '[GRAB] <rag>', '[PUTOBJBACK] <rag>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'ground_coffee', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'stovefan', 'mousepad', 'oil', 'wall', 'bed', 'mouse', 'cupboard', 'door', 'hairdryer', 'table']
Task:Work
response:
| {
"thoughts": "Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[FIND] <mouse>",
"[PUSH] <mouse>",
"[SWITCHOFF] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'food_pizza', 'filing_cabinet', 'beer', 'measuring_cup', 'chair', 'ground_coffee', 'knifeblock', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mail', 'toaster', 'picture', 'dustpan', 'wall', 'bench', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'after_shave', 'dresser', 'maindoor', '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>']
}
|
Scene_Objects:['toilet', 'freezer', 'walllamp', 'cat', 'drawing', 'orchid', 'knifeblock', 'knife', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'coffe_maker', 'check', 'curtain', 'lighter', 'dresser', 'napkin', 'home_office', 'table', 'coffee']
Task:Pet cat
response:
| {
"thoughts": "Walk into bedrrom and to the sofa. Sit on the sofa and touch cat.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[SIT] <couch>",
"[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:['filing_cabinet', 'crayon', 'walllamp', 'woman', 'knifeblock', 'hanger', 'ceiling', 'folder', 'character', 'man', 'mop_bucket', 'bookmark', 'shower', 'window', 'electric_shaver', 'pillow', 'dining_room', 'wall_clock', 'cutting_board', 'bed', 'television', 'wine', 'curtain', 'mouse', 'pencil', 'sink', 'home_office', 'light', 'dirt', 'shoe_rack']
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>']
}
|
Scene_Objects:['pot', 'tablelamp', 'beer', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mousepad', 'food_jam', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'food_onion', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'dresser', 'door', 'table', 'light', 'dishwasher']
Task:Work
response:
| {
"thoughts": "I walk to the bedroom, then find the computer and sit in the chair ,next switch on the computer and finally type in the keyboard to start to work on it",
"actions": [
"[WALK] <bedroom>",
"[WALK] <computer>",
"[FIND] <computer>",
"[FIND] <chair>",
"[SIT] <chair>",
"[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:['sheets', 'chair', 'nail_polish', 'knife', 'cpuscreen', 'floor', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'mousepad', 'closetdrawer', 'couch', 'dining_room', 'wall', 'basket_for_clothes', 'cup', 'check', 'television', 'curtain', 'mouse', 'chessboard', 'shoes', 'comb', 'cupboard', 'hairdryer', 'door', 'home_office']
Task:Read book
response:
{
"thoughts": find a book to read. sit down. read the book.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']
}
|
Scene_Objects:['microwave', 'toilet', 'ground_coffee', 'walllamp', 'trashcan', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'toaster', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'photoframe', 'clothes_gloves', 'coffe_maker', 'coffee_filter', 'centerpiece', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'clothes_scarf', 'home_office', 'table', 'dishwasher']
Task:Make coffee
response:
| {
"thoughts": "Open the coffee maker and put a filer, grab ground coffee and put it in the coffee maker, then close the coffee maker and switch it on",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[OPEN] <coffe_maker>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[FIND] <ground_coffee>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[CLOSE] <coffe_maker>",
"[SWITCHON] <coffe_maker>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'fork', 'beer', 'walllamp', 'bathroom', 'orchid', 'kitchen_cabinet', 'floor', 'phone', 'toaster', 'mat', 'plate', 'tvstand', 'window', 'dish_soap', 'couch', 'bowl', 'wall', 'oven', 'bench', 'coffe_maker', 'tray', 'rag', 'console', 'kitchen_counter', 'dishrack', 'hair', 'maindoor', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet..,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>', '[GRAB] <plate>', '[WIPE] <plate>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[PUTOBJBACK] <dishrack>']
}
|
Scene_Objects:['tablelamp', 'measuring_cup', 'dog', 'freezer', 'walllamp', 'trashcan', 'drawing', 'bills', 'floor', 'ceiling', 'bookshelf', 'computer', 'button', 'tvstand', 'stereo', 'wall', 'nightstand', 'bench', 'bed', 'photoframe', 'television', 'razor', 'food_rice', 'wine', 'tray', 'comb', 'sink', 'bathroom_cabinet', 'light', 'dirt']
Task:Listen to music
response:
| {
"thoughts": "I go into my bedroom and see my stereo. I decide to play music. I walk over to the stereo and turn it on. I sit down on the bed to listen to the music.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[TURNTO] <stereo>",
"[LOOKAT] <stereo>",
"[SWITCHON] <stereo>",
"[FIND] <bed>",
"[SIT] <bed>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'tablelamp', 'chair', 'freezer', 'detergent', 'bathroom_counter', 'desk', 'bedroom', 'keyboard', 'button', 'stovefan', 'ceilinglamp', 'stereo', 'shower', 'window', 'clothes_socks', 'dining_room', 'nightstand', 'wall', 'bench', 'oven', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'dresser', 'napkin', 'bathroom_cabinet', 'soap']
Task:Listen to music
response:
{
"thoughts": Walk into living room, look for radio, grab on button,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'microwave', 'chair', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'drawing', 'knife', 'floor', 'ceiling', 'thread', 'toaster', 'dustpan', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'chessboard', 'cupboard', 'spoon', 'light', 'dishwasher']
Task:Make coffee
response:
| {
"thoughts": "Walk to kitchen. Find coffee maker. Find coffee filter. Put it in the coffee maker. Find ground coffee. Put it in the coffee maker. Find Water. Put it in the coffe maker. Switch on the coffee maker.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[OPEN] <coffe_maker>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[FIND] <water>",
"[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:['pot', 'food_ice_cream', 'bathroom', 'detergent', 'cat', 'food_butter', 'toothbrush', 'orchid', 'cpuscreen', 'desk', 'bedroom', 'purse', 'envelope', 'mail', 'mop_bucket', 'toaster', 'shower', 'faucet', 'oil', 'food_orange', 'powersocket', 'cutting_board', 'shelf', 'curtain', 'after_shave', 'diary', 'kitchen_counter', 'door', 'napkin', 'tooth_paste']
Task:Wash teeth
response:
{
"thoughts": before going to bed or when wake up earily morning brush teeth,
"actions": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']
}
|
Scene_Objects:['pot', 'scissors', 'toilet', 'chair', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'button', 'ceilinglamp', 'mat', 'foundation', 'mousepad', 'clothes_pants', 'wall', 'photoframe', 'television', 'mouse', 'kitchen_counter', 'headset', 'door', 'home_office', 'table']
Task:Work
response:
| {
"thoughts": "Go to home office and work on computer.",
"actions": [
"[RUN] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <keyboard>",
"[GRAB] <keyboard>",
"[TYPE] <keyboard>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[TOUCH] <mouse>",
"[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:['scissors', 'microwave', 'toilet', 'walllamp', 'drawing', 'bills', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'television', 'tray', 'curtain', 'towel_rack', 'pencil', 'kitchen_counter', 'bathtub', 'spoon', 'table']
Task:Watch TV
response:
{
"thoughts": Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'homework', 'couch', 'candle', 'pillow', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'table', 'light']
Task:Watch TV
response:
| {
"thoughts": "Walk into the living room. Sit down on the sofa. Pick up the remote control. Turn on the television with the remote control. Put down the remote control. Watch the television.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[PUTOBJBACK] <remote_control>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'walllamp', 'nail_polish', 'detergent', 'dough', 'drawing', 'food_egg', 'tea_bag', 'bookshelf', 'remote_control', 'alcohol', 'button', 'mop_bucket', 'table_cloth', 'stovefan', 'tvstand', 'shoe-shine_kit', 'shower', 'stereo', 'deck_of_cards', 'mousepad', 'powersocket', 'check', 'rag', 'towel_rack', 'pencil', 'conditioner', 'door', 'bathroom_cabinet', 'soap']
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>']
}
|
Scene_Objects:['filing_cabinet', 'beer', 'walllamp', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'purse', 'food_bacon', 'piano_bench', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'window', 'foundation', 'couch', 'pillow', 'wall', 'bench', 'check', 'wine', 'curtain', 'hairbrush', 'controller', 'door', 'bathroom_cabinet', 'table', 'creditcard']
Task:Relax on sofa
response:
| {
"thoughts": "Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. 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:['pot', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'dough', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'wall', 'powersocket', 'shelf', 'toilet_paper', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'light', 'table', 'vase']
Task:Vacuum
response:
{
"thoughts": Keep my keyboard vacuumed and free of debris.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']
}
|
Scene_Objects:['dry_pasta', 'scissors', 'chair', 'hanger', 'phone', 'keyboard', 'bookshelf', 'plate', 'faucet', 'window', 'mousepad', 'food_noodles', 'oil', 'food_peanut_butter', 'clothes_pants', 'dining_room', 'bench', 'oven', 'cutting_board', 'toy', 'basket_for_clothes', 'cup', 'photoframe', 'keys', 'food_food', 'laundry_detergent', 'bathroom_cabinet', 'instrument_violin', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
| {
"thoughts": "Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <washing_machine>",
"[FIND] <washing_machine>",
"[OPEN] <washing_machine>",
"[FIND] <basket_for_clothes>",
"[GRAB] <basket_for_clothes>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[PUTBACK] <clothes_pants> <washing_machine>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUTBACK] <clothes_shirt> <washing_machine>",
"[PUTOBJBACK] <basket_for_clothes>",
"[WALK] <laundry_detergent>",
"[FIND] <laundry_detergent>",
"[GRAB] <laundry_detergent>",
"[POUR] <laundry_detergent> <washing_machine>",
"[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:['sheets', 'filing_cabinet', 'walllamp', 'nail_polish', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'couch', 'microphone', 'pillow', 'wall', 'pasta', 'cup', 'photoframe', 'bed', 'novel', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'kitchen_counter', 'home_office']
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:['fork', 'tablelamp', 'crayon', 'drawing', 'needle', 'bills', 'knifeblock', 'floor', 'phone', 'ceiling', 'character', 'mat', 'plate', 'homework', 'pillow', 'bowl', 'bench', 'newspaper', 'novel', 'food_food', 'video_game_controller', 'television', 'oven_mitts', 'food_rice', 'coffee_pot', 'shoes', 'cd', 'home_office', 'table', 'teeth']
Task:Set up table
response:
| {
"thoughts": "I walk to the table. I put down the dish. I put down the silverware. I put down the napkin.",
"actions": [
"[WALK] <table>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[PUTBACK] <fork> <table>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[PUTBACK] <fork> <table>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[PUTBACK] <fork> <table>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[PUTBACK] <fork> <table>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[PUTBACK] <fork> <table>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <table>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <table>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <table>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <table>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['dry_pasta', 'measuring_cup', 'microwave', 'walllamp', 'food_carrot', 'orchid', 'knifeblock', 'cpuscreen', 'drawing', 'floor', 'bedroom', 'cleaning_solution', 'computer', 'mop_bucket', 'table_cloth', 'stovefan', 'shower', 'iron', 'couch', 'bowl', 'dining_room', 'nightstand', 'cup', 'keys', 'curtain', 'doorjamb', 'comb', 'dresser', 'sink', 'hands_both']
Task:Wash hands
response:
| {
"thoughts": "walk to bathroom , find cleaning solution , squeeze cleaning solution , wash hands",
"actions": [
"[WALK] <bathroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[SQUEEZE] <cleaning_solution>",
"[FIND] <hands_both>",
"[WASH] <hands_both>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'juice', 'chair', 'jelly', 'nail_polish', 'cat', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'iron', 'clothes_pants', 'food_kiwi', 'wall', 'photoframe', 'food_food', 'water', 'wooden_spoon', 'curtain', 'doorjamb', 'sink', 'bathroom_cabinet', 'teeth']
Task:Wash teeth
response:
{
"thoughts": Wash the teeth,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[TURNTO] <water>', '[POINTAT] <water>', '[FIND] <teeth>', '[WASH] <teeth>', '[SWITCHOFF] <faucet>']
}
|
Scene_Objects:['food_pizza', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'towel', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'pencil', 'door', 'home_office', 'table']
Task:Watch TV
response:
| {
"thoughts": "Walk to living room. Sit on the sofa. Grab the remote control and plug in TV.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[PLUGIN] <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', 'freezer', 'ground_coffee', 'bathroom', 'ceilingfan', 'drawing', 'clothes_underwear', 'floor', 'food_cake', 'toaster', 'mousepad', 'dining_room', 'oven', 'tape', 'box', 'photoframe', 'coin', 'curtain', 'shaving_cream', 'coffee_pot', 'headset', 'dishrack', 'cupboard', 'sink', 'clothes_scarf', 'home_office', 'dishwasher', 'soap', 'board_game', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on.,
"actions": ['[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['pot', 'scissors', 'food_salt', 'freezer', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'desk', 'bedroom', 'bookshelf', 'keyboard', 'clothes_jacket', 'toaster', 'stereo', 'electric_shaver', 'food_noodles', 'dining_room', 'broom', 'wall', 'oven', 'box', 'cup', 'curtain', 'shoes', 'vacuum_cleaner', 'sink', 'bag', 'dishwasher', 'creditcard']
Task:Pick up phone
response:
| {
"thoughts": "Walk to home office 1. Walk over to phone 1 on table 1. Grab phone 1. lift phone 1.",
"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:['chair', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'tvstand', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'oven', 'cup', 'standingmirror', 'check', 'television', 'centerpiece', 'console', 'mouse', 'vacuum_cleaner', 'shoes', 'comb', 'dresser', 'hairbrush', 'sink', 'bag', 'napkin', 'bathroom_cabinet', 'vase']
Task:vacuum carpet
response:
{
"thoughts": I bring my vacuum cleaner into the living room. I plug it into the wall. I press the on switch on the vacuum cleaner. I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet. I turn the vacuum cleaner off. I take the vacuum cleaner back to the hall closet.,
"actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']
}
|
Scene_Objects:['food_pizza', 'scissors', 'tea', 'freezer', 'blow_dryer', 'drawing', 'knifeblock', 'cpuscreen', 'clothes_underwear', 'character', 'desk', 'toaster', 'shower', 'picture', 'mousepad', 'candle', 'dining_room', 'bench', 'oven', 'basket_for_clothes', 'bed', 'check', 'television', 'toothbrush_holder', 'curtain', 'mouse', 'sink', 'light', 'tooth_paste', 'laser_pointer']
Task:Turn on light
response:
| {
"thoughts": "I walk into the living room and then I walk to the light switch in there and turn the lights on",
"actions": [
"[WALK] <home_office>",
"[WALK] <floor_lamp>",
"[SWITCHON] <floor_lamp>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'food_pizza', 'filing_cabinet', 'scissors', 'chair', 'ceilingfan', 'dough', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'coffee_table', 'television', 'coin', 'wooden_spoon', 'curtain', 'maindoor', 'table']
Task:Watch TV
response:
{
"thoughts": I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>']
}
|
Scene_Objects:['band-aids', 'walllamp', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'mail', 'bookmark', 'plate', 'faucet', 'picture', 'dish_soap', 'dustpan', 'wall', 'oven', 'bench', 'bed', 'food_food', 'curtain', 'doorjamb', 'kettle', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'cupboard', 'door', 'sink', 'dirt']
Task:Wash dishes by hand
response:
| {
"thoughts": "i go to the kitchen, i find the faucet. I turn the faucet on, i grab the plate to wash , i then get the soap. I wash the dishes by hand",
"actions": [
"[WALK] <dining_room>",
"[WALK] <faucet>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[FIND] <plate>",
"[GRAB] <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', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'envelope', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'check', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light']
Task:Work
response:
{
"thoughts": I go to the home office to work on my project. I turn on the light and walk to my desk. I turn on the computer. Then I look through the documents. After I'm done, I turn off the computer.,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[TURNTO] <check>', '[LOOKAT] <check>', '[SWITCHOFF] <computer>']
}
|
Scene_Objects:['toilet', 'blow_dryer', 'bathroom', 'walllamp', 'orchid', 'cpuscreen', 'dvd_player', 'character', 'desk', 'stamp', 'envelope', 'stovefan', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'homework', 'food_orange', 'dining_room', 'oven', 'bench', 'box', 'video_game_controller', 'television', 'food_donut', 'curtain', 'doorjamb', 'pajamas', 'napkin', 'light', 'clothes_shirt']
Task:Pet cat
response:
| {
"thoughts": "I enter the room where the cat is. I look for the cat. I find the cat. I walk over to the cat. I use my hand to pet the cat.",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <cat>",
"[FIND] <cat>",
"[WALK] <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:['glue', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'mat', 'mousepad', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'food_food', 'coffe_maker', 'doorjamb', 'pencil', 'kitchen_counter', 'cd', 'shoes', 'hair', 'clothes_dress', 'table']
Task:Set up table
response:
{
"thoughts": Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.,
"actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>']
}
|
Scene_Objects:['sponge', 'microwave', 'toilet', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'character', 'piano_bench', 'bookmark', 'toaster', 'mat', 'shower', 'dish_soap', 'couch', 'wall', 'photoframe', 'novel', 'coffe_maker', 'check', 'cards', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'sink', 'home_office', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "walk to kitchen, find the dishwasher, apply dish soap into vessels or dishwasher, wash the dishes with a dishwasher",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[OPEN] <dishwasher>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[WASH] <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:['filing_cabinet', 'microwave', 'freezer', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'keyboard', 'computer', 'toaster', 'tvstand', 'floor_lamp', 'window', 'closetdrawer', 'couch', 'towel', 'wall', 'wall_clock', 'food_food', 'doorjamb', 'mouse', 'headset', 'shoes', 'dresser', 'controller', 'bathtub', 'sink', 'home_office', 'light']
Task:Turn night light on
response:
{
"thoughts": I walk to the dresser and in the middle Io to small battery operated lamp and switch it on,
"actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <floor_lamp>', '[TURNTO] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}
|
Scene_Objects:['sheets', 'tablelamp', 'microwave', 'chair', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'mat', 'laptop', 'faucet', 'wall', 'box', 'photoframe', 'coffe_maker', 'colander', 'curtain', 'pencil', 'headset', 'dishrack', 'pajamas', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'clothes_shirt', 'hands_both']
Task:Wash hands
response:
| {
"thoughts": "I walk in to the bathroom. I find the soap. I find the faucet. I turn on the faucet. I wash my hands. I put the soap back. I rinse my hands. I turn the faucet off.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <faucet>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[FIND] <hands_both>",
"[WASH] <hands_both>",
"[PUTOBJBACK] <soap>",
"[RINSE] <hands_both>",
"[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:['food_pizza', 'filing_cabinet', 'crayon', 'walllamp', 'bathroom', 'toothbrush', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'faucet', 'electric_shaver', 'dish_soap', 'broom', 'wall', 'oven', 'bench', 'photoframe', 'light_bulb', 'novel', 'coffe_maker', 'television', 'tray', 'towel_rack', 'kettle', 'dishrack', 'table', 'dishwasher', 'tooth_paste']
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>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'walllamp', 'ground_coffee', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'stovefan', 'mousepad', 'oil', 'wall', 'bed', 'mouse', 'cupboard', 'door', 'hairdryer', 'table']
Task:Work
response:
{
"thoughts": Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[SWITCHOFF] <computer>']
}
|
Scene_Objects:['crayon', 'toilet', 'chair', 'bathroom', 'detergent', 'dough', 'knife', 'drawing', 'floor', 'ceiling', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'mousepad', 'clothes_socks', 'pillow', 'wall', 'cup', 'doorjamb', 'console', 'shoes', 'dresser', 'door', 'hairdryer', 'napkin', 'light', 'soap', 'laser_pointer']
Task:Turn on light
response:
| {
"thoughts": "Walk over to light switch. Turn on lights.",
"actions": [
"[WALK] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'food_bread', 'bathroom', 'trashcan', 'food_carrot', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'phone', 'folder', 'bedroom', 'desk', 'keyboard', 'toaster', 'bench', 'tray', 'doorjamb', 'diary', 'console', 'mouse', 'towel_rack', 'cd', 'dresser', 'cupboard', 'controller', 'conditioner', 'table', 'vase']
Task:Drink
response:
{
"thoughts": walk to kitchen, walk to table, grab water glass and drink water,
"actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>', '[PUTBACK] <water_glass> <table>']
}
|
Scene_Objects:['spectacles', 'blender', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'homework', 'mousepad', 'dining_room', 'food_kiwi', 'wall', 'powersocket', 'bench', 'oven', 'bed', 'food_food', 'doorjamb', 'mouse', 'controller', 'door', 'bathroom_cabinet', 'light', 'soap', 'clothes_shirt']
Task:Put groceries in Fridge
response:
| {
"thoughts": "Go to kitchen, open fridge, get groceries, put groceries in fridge, close fridge",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'microwave', 'trashcan', 'drawing', 'floor', 'dvd_player', 'desk', 'envelope', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'cup', 'check', 'television', 'coin', 'colander', 'after_shave', 'cd', 'cupboard', 'table', 'vase', 'soap']
Task:Relax on sofa
response:
{
"thoughts": Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['pot', 'crayon', 'chair', 'walllamp', 'detergent', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'pillow', 'wall', 'powersocket', 'newspaper', 'television', 'tray', 'doorjamb', 'mouse', 'pencil', 'door', 'light', 'table']
Task:Write an email
response:
| {
"thoughts": "I walk into my office and go to the computer desk. I sit at my desk and turn the computer on. Then I write an email.",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <desk>",
"[FIND] <chair>",
"[SIT] <chair>",
"[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:['filing_cabinet', 'walllamp', 'detergent', 'cat', 'milk', 'phone', 'ceiling', 'desk', 'mop_bucket', 'brush', 'ceilinglamp', 'tvstand', 'faucet', 'toaster', 'mat', 'closetdrawer', 'microphone', 'nightstand', 'wall_clock', 'toy', 'cup', 'food_food', 'after_shave', 'lighter', 'towel_rack', 'mouse', 'pajamas', 'controller', 'laundry_detergent', 'soap']
Task:Pet cat
response:
{
"thoughts": Go to the living room where the cat sleeps. Find cat. Proceed to petting cat.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['fork', 'water_glass', 'pot', 'measuring_cup', 'microwave', 'walllamp', 'blow_dryer', 'trashcan', 'knife', 'knifeblock', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'ceilinglamp', 'dish_soap', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'coffee_cup', 'dishwasher']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'filing_cabinet', 'tablelamp', 'juice', 'food_salt', 'microwave', 'chair', 'freezer', 'detergent', 'trashcan', 'toothbrush', 'floor', 'ceiling', 'bookshelf', 'toaster', 'shower', 'stereo', 'mousepad', 'clothes_pants', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'food_food', 'check', 'food_donut', 'kitchen_counter', 'cupboard', 'door', 'home_office']
Task:Cook some food
response:
{
"thoughts": Go kitchen and make something for eat,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>']
}
|
Scene_Objects:['water_glass', 'filing_cabinet', 'juice', 'milk', 'hanger', 'kitchen_cabinet', 'bathroom_counter', 'button', 'food_bacon', 'stovefan', 'mat', 'shoe-shine_kit', 'tvstand', 'electric_shaver', 'food_peanut_butter', 'form', 'dining_room', 'cutting_board', 'cup', 'photoframe', 'coffe_maker', 'television', 'water', 'wooden_spoon', 'kettle', 'kitchen_counter', 'chessboard', 'dresser', 'sink', 'spoon']
Task:Drink
response:
| {
"thoughts": "Go to kitchen. Open the the cabinet. Locate the water glass. Pour water into glass. Drag the bottle close to mouth. Drink water.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <water>",
"[GRAB] <water>",
"[FIND] <water_glass>",
"[POUR] <water> <water_glass>",
"[CLOSE] <kitchen_cabinet>",
"[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:['spectacles', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'button', 'clothes_jacket', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'bed', 'check', 'food_food', 'food_onion', 'dresser', 'light']
Task:Put on glasses
response:
{
"thoughts": Put on glasses.,
"actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[FIND] <spectacles>', '[GRAB] <spectacles>', '[PUTON] <spectacles>']
}
|
Scene_Objects:['fork', 'filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'wall', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'hair', 'clothes_dress', 'door', 'table', 'clothes_skirt', 'scrabble']
Task:Watch TV
response:
| {
"thoughts": "Walk into the living room/den. Turn on the television. Switch channels to find a program with remote. I find a program and look at the screen.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <remote_control>",
"[TURNTO] <remote_control>",
"[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:['pot', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'photoframe', 'novel', 'television', 'mouse', 'kitchen_counter', 'door', 'sink', 'clothes_skirt', 'clothes_shirt']
Task:Read book
response:
{
"thoughts": Go to home office, find the book. Sit in the chair and read the book.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}
|
Scene_Objects:['food_bread', 'walllamp', 'toothbrush', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'toaster', 'ceilinglamp', 'window', 'homework', 'food_noodles', 'couch', 'candle', 'pillow', 'dining_room', 'wall', 'powersocket', 'toy', 'food_food', 'toilet_paper', 'tray', 'curtain', 'food_onion', 'shoes', 'door', 'table']
Task:Relax on sofa
response:
| {
"thoughts": "Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[WALK] <couch>",
"[LIE] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'headset', 'dresser', 'door']
Task:Browse internet
response:
{
"thoughts": Browse the internet,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <chair>', '[LOOKAT] <chair>']
}
|
Scene_Objects:['tablelamp', 'food_salt', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'razor', 'television', 'food_rice', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathroom_cabinet', 'table', 'dirt']
Task:Work
response:
| {
"thoughts": "I go to my office. I switch the computer on and sit on the office chair. I look at the computer screen to see what needs to be done. I use my mouse to navigate to the relevant directory, then release it. I type code with my keyboard. When I'm done, I look at the computer again to evaluate what I've done. Then I switch off the computer using the mouse and put back the mouse.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <chair>",
"[SIT] <chair>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <mouse>",
"[GRAB] <mouse>",
"[PUTOBJBACK] <mouse>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[GRAB] <mouse>",
"[SWITCHOFF] <computer>",
"[PUTOBJBACK] <mouse>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'food_salt', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'mat', 'faucet', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'toothbrush_holder', 'wine', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'door', 'sink', 'clothes_scarf', 'light']
Task:Turn on light
response:
{
"thoughts": Walk into living room. Find wall. Find light button. Switch on light button.,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'microwave', 'chair', 'walllamp', 'cat', 'wallshelf', 'floor', 'character', 'desk', 'tea_bag', 'toaster', 'plate', 'couch', 'dining_room', 'box', 'newspaper', 'bed', 'toilet_paper', 'curtain', 'coffee_pot', 'mouse', 'kettle', 'cupboard', 'controller', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']
Task:Pet cat
response:
{
"thoughts": Find Cat in living room. Walk to cat. Pet cat.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['sponge', 'tablelamp', 'microwave', 'chair', 'walllamp', 'trashcan', 'food_butter', 'orchid', 'floor', 'dvd_player', 'desk', 'toaster', 'tvstand', 'oil', 'wall', 'bench', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'razor', 'wooden_spoon', 'curtain', 'coffee_pot', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'spoon', 'dishwasher']
Task:Wash dishes by hand
response:
| {
"thoughts": "walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[FIND] <dishrack>",
"[FIND] <dishrack>",
"[GRAB] <dishrack>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[PUTBACK] <dishrack> <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:['food_pizza', 'beer', 'chair', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'dvd_player', 'stamp', 'bookshelf', 'toaster', 'ceilinglamp', 'faucet', 'homework', 'floor_lamp', 'window', 'food_orange', 'dining_room', 'nightstand', 'bench', 'food_cheese', 'television', 'doorjamb', 'lighter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer']
Task:Turn off light
response:
{
"thoughts": Walk to the lamp. Find the switch. Click the switch off.,
"actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[SWITCHOFF] <floor_lamp>']
}
|
Scene_Objects:['food_pizza', 'toilet', 'trashcan', 'food_carrot', 'food_egg', 'ceiling', 'folder', 'stamp', 'bookshelf', 'toaster', 'laptop', 'shower', 'food_noodles', 'couch', 'form', 'nightstand', 'powersocket', 'bench', 'toy', 'bed', 'keys', 'novel', 'doorjamb', 'hairbrush', 'cupboard', 'conditioner', 'spoon', 'bathroom_cabinet', 'table', 'board_game']
Task:Pick up phone
response:
| {
"thoughts": "Walk into the living room, walk over to phone, grab the phone, put it to your ear .",
"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:['dry_pasta', 'microwave', 'toilet', 'jelly', 'drawing', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'ceilinglamp', 'deck_of_cards', 'stereo', 'shower', 'window', 'couch', 'candle', 'microphone', 'wall', 'powersocket', 'box', 'photoframe', 'television', 'tray', 'towel_rack', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'home_office']
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:['filing_cabinet', 'trashcan', 'food_carrot', 'knifeblock', 'drawing', 'cpuscreen', 'clothes_underwear', 'floor', 'bedroom', 'alcohol', 'laptop', 'tvstand', 'stereo', 'faucet', 'mat', 'couch', 'clothes_hat', 'nightstand', 'bench', 'oven', 'toy', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'cupboard', 'home_office', 'bathroom_cabinet', 'dishwasher', 'board_game']
Task:Listen to music
response:
| {
"thoughts": "go to radio. run on radio.",
"actions": [
"[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', 'tablelamp', 'measuring_cup', 'walllamp', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'broom', 'wall', 'newspaper', 'light_bulb', 'novel', 'television', 'curtain', 'doorjamb', 'lighter', 'cupboard', 'table', 'light']
Task:Change TV channel
response:
{
"thoughts": Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['beer', 'bathroom', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'button', 'brush', 'mat', 'toaster', 'faucet', 'picture', 'iron', 'pillow', 'broom', 'wall', 'oven', 'keys', 'novel', 'coin', 'tray', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'soap', 'clothes_shirt', 'scrabble', 'hands_both']
Task:Wash hands
response:
| {
"thoughts": "Go to the bathroom and to the sink, turn the faucet on, push the bottle of soap onto your hands and scrub them. Then rinse your hands out and turn the faucet off.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <soap>",
"[PUSH] <soap>",
"[FIND] <hands_both>",
"[SCRUB] <hands_both>",
"[RINSE] <hands_both>",
"[SWITCHOFF] <faucet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'face', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'wall_clock', 'face_soap', 'food_food', 'coffe_maker', 'tray', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'shoe_rack']
Task:Wash face
response:
{
"thoughts": Run warm water. Cleanse my face with soap. Rinse my face with water.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <face_soap>', '[GRAB] <face_soap>', '[FIND] <face>', '[SCRUB] <face>', '[PUTOBJBACK] <face_soap>', '[WASH] <face>', '[RINSE] <face>', '[SWITCHOFF] <faucet>']
}
|
Scene_Objects:['chair', 'freezer', 'ground_coffee', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'bedroom', 'ceilinglamp', 'tvstand', 'stereo', 'food_orange', 'cup', 'bed', 'keys', 'novel', 'food_food', 'coffe_maker', 'mouthwash', 'coin', 'check', 'diary', 'coffee_pot', 'mouse', 'dresser', 'hair', 'table', 'light']
Task:Listen to music
response:
| {
"thoughts": "I go to my bedroom, and then I switch on the radio",
"actions": [
"[WALK] <bedroom>",
"[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:['dry_pasta', 'toilet', 'nail_polish', 'detergent', 'cat', 'trashcan', 'milk', 'knifeblock', 'phone', 'ceiling', 'desk', 'keyboard', 'mousepad', 'couch', 'pillow', 'bench', 'oven', 'cup', 'bed', 'light_bulb', 'food_food', 'lighter', 'kitchen_counter', 'hairbrush', 'dresser', 'laundry_detergent', 'table', 'clothes_skirt', 'tooth_paste', 'dirt']
Task:Pet cat
response:
{
"thoughts": Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <milk>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[TURNTO] <cat>', '[POINTAT] <cat>']
}
|
Scene_Objects:['spectacles', 'sponge', 'food_bread', 'blender', 'chair', 'walllamp', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'tvstand', 'window', 'mousepad', 'clothes_socks', 'wall', 'oven', 'cup', 'television', 'mouse', 'cupboard', 'door', 'home_office', 'table']
Task:Browse internet
response:
| {
"thoughts": "go to the office, turn computer on, open an browser or any application to open any website.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <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:['pot', 'filing_cabinet', 'band-aids', 'freezer', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'bookshelf', 'computer', 'tvstand', 'shower', 'homework', 'clothes_pants', 'bowl', 'nightstand', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'toilet_paper', 'coffe_maker', 'wine', 'tray', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet']
Task:Pet cat
response:
{
"thoughts": Find the cat. Pet the cat.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'freezer', 'cpuscreen', 'ceiling', 'desk', 'computer', 'button', 'piano_bench', 'mop_bucket', 'mat', 'stereo', 'food_noodles', 'mousepad', 'wall', 'bench', 'bed', 'novel', 'oven_mitts', 'curtain', 'doorjamb', 'centerpiece', 'kettle', 'cupboard', 'table', 'dishwasher', 'instrument_violin', 'laser_pointer']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "grab the vesseles and wash",
"actions": [
"[WALK] <dining_room>",
"[WALK] <bowl>",
"[FIND] <bowl>",
"[GRAB] <bowl>",
"[WALK] <dining_room>",
"[WASH] <bowl>",
"[WALK] <detergent>",
"[FIND] <detergent>",
"[RINSE] <detergent>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'mop', 'microwave', 'walllamp', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'iron', 'window', 'laptop', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'check', 'tray', 'rag', 'towel_rack', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet']
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>']
}
|
Scene_Objects:['tablelamp', 'tea', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'plate', 'mousepad', 'food_noodles', 'couch', 'closetdrawer', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'razor', 'television', 'shaving_cream', 'kitchen_counter', 'bathroom_cabinet', 'dishwasher', 'soap', 'teeth']
Task:Text friends while sitting on couch
response:
| {
"thoughts": "Text while sitting",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>",
"[GRAB] <phone>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TURNTO] <phone>",
"[LOOKAT] <phone>",
"[TOUCH] <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', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'knife', 'drawing', 'wallshelf', 'orchid', 'hanger', 'cpuscreen', 'floor', 'character', 'keyboard', 'purse', 'homework', 'mousepad', 'wall', 'pasta', 'bench', 'keys', 'television', 'wooden_spoon', 'towel_rack', 'kettle', 'kitchen_counter', 'hair', 'conditioner', 'home_office', 'table']
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:['pot', 'food_salt', 'microwave', 'toilet', 'dog', 'detergent', 'orchid', 'wallshelf', 'food_egg', 'cpuscreen', 'phone', 'stamp', 'bedroom', 'bookshelf', 'bookmark', 'shower', 'mousepad', 'food_jam', 'towel', 'pasta', 'bed', 'novel', 'food_food', 'curtain', 'centerpiece', 'shaving_cream', 'dresser', 'cupboard', 'table', 'creditcard']
Task:Walk through
response:
| {
"thoughts": "Walk through the entrance hall",
"actions": [
"[WALK] <home_office>",
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'fork', 'crayon', 'tea', 'toilet', 'bathroom', 'orchid', 'hanger', 'floor', 'character', 'bedroom', 'tea_bag', 'keyboard', 'purse', 'toaster', 'mat', 'deck_of_cards', 'window', 'food_orange', 'pillow', 'photoframe', 'food_food', 'coffe_maker', 'food_donut', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'sink']
Task:Open door
response:
{
"thoughts": Open the door when leaving or coming in.,
"actions": ['[WALK] <home_office>']
}
|
Scene_Objects:['sponge', 'microwave', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'window', 'dish_soap', 'food_noodles', 'closetdrawer', 'couch', 'towel', 'dining_room', 'wall', 'wine', 'rag', 'shaving_cream', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'conditioner', 'sink', 'table', 'dishwasher', 'soap']
Task:Wash dishes
response:
| {
"thoughts": "Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[FIND] <sponge>",
"[GRAB] <sponge>",
"[POUR] <dish_soap> <sponge>",
"[PUTOBJBACK] <dish_soap>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[SCRUB] <plate>",
"[WASH] <plate>",
"[RINSE] <plate>",
"[RINSE] <sponge>",
"[SWITCHOFF] <faucet>",
"[PUTOBJBACK] <sponge>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[WIPE] <plate>",
"[PUTOBJBACK] <towel>",
"[WALK] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[PUTIN] <plate> <kitchen_cabinet>",
"[CLOSE] <kitchen_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'tablelamp', 'microwave', 'freezer', 'ground_coffee', 'walllamp', 'bathroom', 'trashcan', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'stovefan', 'homework', 'wall', 'novel', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'after_shave', 'diary', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'food_steak', 'dishwasher']
Task:Make coffee
response:
{
"thoughts": Walk to kitchen, open coffee maker, find coffee filter, grab coffee filter, put coffee filter in coffee maker, find ground coffee, put ground coffee in coffee maker, pour water in coffee maker, close coffee maker and switch 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>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['dry_pasta', 'microwave', 'freezer', 'walllamp', 'detergent', 'dough', 'floor', 'phone', 'ceiling', 'tea_bag', 'bookshelf', 'keyboard', 'toaster', 'laptop', 'tvstand', 'faucet', 'mousepad', 'dining_room', 'wall', 'box', 'cup', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'dishwasher']
Task:Make popcorn
response:
| {
"thoughts": "Lay popcorn bag flat inside microwave and press popcorn button to start.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <microwave>",
"[TURNTO] <microwave>",
"[OPEN] <microwave>",
"[PUTIN] <food_food> <microwave>",
"[CLOSE] <microwave>",
"[SWITCHON] <microwave>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'bathroom', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'envelope', 'computer', 'mop_bucket', 'stovefan', 'mat', 'tvstand', 'toaster', 'foundation', 'mousepad', 'pillow', 'wall', 'standingmirror', 'photoframe', 'toilet_paper', 'oven_mitts', 'tray', 'mouse', 'sink']
Task:Read book
response:
{
"thoughts": go to living room,find the text book on the self ,sat on the chair ,open and read the book,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}
|
Scene_Objects:['sheets', 'beer', 'toilet', 'chair', 'band-aids', 'walllamp', 'bathroom', 'detergent', 'bills', 'knife', 'knifeblock', 'hanger', 'bedroom', 'button', 'plate', 'tvstand', 'iron', 'window', 'food_noodles', 'candle', 'nightstand', 'child', 'check', 'food_food', 'toothbrush_holder', 'razor', 'food_donut', 'cupboard', 'home_office', 'bathroom_cabinet']
Task:Greet guests
response:
| {
"thoughts": "Say hi",
"actions": [
"[WALK] <home_office>",
"[WALK] <child>",
"[FIND] <child>",
"[GREET] <child>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'detergent', 'trashcan', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'closetdrawer', 'wall', 'oven', 'cup', 'novel', 'water', 'drinking_glass', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'door']
Task:Drink
response:
{
"thoughts": go to the kitchen,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'microwave', 'food_butter', 'drawing', 'knifeblock', 'floor', 'bedroom', 'envelope', 'stovefan', 'ceilinglamp', 'mat', 'balanceball', 'window', 'couch', 'clothes_hat', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'television', 'after_shave', 'cards', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'hairdryer', 'spoon', 'table', 'light']
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>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'wall', 'photoframe', 'newspaper', 'television', 'food_donut', 'food_rice', 'doorjamb', 'mouse', 'cd', 'dresser']
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:['dry_pasta', 'pot', 'fork', 'scissors', 'food_ice_cream', 'microwave', 'walllamp', 'knifeblock', 'knife', 'wallshelf', 'floor', 'ceiling', 'phone', 'alcohol', 'clothes_jacket', 'toaster', 'stovefan', 'faucet', 'couch', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'rag', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'colander']
Task:Clean
response:
| {
"thoughts": "Take out a rag. Turn on faucet and get water on the rag. Clean counter off.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[PUTBACK] <rag> <sink>",
"[SWITCHOFF] <faucet>",
"[GRAB] <rag>",
"[SQUEEZE] <rag>",
"[WALK] <kitchen_counter>",
"[WIPE] <kitchen_counter>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'trashcan', 'drawing', 'floor', 'character', 'desk', 'purse', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'couch', 'pillow', 'nightstand', 'powersocket', 'novel', 'tray', 'mouse', 'bathroom_cabinet', 'soap', 'teeth']
Task:Pet cat
response:
{
"thoughts": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'chair', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'laptop', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'tape', 'cup', 'photoframe', 'food_food', 'mouse', 'vacuum_cleaner', 'chessboard', 'napkin', 'table', 'soap']
Task:Work
response:
{
"thoughts": first ill go to my home office adn ill switch on my laptop and with the use of mouse and keyboard il run my computer,
"actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <mouse>', '[TOUCH] <mouse>', '[RUN] <laptop>']
}
|
Scene_Objects:['sheets', 'spectacles', 'walllamp', 'cat', 'drawing', 'needle', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'mat', 'ceilinglamp', 'faucet', 'stereo', 'towel', 'pillow', 'wall', 'tape', 'bed', 'toilet_paper', 'video_game_controller', 'television', 'food_food', 'tray', 'diary', 'console', 'sink', 'bathroom_cabinet', '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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'cd_player', 'chair', 'knifeblock', 'music_stand', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'envelope', 'food_bacon', 'mop_bucket', 'stovefan', 'ceilinglamp', 'shower', 'nightstand', 'bed', 'photoframe', 'coffe_maker', 'tray', 'curtain', 'lighter', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'bathroom_cabinet', 'light']
Task:Listen to music
response:
{
"thoughts": Walk to the living and turn to the music stand. Switch on the CD player to listen to music.,
"actions": ['[WALK] <home_office>', '[WALK] <music_stand>', '[FIND] <music_stand>', '[TURNTO] <music_stand>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']
}
|
Scene_Objects:['filing_cabinet', 'crayon', 'walllamp', 'dough', 'knife', 'needle', 'food_egg', 'knifeblock', 'phone', 'ceiling', 'desk', 'bookshelf', 'stovefan', 'stereo', 'oil', 'food_orange', 'dining_room', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'wooden_spoon', 'curtain', 'doorjamb', 'kitchen_counter', 'sink', 'napkin', 'bag', 'light', 'dishwasher']
Task:Walk through
response:
| {
"thoughts": "Walk through the hallway.",
"actions": [
"[WALK] <home_office>",
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'dog', 'chair', 'bathroom', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'mat', 'ceilinglamp', 'shower', 'candle', 'wall', 'bed', 'clothes_gloves', 'food_food', 'water', 'food_rice', 'wooden_spoon', 'curtain', 'console', 'dishrack', 'pajamas', 'light', 'clothes_skirt', 'soap', 'dirt']
Task:Take shower
response:
{
"thoughts": go to a bathroom, open the shower, let water wash your body,
"actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'microwave', 'toilet', 'jelly', 'freezer', 'walllamp', 'detergent', 'knifeblock', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'oil', 'wall', 'nightstand', 'oven', 'powersocket', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'dishwasher']
Task:Cook some food
response:
| {
"thoughts": "Cooking a meal",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <pot>",
"[GRAB] <pot>",
"[CLOSE] <kitchen_cabinet>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[PUTBACK] <pot> <sink>",
"[GRAB] <pot>",
"[SWITCHOFF] <faucet>",
"[WALK] <oven>",
"[PUTBACK] <pot> <oven>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[CLOSE] <freezer>",
"[WALK] <oven>",
"[PUTBACK] <food_food> <pot>",
"[SWITCHON] <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'food_salt', 'bathroom', 'drawing', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stereo', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'toothbrush_holder', 'wooden_spoon', 'doorjamb', 'shoes', 'dresser', 'door', 'light', 'coffee']
Task:Turn on light
response:
{
"thoughts": switching on the light,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'mop', 'walllamp', 'detergent', 'food_carrot', 'toothbrush', 'knifeblock', 'orchid', 'clothes_underwear', 'hanger', 'phone', 'stovefan', 'shower', 'homework', 'couch', 'food_jam', 'microphone', 'bowl', 'photoframe', 'check', 'curtain', 'console', 'mouse', 'pencil', 'dresser', 'sink', 'soap', 'creditcard']
Task:Pet dog
response:
| {
"thoughts": "Pet my dog in hall",
"actions": [
"[WALK] <home_office>",
"[WALK] <dog>",
"[TURNTO] <dog>",
"[LOOKAT] <dog>",
"[TOUCH] <dog>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'freezer', 'blow_dryer', 'bathroom', 'cpuscreen', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'food_bacon', 'tvstand', 'clothes_socks', 'oil', 'towel', 'nightstand', 'oven', 'bed', 'check', 'coffee_filter', 'curtain', 'clothes_dress', 'door', 'sink', 'home_office', 'table', 'light', 'colander', 'laser_pointer']
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:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'freezer', 'knife', 'floor', 'ceiling', 'folder', 'stamp', 'brush', 'mat', 'ceilinglamp', 'shower', 'faucet', 'toaster', 'pillow', 'bowl', 'food_kiwi', 'wall', 'powersocket', 'toilet_paper', 'mouthwash', 'doorjamb', 'door', 'home_office', 'light', 'table']
Task:Turn light off
response:
| {
"thoughts": "Put the light switch into the down, or off, position.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHOFF] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'detergent', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'purse', 'toaster', 'mat', 'faucet', 'iron', 'mousepad', 'wall', 'powersocket', 'cup', 'coffe_maker', 'water', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'clothes_scarf', 'colander']
Task:Drink
response:
{
"thoughts": I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it.,
"actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']
}
|
Scene_Objects:['sponge', 'tablelamp', 'measuring_cup', 'microwave', 'blow_dryer', 'bathroom', 'woman', 'knifeblock', 'clothes_underwear', 'phone', 'dvd_player', 'man', 'mail', 'toaster', 'iron', 'faucet', 'food_orange', 'child', 'powersocket', 'cup', 'food_cheese', 'check', 'tray', 'curtain', 'door', 'sink', 'home_office', 'dishwasher', 'clothes_skirt', 'tooth_paste']
Task:Say goodbye to guests leaving
response:
| {
"thoughts": "Tell them bye",
"actions": [
"[WALK] <home_office>",
"[WALK] <child>",
"[FIND] <child>",
"[TOUCH] <child>",
"[FIND] <man>",
"[TOUCH] <man>",
"[FIND] <woman>",
"[TOUCH] <woman>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'plate', 'faucet', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'powersocket', 'box', 'photoframe', 'novel', 'food_food', 'television', 'food_donut', 'curtain', 'doorjamb', 'bathroom_cabinet']
Task:Read book
response:
{
"thoughts": Sit on couch. Grab book. Open book. Read book.,
"actions": ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['fork', 'pot', 'toilet', 'chair', 'bathroom', 'drawing', 'knife', 'clothes_underwear', 'floor', 'mail', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'plate', 'deck_of_cards', 'toaster', 'oil', 'wall', 'wall_clock', 'oven', 'cup', 'novel', 'food_food', 'television', 'oven_mitts', 'cards', 'cupboard', 'conditioner', 'table']
Task:Eat dinner
response:
| {
"thoughts": "Sit down at the dinning table with my family and eat dinner.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <table>",
"[FIND] <chair>",
"[PULL] <chair>",
"[SIT] <chair>",
"[FIND] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <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:['microwave', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'faucet', 'shower', 'window', 'towel', 'wall', 'newspaper', 'curtain', 'towel_rack', 'pencil', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands.,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'envelope', 'mop_bucket', 'toaster', 'mat', 'faucet', 'dish_soap', 'couch', 'wall', 'cup', 'photoframe', 'toilet_paper', 'video_game_controller', 'wooden_spoon', 'tray', 'console', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'light']
Task:Wash dishes
response:
| {
"thoughts": "Place all of the dirty dishes in a sink full of clean, soapy water. Wash them. Rinse them in fresh, running water. Place them in the strainer to dry.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[SWITCHOFF] <faucet>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[POUR] <dish_soap> <sink>",
"[PUTOBJBACK] <dish_soap>",
"[FIND] <sponge>",
"[GRAB] <sponge>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[SCRUB] <cup>",
"[PUTOBJBACK] <cup>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[SCRUB] <cup>",
"[PUTOBJBACK] <cup>",
"[PUTBACK] <sponge> <sink>",
"[SWITCHON] <faucet>",
"[RINSE] <cup>",
"[GRAB] <cup>",
"[FIND] <dishrack>",
"[PUTBACK] <cup> <dishrack>",
"[RINSE] <cup>",
"[GRAB] <cup>",
"[PUTBACK] <cup> <dishrack>",
"[RINSE] <sponge>",
"[SWITCHOFF] <faucet>",
"[GRAB] <sponge>",
"[PUTOBJBACK] <sponge>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'trashcan', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'purse', 'mail', 'toaster', 'tvstand', 'faucet', 'towel', 'wall', 'nightstand', 'powersocket', 'food_food', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Turn faucet clockwise to turn on water. Place hands under stream of water, pick up soap, rub hands with soap. Put soap back down. Rub hands together with soap on them. Rinse hands under water from faucet. Turn faucet counterclockwise to turn water off. Dry hands by rubbing them on a towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[WASH] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['microwave', 'toilet', 'chair', 'jelly', 'ground_coffee', 'knifeblock', 'drawing', 'needle', 'food_egg', 'hanger', 'clothes_underwear', 'desk', 'purse', 'alcohol', 'mat', 'stereo', 'faucet', 'food_peanut_butter', 'wall', 'powersocket', 'photoframe', 'novel', 'coffe_maker', 'curtain', 'mouse', 'vacuum_cleaner', 'shoes', 'bathroom_cabinet', 'clothes_shirt', 'electrical_outlet']
Task:Vacuum
response:
| {
"thoughts": "Plug vacuum into the wall. Turn on the vacuum. Move vacuum around the floor to clean it. Unplug vacuum.",
"actions": [
"[WALK] <home_office>",
"[WALK] <vacuum_cleaner>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[FIND] <electrical_outlet>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[PUTOBJBACK] <vacuum_cleaner>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'filing_cabinet', 'pot', 'tablelamp', 'measuring_cup', 'freezer', 'walllamp', 'ceilingfan', 'knifeblock', 'drawing', 'longboard', 'floor', 'ceiling', 'keyboard', 'button', 'clothes_jacket', 'tvstand', 'couch', 'form', 'dining_room', 'bowl', 'nightstand', 'light_bulb', 'check', 'curtain', 'mouse', 'hair', 'cupboard', 'hairdryer', 'vase']
Task:Drink
response:
{
"thoughts": Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water 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:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'television', 'curtain', 'shaving_cream', 'dresser', 'home_office', 'table', 'bathroom_cabinet', 'shoe_rack']
Task:Watch TV
response:
| {
"thoughts": "Watch favorite shows, netflix, hulu",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[PUTBACK] <remote_control> <couch>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mop_bucket', 'mat', 'laptop', 'window', 'homework', 'mousepad', 'food_orange', 'dining_room', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'bed', 'tray', 'curtain', 'mouse', 'pencil', 'light']
Task:Watch movie
response:
{
"thoughts": Bring laptop to bed and watch a movie,
"actions": ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <bed>', '[SIT] <bed>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'character', 'video_game_console', 'bedroom', 'computer', 'button', 'table_cloth', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'box', 'video_game_controller', 'television', 'curtain', 'pencil', 'dresser', 'door', 'table']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'band-aids', 'dough', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'dvd_player', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'powersocket', 'cup', 'bed', 'photoframe', 'newspaper', 'water', 'food_donut', 'doorjamb', 'mouse', 'door', 'light', 'table', 'shoe_rack']
Task:Drink
response:
{
"thoughts": Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']
}
|
Scene_Objects:['sheets', 'filing_cabinet', 'food_salt', 'toilet', 'detergent', 'cpuscreen', 'food_egg', 'bathroom_counter', 'floor', 'folder', 'desk', 'envelope', 'clothes_jacket', 'mat', 'plate', 'stereo', 'deck_of_cards', 'shower', 'couch', 'television', 'oven_mitts', 'curtain', 'shaving_cream', 'chessboard', 'cupboard', 'conditioner', 'light', 'table', 'soap', 'clothes_shirt']
Task:Dust
response:
| {
"thoughts": "Get a broom or duster with long handle. Dust blades of ceiling fan.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <duster>",
"[FIND] <duster>",
"[GRAB] <duster>",
"[PUTOBJBACK] <duster>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'bookshelf', 'mat', 'mousepad', 'dining_room', 'wall', 'nightstand', 'bench', 'basket_for_clothes', 'bed', 'photoframe', 'coffe_maker', 'food_food', 'wooden_spoon', 'mouse', 'dresser', 'sink', 'dishwasher']
Task:Go to sleep
response:
{
"thoughts": go t the bedroom and go to sleep,
"actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>']
}
|
Scene_Objects:['tablelamp', 'blender', 'tea', 'toilet', 'chair', 'freezer', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'dvd_player', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'food_jam', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'cup', 'food_vegetable', 'photoframe', 'basket_for_clothes', 'doorjamb', 'mouse', 'door', 'table', 'light']
Task:Chop vegetables
response:
| {
"thoughts": "Cut up veggies with knife",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <knife>",
"[GRAB] <knife>",
"[FIND] <cutting_board>",
"[GRAB] <cutting_board>",
"[CLOSE] <kitchen_cabinet>",
"[WALK] <table>",
"[PUTBACK] <knife> <table>",
"[PUTBACK] <cutting_board> <table>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[CLOSE] <freezer>",
"[WALK] <table>",
"[PUTBACK] <food_vegetable> <cutting_board>",
"[GRAB] <knife>",
"[CUT] <food_vegetable>",
"[PUTOBJBACK] <knife>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'cat', 'drawing', 'hanger', 'longboard', 'floor', 'phone', 'character', 'desk', 'purse', 'stovefan', 'ceilinglamp', 'iron', 'stereo', 'window', 'oil', 'couch', 'wall', 'bench', 'toy', 'food_food', 'television', 'food_rice', 'towel_rack', 'console', 'hairbrush', 'napkin', 'table', 'vase', 'dirt']
Task:Pet cat
response:
{
"thoughts": I would walk into the living room. Then sit on the couch and pet the cat.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'detergent', 'milk', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'stamp', 'food_cake', 'computer', 'piano_bench', 'mat', 'tvstand', 'faucet', 'shower', 'couch', 'clothes_hat', 'pillow', 'wall', 'powersocket', 'toy', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'mouse', 'light']
Task:Relax on sofa
response:
{
"thoughts": I walk into the living room and I lie down on the sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'table_cloth', 'stovefan', 'laptop', 'tvstand', 'picture', 'window', 'homework', 'closetdrawer', 'couch', 'food_jam', 'wall', 'television', 'curtain', 'mouse', 'dresser', 'sink', 'instrument_guitar', 'dishwasher', 'laser_pointer']
Task:Open window
response:
| {
"thoughts": "Unlock the latch at the top. Push the bottom half of the window upwards.",
"actions": [
"[WALK] <home_office>",
"[WALK] <window>",
"[OPEN] <window>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'pot', 'food_pizza', 'tablelamp', 'microwave', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_bacon', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'food_food', 'television', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light']
Task:Cook some food
response:
{
"thoughts": go to the kitchen and cook some thing to eat,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <oven>', '[OPEN] <oven>', '[FIND] <food_pizza>', '[GRAB] <food_pizza>', '[PUTIN] <food_pizza> <oven>', '[SWITCHON] <oven>']
}
|
Scene_Objects:['pot', 'chair', 'drawing', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'mail', 'clothes_jacket', 'computer', 'ceilinglamp', 'plate', 'mat', 'picture', 'form', 'wall', 'bed', 'food_food', 'check', 'television', 'oven_mitts', 'diary', 'pencil', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'hairdryer', 'door', 'table', 'laser_pointer']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']
Task:Work
response:
{
"thoughts": I sit at my desk and work on the computer.,
"actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'chair', 'freezer', 'walllamp', 'bathroom', 'cpuscreen', 'floor', 'character', 'desk', 'folder', 'keyboard', 'computer', 'mail', 'bookmark', 'laptop', 'ceilinglamp', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'food_orange', 'pillow', 'wall', 'love_seat', 'bed', 'photoframe', 'mouse', 'electrical_outlet']
Task:Write book
response:
| {
"thoughts": "Writing a book",
"actions": [
"[WALK] <home_office>",
"[WALK] <laptop>",
"[FIND] <laptop>",
"[GRAB] <laptop>",
"[FIND] <electrical_outlet>",
"[PLUGIN] <laptop>",
"[WALK] <love_seat>",
"[SIT] <love_seat>",
"[SWITCHON] <laptop>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'sponge', 'scissors', 'microwave', 'ground_coffee', 'dough', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'tea_bag', 'food_cake', 'toaster', 'stovefan', 'tvstand', 'food_orange', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'coffe_maker', 'coffee_filter', 'hairbrush', 'napkin', 'bathroom_cabinet', 'home_office', 'dishwasher', 'vase']
Task:Make coffee
response:
{
"thoughts": Open the coffee maker and put a filer, grab ground coffee and put it in the coffee maker, then close the coffee maker and switch it on,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[FIND] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['glue', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'microwave', 'chair', 'dog', 'toothbrush', 'knifeblock', 'hanger', 'ceiling', 'bedroom', 'man', 'keyboard', 'ceilinglamp', 'stereo', 'shower', 'couch', 'food_jam', 'pillow', 'pasta', 'powersocket', 'coffe_maker', 'kettle', 'pencil', 'napkin', 'table', 'scrabble', 'creditcard']
Task:Greet guests
response:
| {
"thoughts": "When someone knocks I n the door walk through the hallway and greet them.",
"actions": [
"[RUN] <home_office>",
"[WALK] <man>",
"[FIND] <man>",
"[GREET] <man>",
"[FIND] <man>",
"[GREET] <man>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'toilet', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'envelope', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'stereo', 'mousepad', 'towel', 'wall', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'tray', 'curtain', 'doorjamb', 'dresser', 'controller', 'door', 'food_steak', 'light', 'tooth_paste']
Task:Take shower
response:
{
"thoughts": walk to bathroom , find shower , take a shower,
"actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>']
}
|
Scene_Objects:['pot', 'food_bread', 'juice', 'toilet', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'food_peanut_butter', 'food_jam', 'bowl', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'light', 'dishwasher', 'table']
Task:Grab some juice
response:
| {
"thoughts": "I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[CLOSE] <cupboard>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <juice>",
"[GRAB] <juice>",
"[POUR] <juice> <cup>",
"[PUTOBJBACK] <juice>",
"[CLOSE] <freezer>",
"[FIND] <table>",
"[PUTBACK] <cup> <table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'food_ice_cream', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'bookshelf', 'computer', 'faucet', 'balanceball', 'window', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'nightstand', 'bench', 'powersocket', 'basket_for_clothes', 'novel', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'maindoor', 'sink', 'hairdryer']
Task:Pick up phone
response:
{
"thoughts": Enter the Home office, then walk to the phone, pickup the phone.,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['sponge', 'scissors', 'juice', 'food_salt', 'walllamp', 'toothbrush', 'bathroom_counter', 'shampoo', 'character', 'stamp', 'bookshelf', 'computer', 'toaster', 'stovefan', 'window', 'clothes_pants', 'pillow', 'bowl', 'food_kiwi', 'dining_room', 'oven', 'check', 'food_food', 'razor', 'ice', 'curtain', 'pencil', 'cupboard', 'sink', 'dishwasher']
Task:Shut off alarm
response:
| {
"thoughts": "Shutting of the alarm clock",
"actions": [
"[WALK] <bedroom>",
"[WALK] <alarm_clock>",
"[FIND] <alarm_clock>",
"[GRAB] <alarm_clock>",
"[SWITCHOFF] <alarm_clock>",
"[PUTOBJBACK] <alarm_clock>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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>']
}
|
Scene_Objects:['spectacles', 'microwave', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door', 'bag', 'light', 'table']
Task:Turn on computer
response:
| {
"thoughts": "Press the power button on the computer to turn it on",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[SWITCHON] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'check', 'television', 'doorjamb', 'mouse', 'address_book', 'dresser', 'door']
Task:Write an email
response:
{
"thoughts": Walk to Home office. Sit on the chair. Switch on the computer. Find address in addressbook. Type in the keyboard. Write mail.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <address_book>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Scene_Objects:['sheets', 'food_salt', 'chair', 'wallshelf', 'character', 'keyboard', 'food_cake', 'mop_bucket', 'stovefan', 'toaster', 'iron', 'shower', 'window', 'clothes_socks', 'closetdrawer', 'dining_room', 'broom', 'box', 'coffe_maker', 'television', 'tray', 'centerpiece', 'doorjamb', 'kettle', 'mouse', 'headset', 'cupboard', 'bag', 'table', 'light']
Task:Shut front door
response:
| {
"thoughts": "Close the storm door. Lock the storm door.",
"actions": [
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'scissors', 'tea', 'freezer', 'blow_dryer', 'drawing', 'knifeblock', 'cpuscreen', 'clothes_underwear', 'character', 'desk', 'toaster', 'shower', 'picture', 'mousepad', 'candle', 'dining_room', 'bench', 'oven', 'basket_for_clothes', 'bed', 'check', 'television', 'toothbrush_holder', 'curtain', 'mouse', 'sink', 'light', 'tooth_paste', 'laser_pointer']
Task:Turn on light
response:
{
"thoughts": I walk into the living room and then I walk to the light switch in there and turn the lights on,
"actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}
|
Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'crayon', 'mop', 'toilet', 'chair', 'bathroom', 'detergent', 'dough', 'ceiling', 'keyboard', 'stereo', 'couch', 'pillow', 'cup', 'newspaper', 'keys', 'check', 'toothbrush_holder', 'food_donut', 'after_shave', 'rag', 'mouse', 'pajamas', 'cupboard', 'bag', 'light', 'table', 'tooth_paste']
Task:Put away keys
response:
| {
"thoughts": "Return keys into a bag",
"actions": [
"[WALK] <home_office>",
"[WALK] <keys>",
"[FIND] <keys>",
"[GRAB] <keys>",
"[FIND] <bag>",
"[OPEN] <bag>",
"[PUTBACK] <keys> <bag>",
"[CLOSE] <bag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'stovefan', 'mousepad', 'wall', 'nightstand', 'television', 'curtain', 'after_shave', 'mouse', 'kitchen_counter', 'clothes_dress', 'door', 'sink', 'home_office', 'soap']
Task:Read book
response:
{
"thoughts": find a book to read. sit down. read the book.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']
}
|
Scene_Objects:['sponge', 'sheets', 'pot', 'blender', 'microwave', 'chair', 'nail_polish', 'detergent', 'milk', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'clothes_socks', 'broom', 'wall', 'food_kiwi', 'powersocket', 'cup', 'photoframe', 'keys', 'newspaper', 'curtain', 'lighter', 'pencil', 'pajamas', 'clothes_dress', 'sink', 'table', 'light']
Task:Sit in chair
response:
| {
"thoughts": "I sit in a chair to rest and eat.",
"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:['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>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'juice', 'band-aids', 'freezer', 'bathroom', 'orchid', 'needle', 'wallshelf', 'knife', 'hanger', 'floor', 'ceiling', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'wall', 'oven', 'food_food', 'oven_mitts', 'doorjamb', 'pencil', 'cd', 'dresser', 'door', 'maindoor', 'bathroom_cabinet', 'light', 'clothes_skirt']
Task:Turn on light
response:
{
"thoughts": Walk to the bedroom and use the button on the wall, next to the door to turn on the lights.,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'walllamp', 'cat', 'milk', 'orchid', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bookshelf', 'toaster', 'ceilinglamp', 'mat', 'stereo', 'picture', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'doorjamb', 'door', 'light', 'table']
Task:Look at painting
response:
| {
"thoughts": "Walk to the painting. Look up at the painting. Admire it on the wall.",
"actions": [
"[WALK] <home_office>",
"[WALK] <drawing>",
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'tea_bag', 'bookshelf', 'food_bacon', 'toaster', 'plate', 'tvstand', 'dish_soap', 'mousepad', 'couch', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'toothbrush_holder', 'ice', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'clothes_dress', 'dishwasher']
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>']
}
|
Scene_Objects:['pot', 'food_pizza', 'juice', 'tea', 'chair', 'freezer', 'bathroom', 'detergent', 'wallshelf', 'cpuscreen', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'window', 'dustpan', 'bed', 'light_bulb', 'check', 'food_food', 'curtain', 'dresser', 'door', 'napkin', 'light', 'colander', 'clothes_shirt', 'scrabble', 'dirt']
Task:Answer door
response:
| {
"thoughts": "Walk up to the door. Open the door and greet whomever is out side",
"actions": [
"[WALK] <home_office>",
"[WALK] <man>",
"[FIND] <man>",
"[GREET] <man>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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>']
}
|
Scene_Objects:['dry_pasta', 'glue', 'measuring_cup', 'microwave', 'chair', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'floor', 'phone', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'wall', 'nightstand', 'photoframe', 'food_food', 'coffee_pot', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'instrument_violin', 'table', 'soap', 'tooth_paste']
Task:Bring dirty plate to sink
response:
| {
"thoughts": "Stand up from the table. Pick up dirty plate. Walk to sink. Put plate in sink.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <table>",
"[FIND] <table>",
"[TURNTO] <table>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <sink>",
"[PUTBACK] <plate> <sink>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_bread', 'juice', 'food_ice_cream', 'food_oatmeal', 'microwave', 'chair', 'freezer', 'walllamp', 'ground_coffee', 'milk', 'knifeblock', 'drawing', 'knife', 'floor', 'ceiling', 'stovefan', 'toaster', 'mat', 'faucet', 'ceilinglamp', 'bowl', 'wall', 'oven', 'bench', 'cup', 'coffe_maker', 'food_donut', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'dishwasher']
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>']
}
|
Scene_Objects:['sponge', 'microwave', 'toilet', 'jelly', 'freezer', 'ground_coffee', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'button', 'mat', 'shower', 'picture', 'dustpan', 'food_orange', 'form', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'light_bulb', 'food_food', 'doorjamb', 'cd', 'door', 'light']
Task:Added meat to freezer
response:
| {
"thoughts": "After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTBACK] <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:['pot', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'mat', 'tvstand', 'faucet', 'stereo', 'picture', 'mousepad', 'couch', 'microphone', 'pillow', 'wall', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'lighter', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher']
Task:Relax on sofa
response:
{
"thoughts": go to living room and lie down on the sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['food_salt', 'toilet', 'dog', 'freezer', 'drawing', 'cpuscreen', 'phone', 'tea_bag', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'window', 'oil', 'food_orange', 'food_cheese', 'clothes_gloves', 'toilet_paper', 'food_food', 'television', 'coffee_filter', 'check', 'curtain', 'kettle', 'mouse', 'food_steak', 'spoon', 'instrument_guitar', 'light', 'dishwasher']
Task:Walk to room
response:
| {
"thoughts": "Leave the living room and enter the hall",
"actions": [
"[WALK] <home_office>",
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'computer', 'mail', 'table_cloth', 'mat', 'tvstand', 'plate', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'photoframe', 'check', 'television', 'curtain', 'after_shave', 'doorjamb', 'cards', 'mouse', 'shoes', 'sink']
Task:Relax on sofa
response:
{
"thoughts": I walk to the living room. I sit in the sofa and I relax.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['pot', 'tablelamp', 'beer', 'toilet', 'chair', 'freezer', 'walllamp', 'food_butter', 'drawing', 'orchid', 'floor', 'ceiling', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'food_food', 'television', 'food_onion', 'doorjamb', 'door', 'spoon', 'light']
Task:Drink
response:
| {
"thoughts": "Get a can of beer, open it, sit on couch, relax",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <beer>",
"[GRAB] <beer>",
"[CLOSE] <freezer>",
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[DRINK] <beer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'juice', 'toilet', 'walllamp', 'toothbrush', 'drawing', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stamp', 'faucet', 'balanceball', 'clothes_pants', 'wall', 'powersocket', 'photoframe', 'novel', 'toothbrush_holder', 'television', 'food_donut', 'tray', 'towel_rack', 'cupboard', 'controller', 'sink', 'bathroom_cabinet', 'tooth_paste']
Task:Wash teeth
response:
{
"thoughts": I go into the bathroom, go to the sink, get toothbrush and toothpaste. Put toothpaste on the toothbrush, brush teeth, turn on faucet, rinse brush, and return toothbrush.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[PUTBACK] <toothbrush> <toothbrush_holder>']
}
|
Scene_Objects:['blender', 'toilet', 'chair', 'walllamp', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'ceiling', 'bedroom', 'bookshelf', 'food_bacon', 'table_cloth', 'toaster', 'laptop', 'ceilinglamp', 'floor_lamp', 'mousepad', 'couch', 'clothes_pants', 'towel', 'dining_room', 'basket_for_clothes', 'check', 'pencil', 'chessboard', 'food_steak', 'napkin', 'spoon', 'table']
Task:Turn off light
response:
| {
"thoughts": "Walk to the lamp. Find the switch. Click the switch off.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <floor_lamp>",
"[SWITCHOFF] <floor_lamp>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['freezer', 'bathroom', 'ceilingfan', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stovefan', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'cutting_board', 'bed', 'novel', 'mouthwash', 'television', 'curtain', 'towel_rack', 'home_office', 'table', 'clothes_skirt']
Task:Watch TV
response:
{
"thoughts": I come home and go to the sofa for turn off the tv and relax,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['microwave', 'chair', 'walllamp', 'wallshelf', 'ceiling', 'phone', 'keyboard', 'thread', 'piano_bench', 'brush', 'mat', 'ceilinglamp', 'window', 'oil', 'closetdrawer', 'mousepad', 'food_peanut_butter', 'candle', 'nightstand', 'powersocket', 'newspaper', 'novel', 'television', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'home_office', 'table', 'instrument_violin']
Task:Turn on light
response:
| {
"thoughts": "Twist the lamp switch until the light goes on.",
"actions": [
"[WALK] <home_office>",
"[WALK] <floor_lamp>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'toilet', 'bathroom', 'trashcan', 'ceilingfan', 'toothbrush', 'orchid', 'floor', 'phone', 'bookshelf', 'computer', 'toaster', 'shoe-shine_kit', 'mousepad', 'pillow', 'dining_room', 'box', 'basket_for_clothes', 'keys', 'razor', 'toothbrush_holder', 'coin', 'wine', 'doorjamb', 'cards', 'door', 'napkin', 'home_office', 'soap', 'tooth_paste']
Task:Brush teeth
response:
{
"thoughts": today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well,
"actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <toothbrush>']
}
|
Scene_Objects:['sheets', 'pot', 'mop', 'microwave', 'detergent', 'food_butter', 'drawing', 'keyboard', 'bookshelf', 'computer', 'food_bacon', 'toaster', 'faucet', 'clothes_hat', 'oven', 'cutting_board', 'cup', 'check', 'coin', 'doorjamb', 'mouse', 'vacuum_cleaner', 'headset', 'chessboard', 'dresser', 'laundry_detergent', 'light', 'dishwasher', 'instrument_violin', 'dirt']
Task:Vacuum
response:
| {
"thoughts": "Get the vacuum and use it to clean my floors",
"actions": [
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[WALK] <bedroom>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[WALK] <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:['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:['sponge', 'food_bread', 'toilet', 'bathroom', 'detergent', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'mail', 'ceilinglamp', 'shower', 'iron', 'closetdrawer', 'couch', 'towel', 'oven', 'coin', 'lighter', 'console', 'mouse', 'shoes', 'cd', 'dishrack', 'spoon', 'light', 'table']
Task:Switch on lamp
response:
| {
"thoughts": "Press the button so the light comes on.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <floor_lamp>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'band-aids', 'walllamp', 'blow_dryer', 'detergent', 'bathroom', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'stereo', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'clothes_gloves', 'water', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'napkin']
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:['chair', 'band-aids', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'cleaning_solution', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'photoframe', 'novel', 'rag', 'doorjamb', 'centerpiece', 'mouse', 'kitchen_counter', 'dresser', 'door', 'food_steak', 'home_office', 'dishwasher']
Task:Dust
response:
| {
"thoughts": "Gather wood cleaner and cleaning rag. Wipe baseboards and window sills with dry cloth, then spray with cleaner and buff",
"actions": [
"[WALK] <bedroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[POUR] <cleaning_solution> <rag>",
"[PUTOBJBACK] <cleaning_solution>",
"[WALK] <wall>",
"[WALK] <window>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'ground_coffee', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'piano_bench', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'stereo', 'deck_of_cards', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'television', 'food_rice', 'mouse', 'door', 'table', 'laser_pointer']
Task:Work
response:
{
"thoughts": Go to the office and sit on the chair, then work on the computer,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'shampoo', 'ceiling', 'button', 'deck_of_cards', 'shower', 'clothes_pants', 'food_kiwi', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'spoon', 'home_office', 'light', 'clothes_skirt', 'dishwasher', 'coffee']
Task:Grab things
response:
| {
"thoughts": "The robot will need some kind of hands or grabbing device to transport objects.",
"actions": [
"[WALK] <novel>",
"[TURNTO] <novel>",
"[GRAB] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'brush', 'ceilinglamp', 'mat', 'laptop', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_food', 'oven_mitts', 'kettle', 'mouse', 'cd', 'door', 'hairdryer', 'napkin', 'sink', 'table', 'light']
Task:Wash monitor
response:
{
"thoughts": Clean the grime off of my monitor screen when not in use,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHOFF] <computer>', '[FIND] <brush>', '[TURNTO] <brush>', '[LOOKAT] <brush>', '[GRAB] <brush>', '[WIPE] <computer>', '[DROP] <brush>', '[FIND] <napkin>', '[GRAB] <napkin>', '[WASH] <napkin>', '[WIPE] <computer>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'measuring_cup', 'chair', 'walllamp', 'bathroom', 'bills', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'alcohol', 'bookmark', 'toaster', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'check', 'television', 'tray', 'cupboard', 'instrument_violin', 'teeth']
Task:Do homework
response:
| {
"thoughts": "Sit on the couch in the Living room and pick u some papers",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <check>",
"[GRAB] <check>",
"[DROP] <check>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['jelly', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'brush', 'stovefan', 'faucet', 'iron', 'couch', 'towel', 'wall', 'powersocket', 'cutting_board', 'photoframe', 'bed', 'television', 'lighter', 'console', 'dresser', 'pajamas', 'door', 'sink', 'bathroom_cabinet', 'table', 'clothes_skirt', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands.,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['dry_pasta', 'scissors', 'crayon', 'toilet', 'jelly', 'walllamp', 'nail_polish', 'detergent', 'food_cake', 'alcohol', 'piano_bench', 'toaster', 'food_noodles', 'garbage_can', 'pillow', 'broom', 'oven', 'toy', 'food_vegetable', 'food_food', 'television', 'oven_mitts', 'doorjamb', 'pencil', 'headset', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'pantry']
Task:Organize pantry
response:
| {
"thoughts": "Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <pantry>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>",
"[FIND] <garbage_can>",
"[PUTBACK] <food_food> <garbage_can>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[TURNTO] <food_vegetable>",
"[LOOKAT] <food_vegetable>",
"[PUTBACK] <food_vegetable> <garbage_can>",
"[FIND] <dry_pasta>",
"[GRAB] <dry_pasta>",
"[TURNTO] <dry_pasta>",
"[LOOKAT] <dry_pasta>",
"[PUTOBJBACK] <dry_pasta>",
"[FIND] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>",
"[PUSH] <food_food>",
"[FIND] <food_noodles>",
"[GRAB] <food_noodles>",
"[TURNTO] <food_noodles>",
"[LOOKAT] <food_noodles>",
"[PUTOBJBACK] <food_noodles>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'bathroom', 'detergent', 'nail_polish', 'trashcan', 'food_butter', 'orchid', 'hanger', 'longboard', 'floor', 'bathroom_counter', 'remote_control', 'envelope', 'computer', 'window', 'electric_shaver', 'wall', 'cutting_board', 'bed', 'television', 'tray', 'curtain', 'after_shave', 'lighter', 'mouse', 'cupboard', 'clothes_dress', 'light', 'clothes_skirt', 'board_game']
Task:Watch TV
response:
{
"thoughts": Watching tv with a remote is always fun; lay back, relax and enjoy;,
"actions": ['[WALK] <bedroom>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <bed>', '[LIE] <bed>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'mop', 'bathroom', 'dough', 'milk', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'cleaning_solution', 'keyboard', 'mat', 'faucet', 'window', 'food_noodles', 'closetdrawer', 'couch', 'clothes_pants', 'nightstand', 'tape', 'food_food', 'check', 'food_rice', 'wooden_spoon', 'rag', 'mouse', 'controller', 'door', 'home_office']
Task:Clean mirror
response:
| {
"thoughts": "Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[POUR] <cleaning_solution> <rag>",
"[PUTOBJBACK] <cleaning_solution>",
"[WALK] <mirror>",
"[WIPE] <mirror>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'freezer', 'band-aids', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stamp', 'desk', 'stovefan', 'shoe-shine_kit', 'couch', 'pillow', 'wall', 'bench', 'coffe_maker', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'cupboard', 'door', 'sink', 'bathtub', 'instrument_guitar', 'light', 'home_office', 'clothes_skirt']
Task:Turn on light
response:
{
"thoughts": I walk to room. I enter room. I find where the lightswitch is. I turn on the lights with the lightswitch.,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[LOOKAT] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'door', 'light', 'table']
Task:Vacuum
response:
| {
"thoughts": "Keep my keyboard vacuumed and free of debris.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'crayon', 'chair', 'freezer', 'detergent', 'food_butter', 'drawing', 'knife', 'hanger', 'floor', 'character', 'piano_bench', 'toaster', 'clothes_socks', 'food_peanut_butter', 'pillow', 'food_kiwi', 'coffe_maker', 'food_donut', 'tray', 'curtain', 'shaving_cream', 'mouse', 'kitchen_counter', 'dishrack', 'hair', 'door', 'hairdryer', 'napkin']
Task:Turn on light
response:
{
"thoughts": Turning on lights,
"actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}
|
Scene_Objects:['sheets', 'orchid', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'phone', 'cleaning_solution', 'button', 'ceilinglamp', 'mat', 'shoe-shine_kit', 'food_orange', 'pillow', 'dining_room', 'food_kiwi', 'cup', 'food_cheese', 'bed', 'clothes_gloves', 'coffe_maker', 'toilet_paper', 'oven_mitts', 'curtain', 'rag', 'console', 'pencil', 'dresser', 'clothes_scarf', 'light', 'colander']
Task:Clean
response:
| {
"thoughts": "Spray counter tops with all purpose cleaner. Using towel, wipe counter, removing all dirt and grime until clean.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[PUTOBJBACK] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'mop', 'band-aids', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'cleaning_solution', 'bookshelf', 'computer', 'stereo', 'oil', 'mousepad', 'wall', 'wall_clock', 'nightstand', 'shelf', 'newspaper', 'food_food', 'video_game_controller', 'coin', 'rag', 'mouse', 'pencil', 'bathtub', 'bathroom_cabinet', 'light', 'coffee', 'creditcard']
Task:Clean mirror
response:
{
"thoughts": GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR,
"actions": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']
}
|
Scene_Objects:['sponge', 'pot', 'blender', 'beer', 'microwave', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'toaster', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'food_orange', 'wall', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'sink']
Task:Wash dirty dishes
response:
| {
"thoughts": "Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <sponge>",
"[GRAB] <sponge>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[PUTBACK] <sponge> <sink>",
"[GRAB] <sponge>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[POUR] <dish_soap> <sponge>",
"[PUTOBJBACK] <dish_soap>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[SCRUB] <plate>",
"[RINSE] <plate>",
"[FIND] <dishrack>",
"[PUTBACK] <plate> <dishrack>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[SCRUB] <plate>",
"[RINSE] <plate>",
"[PUTBACK] <plate> <dishrack>",
"[RINSE] <sponge>",
"[PUTOBJBACK] <sponge>",
"[SWITCHOFF] <faucet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'microwave', 'walllamp', 'bathroom', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'shoe-shine_kit', 'faucet', 'window', 'mousepad', 'couch', 'wall', 'oven', 'newspaper', 'coffe_maker', 'food_food', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'light']
Task:Pick up phone
response:
{
"thoughts": Walk to living room. Go near telephone. take the receiver and then talk to other person on that side.,
"actions": ['[WALK] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'ground_coffee', 'wallshelf', 'hanger', 'floor', 'stamp', 'desk', 'bookshelf', 'tea_bag', 'envelope', 'computer', 'mop_bucket', 'mat', 'shower', 'foundation', 'form', 'wall', 'powersocket', 'cutting_board', 'photoframe', 'novel', 'check', 'television', 'wooden_spoon', 'after_shave', 'doorjamb', 'door', 'light']
Task:Read to child
response:
| {
"thoughts": "Read a book out loud to a child",
"actions": [
"[WALK] <bedroom>",
"[WALK] <child>",
"[FIND] <child>",
"[GREET] <child>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[WALK] <chair>",
"[PULL] <chair>",
"[SIT] <chair>",
"[TURNTO] <novel>",
"[LOOKAT] <novel>",
"[TURNTO] <novel>",
"[POINTAT] <novel>",
"[TURNTO] <novel>",
"[POINTAT] <novel>",
"[READ] <novel>",
"[READ] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'cat', 'ceilingfan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'oil', 'couch', 'wall', 'wall_clock', 'powersocket', 'oven', 'bench', 'newspaper', 'mouthwash', 'television', 'diary', 'towel_rack', 'mouse', 'dresser', 'hairbrush', 'hairdryer', 'soap']
Task:Check email
response:
{
"thoughts": Sit in teak deck chair, have wooden drawing board on lap, laptop on wooden drawing board, log in to my two email accounts, go through new emails and respond.,
"actions": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <chair>', '[SIT] <chair>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>']
}
|
Scene_Objects:['filing_cabinet', 'food_ice_cream', 'chair', 'nail_polish', 'bathroom', 'cat', 'dough', 'toothbrush', 'desk', 'button', 'stovefan', 'shower', 'faucet', 'window', 'pillow', 'nightstand', 'wall_clock', 'oven', 'cutting_board', 'novel', 'check', 'television', 'toothbrush_holder', 'lighter', 'kettle', 'chessboard', 'dresser', 'sink', 'home_office', 'clothes_skirt']
Task:Keep cats out of room
response:
| {
"thoughts": "Stand in the doorway and create a loud noise so the cats will stay out.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <cat>",
"[FIND] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <cat>"
]
} |
Subsets and Splits