input
stringlengths 1.39k
2.78k
| thoughts
stringlengths 11
442
|
|---|---|
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'food_pizza', 'tablelamp', 'blender', 'food_salt', 'blow_dryer', 'trashcan', 'toothbrush', 'cpuscreen', 'hanger', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'purse', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'microphone', 'oven', 'food_food', 'check', 'tray', 'dresser', 'napkin', 'bathroom_cabinet', 'clothes_shirt'] Task:Leave home response: { thoughts : Put on shoes. Put on coat. Open door and exit through it. Lock door behind you., actions : ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>'] } Scene_Objects:['toilet', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'centerpiece', 'mouse', 'shoes', 'dresser', 'door', 'maindoor', 'sink', 'light', 'table', 'soap'] Task:Browse internet response: | { go to the office, turn computer on, open an browser or any application to open any website. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'ceilingfan', 'knifeblock', 'orchid', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'computer', 'couch', 'broom', 'wall', 'coffe_maker', 'video_game_controller', 'wine', 'doorjamb', 'towel_rack', 'cards', 'pencil', 'kitchen_counter', 'mouse', 'dresser', 'cupboard', 'door', 'light', 'board_game'] Task:Turn on light response: { thoughts : Walk over to light switch. Turn on lights., actions : ['[WALK] <light>', '[SWITCHON] <light>'] } Scene_Objects:['chair', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mail', 'button', 'clothes_jacket', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'keys', 'television', 'ice', 'doorjamb', 'mouse', 'pencil', 'headset', 'dresser', 'sink', 'light', 'table'] Task:Write an email response: | { Switch on computer, Use keybord and mouse to open e-mail provider, type requested e-mail, click send, close e-mail provider, turn off computer } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', '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>'] } Scene_Objects:['fork', 'filing_cabinet', 'tablelamp', 'mop', 'bathroom', 'drawing', 'floor', 'phone', 'character', 'desk', 'mail', 'laptop', 'tvstand', 'stereo', 'food_orange', 'dining_room', 'wall', 'oven', 'photoframe', 'television', 'tray', 'towel_rack', 'kettle', 'kitchen_counter', 'dresser', 'sink', 'bathtub', 'table', 'board_game', 'coffee'] Task:Walk through response: | { Walk through the entrance hall } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_salt', 'microwave', 'jelly', 'detergent', 'food_carrot', 'toothbrush', 'needle', 'hanger', 'floor', 'phone', 'shampoo', 'character', 'tvstand', 'iron', 'balanceball', 'stereo', 'mousepad', 'food_jam', 'pillow', 'nightstand', 'toothbrush_holder', 'diary', 'console', 'shaving_cream', 'kitchen_counter', 'sink', 'light', 'dishwasher', 'vase'] Task:Listen to music response: { thoughts : Find the playback device you want to listen to. turn on. press play. enjoyu music., actions : ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>'] } Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'bills', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light'] Task:Watch TV response: | { Sit on my couch directly opposite my tv , switch on my tv with the remote control and watch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'detergent', 'drawing', 'orchid', 'floor', 'character', 'keyboard', 'toaster', 'mat', 'faucet', 'stereo', 'couch', 'towel', 'wall', 'wall_clock', 'nightstand', 'cup', 'coffe_maker', 'kitchen_counter', 'shoes', 'cd', 'hairbrush', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'scrabble', 'hands_both'] Task:Wash hands response: { thoughts : I have had my lunch and walked towards the sink and applied soap to my hands and washed cleanly., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>'] } Scene_Objects:['sheets', 'walllamp', 'bathroom', 'trashcan', 'dough', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'faucet', 'window', 'food_noodles', 'mousepad', 'pillow', 'dining_room', 'wall', 'bed', 'food_food', 'razor', 'rag', 'console', 'mouse', 'towel_rack', 'kitchen_counter', 'door', 'sink', 'bathtub', 'bathroom_cabinet'] Task:Clean sink response: | { Take a premoistened cleaning wipe and wipe down top of sink and faucet. Next clean the sink bowl. Let air dry. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'nail_polish', 'bathroom', 'detergent', 'knife', 'cpuscreen', 'dvd_player', 'bedroom', 'computer', 'table_cloth', 'mop_bucket', 'brush', 'toaster', 'shower', 'window', 'couch', 'dining_room', 'wall', 'pasta', 'cup', 'photoframe', 'after_shave', 'pencil', 'kitchen_counter', 'dresser', 'clothes_dress', 'sink', 'instrument_guitar', 'light', 'creditcard'] Task:Sit response: { thoughts : We sit at the dining room table, actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>'] } Scene_Objects:['pot', 'tea', 'microwave', 'bathroom', 'trashcan', 'orchid', 'knife', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'envelope', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'food_food', 'food_donut', 'curtain', 'doorjamb', 'kitchen_counter', 'hair', 'door', 'sink', 'table', 'light', 'dishwasher'] Task:Put out flowers response: | { Place a flower centrepiece on the entrance hall table. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'food_carrot', 'drawing', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'shower', 'faucet', 'window', 'oil', 'couch', 'clothes_pants', 'pillow', 'wall', 'tape', 'cup', 'novel', 'tray', 'curtain', 'mouse', 'chessboard', 'controller', 'table'] Task:Read book response: { thoughts : Sit on a couch, grab a book, open it, and scan the pages, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>'] } Scene_Objects:['food_pizza', 'tablelamp', 'toilet', 'chair', 'detergent', 'trashcan', 'orchid', 'floor', 'ceiling', 'stamp', 'man', 'bookshelf', 'purse', 'toaster', 'mat', 'oil', 'mousepad', 'nightstand', 'cup', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'mouse', 'headset', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher'] Task:Answer door response: | { Wait until doorbell rings, look to see who it is outside and open the door if you feel so inclined. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'stereo', 'window', 'shower', 'mousepad', 'wall', 'powersocket', 'bench', 'clothes_gloves', 'television', 'tray', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'bathtub', 'table'] Task:Work response: { thoughts : I walk into home office. I walk to desk. I sit at chair. I turn on computer., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['sponge', 'pot', 'microwave', 'chair', 'walllamp', 'bathroom', 'knifeblock', 'needle', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'plate', 'faucet', 'dish_soap', 'pillow', 'wall', 'oven', 'box', 'coffe_maker', 'coin', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'home_office', 'table'] Task:Wash dishes response: | { Turn water on and run over dishes while scrubbing with a soapy 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:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'tvstand', 'dish_soap', 'wall', 'pasta', 'coffee_filter', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'scrabble'] Task:Wash dishes response: { thoughts : Place all of the dirty dishes in a sink full of clean, soapy water. Wash them. Rinse them in fresh, running water. Place them in the strainer to dry., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[SWITCHON] <faucet>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[GRAB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['spectacles', 'filing_cabinet', 'food_salt', 'mop', 'microwave', 'band-aids', 'freezer', 'walllamp', 'bathroom', 'food_carrot', 'drawing', 'floor', 'ceiling', 'keyboard', 'bookshelf', 'computer', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'tray', 'curtain', 'doorjamb', 'shoes', 'door', 'bathroom_cabinet', 'light', 'shoe_rack'] Task:Turn light off response: | { Put the light switch into the down, or off, position. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'measuring_cup', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'mouse', 'pencil', 'cupboard', 'door', 'maindoor', 'home_office', 'light', 'dishwasher', 'creditcard'] Task:Work response: { thoughts : turn computer on, open application to work with, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'toilet', 'band-aids', 'knifeblock', 'orchid', 'bedroom', 'keyboard', 'thread', 'clothes_jacket', 'faucet', 'food_noodles', 'food_orange', 'pillow', 'dining_room', 'oven', 'bench', 'powersocket', 'cup', 'newspaper', 'bed', 'check', 'coffe_maker', 'ice', 'tray', 'towel_rack', 'bathtub', 'home_office', 'dishwasher'] Task:Walk through response: | { Walk through the hallway. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'chair', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'computer', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'wall_clock', 'bench', 'television', 'wine', 'curtain', 'coffee_pot', 'door', 'sink', 'spoon', 'table'] Task:Watch TV response: { thoughts : I watch Netflix from about 8:30 to 10:30 every night. I usually watch TV shows., actions : ['[WALK] <home_office>', '[WALK] <wall_clock>', '[FIND] <wall_clock>', '[TURNTO] <wall_clock>', '[LOOKAT] <wall_clock>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['fork', 'pot', 'microwave', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'knife', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'toaster', 'stovefan', 'plate', 'faucet', 'tvstand', 'wall', 'nightstand', 'oven', 'coffe_maker', 'drinking_glass', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'home_office', 'dishwasher'] Task:Unload dishwasher response: | { Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'bedroom', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'pillow', 'dining_room', 'wall', 'bench', 'toy', 'box', 'photoframe', 'clothes_gloves', 'novel', 'video_game_controller', 'cards', 'vacuum_cleaner', 'dresser', 'controller', 'maindoor', 'napkin', 'dishwasher', 'instrument_violin'] Task:Pick up toys response: { thoughts : Bend down and pick up the toys off of the floor., actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'detergent', 'milk', 'knifeblock', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'faucet', 'iron', 'couch', 'wall', 'oven', 'food_food', 'television', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'laser_pointer', 'scrabble'] Task:Cook some food response: | { Cooking a meal } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'faucet', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door'] Task:Watch youtube response: { thoughts : Go to youtube.Com watch videos, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['microwave', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'phone', 'bookshelf', 'table_cloth', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'cup', 'photoframe', 'check', 'television', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'sink', 'light', 'tooth_paste'] Task:Pet dog response: | { Pet my dog in hall } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_ice_cream', 'freezer', 'cat', 'knifeblock', 'longboard', 'floor', 'ceiling', 'keyboard', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'mat', 'stereo', 'tvstand', 'electric_shaver', 'mousepad', 'couch', 'wall', 'oven', 'bench', 'cup', 'food_food', 'doorjamb', 'conditioner', 'clothes_scarf', 'home_office', 'table', 'light', 'vase'] Task:Put groceries in Fridge response: { thoughts : I get my groceries and go to the fridge. I open the fridge and put the groceries there., actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['sponge', 'pot', 'bathroom', 'knifeblock', 'bathroom_counter', 'shampoo', 'phone', 'mail', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'window', 'clothes_socks', 'couch', 'clothes_pants', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'mouse', 'shoes', 'chessboard', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt'] Task:Get dressed response: | { Open drawer. Pull out pants and put them on. Take a shirt out and put it on. Put on socks and shoes. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Watch youtube response: { thoughts : Go to youtube.Com watch videos, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['chair', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bedroom', 'bookshelf', 'keyboard', 'ceilinglamp', 'faucet', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'food_food', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathtub', 'light', 'table', 'instrument_violin'] Task:Straighten pictures on wall response: | { Move the pictures/paintings until they are straight. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'spectacles', 'filing_cabinet', 'food_salt', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'character', 'shower', 'stereo', 'microphone', 'wall', 'toy', 'cutting_board', 'cup', 'novel', 'food_food', 'check', 'food_onion', 'coffee_pot', 'console', 'shaving_cream', 'towel_rack', 'shoes', 'cd', 'hairbrush', 'maindoor', 'soap', 'coffee'] Task:Read response: { thoughts : Read a book in the living room, actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[READ] <novel>'] } Scene_Objects:['pot', 'food_pizza', 'tea', 'toilet', 'walllamp', 'nail_polish', 'cpuscreen', 'floor', 'phone', 'ceiling', 'keyboard', 'toaster', 'mat', 'oil', 'pillow', 'bowl', 'wall', 'powersocket', 'oven', 'photoframe', 'television', 'rag', 'doorjamb', 'headset', 'door', 'sink', 'home_office', 'light', 'bathroom_cabinet', 'coffee'] Task:Turn light off response: | { Put the light switch into the down, or off, position. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'detergent', 'hanger', 'bathroom_counter', 'shampoo', 'ceiling', 'desk', 'bedroom', 'computer', 'stovefan', 'toaster', 'tvstand', 'shower', 'homework', 'closetdrawer', 'bench', 'oven', 'toy', 'cup', 'bed', 'photoframe', 'toilet_paper', 'coffe_maker', 'oven_mitts', 'pencil', 'dresser', 'bag', 'bathroom_cabinet'] 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>'] } Scene_Objects:['chair', 'trashcan', 'orchid', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'window', 'food_noodles', 'couch', 'pillow', 'wall', 'photoframe', 'toothbrush_holder', 'curtain', 'doorjamb', 'chessboard', 'door', 'bathtub', 'bag', 'home_office', 'light', 'table', 'dishwasher', 'instrument_violin'] Task:Admire art response: | { Looking at painting, art } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'cat', 'dough', 'bathroom_counter', 'phone', 'bookshelf', 'ceilinglamp', 'tvstand', 'stereo', 'candle', 'bowl', 'dining_room', 'wall', 'newspaper', 'coffe_maker', 'food_food', 'coffee_filter', 'tray', 'curtain', 'diary', 'towel_rack', 'pencil', 'dresser', 'food_steak', 'sink', 'napkin', 'door', 'dishwasher'] Task:Pick up phone response: { thoughts : I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>'] } Scene_Objects:['microwave', 'walllamp', 'trashcan', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'light', 'table'] Task:Watch TV response: | { I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'cd_player', 'blow_dryer', 'bathroom', 'detergent', 'orchid', 'bills', 'bathroom_counter', 'phone', 'bedroom', 'remote_control', 'thread', 'button', 'mat', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'broom', 'wall_clock', 'powersocket', 'bench', 'box', 'coffe_maker', 'razor', 'towel_rack', 'vacuum_cleaner', 'bathtub', 'dishwasher', 'soap'] Task:Listen to music response: { thoughts : I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton, actions : ['[WALK] <home_office>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[PLUGIN] <cd_player>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'shoes', 'door', 'table', 'light', 'creditcard'] Task:Watch TV response: | { Sit on my couch directly opposite my tv , switch on my tv with the remote control and watch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'glue', 'filing_cabinet', 'microwave', 'jelly', 'freezer', 'ceilingfan', 'orchid', 'food_egg', 'floor', 'phone', 'ceiling', 'desk', 'thread', 'mat', 'laptop', 'deck_of_cards', 'faucet', 'foundation', 'pillow', 'nightstand', 'powersocket', 'basket_for_clothes', 'food_food', 'lighter', 'sink', 'home_office', 'vase', 'soap', 'washing_machine'] Task:Wash clothes response: { thoughts : I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine., actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['tablelamp', 'bathroom', 'trashcan', 'orchid', 'drawing', 'wallshelf', 'floor', 'character', 'bedroom', 'tea_bag', 'keyboard', 'toaster', 'mat', 'stovefan', 'tvstand', 'couch', 'dining_room', 'wall', 'nightstand', 'child', 'bed', 'photoframe', 'novel', 'food_onion', 'after_shave', 'cupboard', 'bathtub', 'napkin', 'bathroom_cabinet', 'board_game'] Task:Story reading time response: | { Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'scissors', 'ceilingfan', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'food_kiwi', 'wall', 'oven', 'powersocket', 'cup', 'light_bulb', 'novel', 'television', 'tray', 'curtain', 'after_shave', 'kitchen_counter', 'dresser', 'table', 'light'] Task:Watch TV response: { thoughts : walk to living room, find couch, sit on couch, find remote control , turn on tv by pressing button, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>'] } Scene_Objects:['tablelamp', 'measuring_cup', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'centerpiece', 'shoes', 'door', 'table', 'light'] Task:Watch TV response: | { TURN ON TV, SIT ON COUCH ACROSS THE ROOM, USE REMOTE TO LOOK FOR SHOW TO WATCH } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'walllamp', 'bathroom', 'milk', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'envelope', 'computer', 'mat', 'ceilinglamp', 'stereo', 'mousepad', 'wall', 'toothbrush_holder', 'food_rice', 'ice', 'after_shave', 'mouse', 'headset', 'dresser', 'door', 'home_office', 'table', 'board_game'] Task:Work response: { thoughts : Walk to home office, walk to desk, sit in chair, turn on computer, look at computer, click mouse and type on keyboard., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[TOUCH] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'dough', 'woman', 'knifeblock', 'bathroom_counter', 'floor', 'character', 'desk', 'tea_bag', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'wall', 'child', 'coffe_maker', 'video_game_controller', 'television', 'towel_rack', 'kettle', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'instrument_violin', 'clothes_shirt'] Task:Greet guests response: | { Go to the kitchen, greet your family members } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'bedroom', 'computer', 'alcohol', 'mat', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'bench', 'cutting_board', 'standingmirror', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'chessboard', 'dresser', 'table', 'clothes_skirt'] Task:Watch TV response: { thoughts : Walk into the living room. Sit on the couch. Turn on TV., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['sheets', 'pot', 'mop', 'walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'remote_control', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'powersocket', 'box', 'love_seat', 'photoframe', 'television', 'curtain', 'doorjamb', 'dresser', 'clothes_dress', 'bathtub', 'light'] Task:Watch TV response: | { I'll watch TV } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine'] Task:Wash clothes response: { thoughts : Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine., actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'faucet', 'wall', 'cup', 'photoframe', 'keys', 'ice', 'tray', 'rag', 'towel_rack', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'dishwasher', 'table', 'laser_pointer'] Task:Wipe down sink response: | { Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'food_carrot', 'drawing', 'floor', 'thread', 'toaster', 'mat', 'picture', 'oil', 'towel', 'nightstand', 'powersocket', 'toy', 'shelf', 'box', 'cup', 'cutting_board', 'bed', 'photoframe', 'novel', 'toilet_paper', 'check', 'television', 'tray', 'food_onion', 'curtain', 'dresser', 'door', 'hairdryer', 'tooth_paste'] Task:Listen to music response: { thoughts : Find the radio; switch on the radio and listen to music., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'door', 'table', 'light'] Task:Watch TV response: | { In the evenings after dinner, we sit on the couch, turn on the television, cue up Netflix and watch our favorite shows. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'beer', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'balanceball', 'mousepad', 'candle', 'wall', 'nightstand', 'newspaper', 'doorjamb', 'mouse', 'light', 'clothes_skirt'] 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:['pot', 'filing_cabinet', 'microwave', 'chair', 'freezer', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'tvstand', 'shoe-shine_kit', 'faucet', 'window', 'mousepad', 'couch', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'curtain', 'coffee_pot', 'towel_rack', 'sink', 'light', 'laser_pointer'] Task:Gaze out window response: | { Look at the yard from the 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:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'milk', 'floor', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'toy', 'basket_for_clothes', 'coffe_maker', 'video_game_controller', 'tray', 'doorjamb', 'kettle', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'table'] Task:Pick up toys response: { thoughts : Bend down and pick up the toys off of the floor., actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['tea', 'microwave', 'toilet', 'freezer', 'walllamp', 'ground_coffee', 'blow_dryer', 'knifeblock', 'cpuscreen', 'bedroom', 'computer', 'stovefan', 'faucet', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'love_seat', 'newspaper', 'television', 'after_shave', 'doorjamb', 'mouse', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'conditioner', 'bathtub'] Task:Read response: | { Reading a magazine } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'measuring_cup', 'freezer', 'nail_polish', 'food_carrot', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'plate', 'mat', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'powersocket', 'bench', 'food_vegetable', 'food_food', 'doorjamb', 'mouse', 'door', 'light', 'table', 'scrabble'] Task:Fix snack response: { thoughts : Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTBACK] <food_carrot> <plate>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[PUTBACK] <food_vegetable> <plate>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <plate> <table>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'detergent', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'food_cake', 'computer', 'mat', 'faucet', 'mousepad', 'bowl', 'wall', 'nightstand', 'oven', 'bench', 'box', 'check', 'coffee_filter', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'home_office'] Task:Wipe down sink response: | { Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'tea', 'microwave', 'bathroom', 'trashcan', 'orchid', 'knife', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'envelope', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'food_food', 'food_donut', 'curtain', 'doorjamb', 'kitchen_counter', 'hair', 'door', 'sink', 'table', 'light', 'dishwasher'] Task:Put out flowers response: { thoughts : Place a flower centrepiece on the entrance hall table., actions : ['[WALK] <home_office>', '[WALK] <centerpiece>', '[FIND] <centerpiece>', '[GRAB] <centerpiece>', '[WALK] <table>', '[PUTBACK] <centerpiece> <table>'] } Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'cards', 'cupboard', 'door', 'light', 'table'] Task:Watch TV response: | { Sit on couch and watch the tv } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'crayon', 'microwave', 'walllamp', 'dough', 'knifeblock', 'wallshelf', 'floor', 'phone', 'shampoo', 'desk', 'keyboard', 'bookmark', 'mat', 'shoe-shine_kit', 'floor_lamp', 'mousepad', 'pillow', 'powersocket', 'novel', 'curtain', 'centerpiece', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'table', 'clothes_skirt', 'colander'] Task:Read book response: { thoughts : Turn a light on and read a book in the bedroom., actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['tablelamp', 'bathroom', 'drawing', 'knifeblock', 'floor', 'character', 'keyboard', 'stovefan', 'mat', 'ceilinglamp', 'stereo', 'shower', 'window', 'toaster', 'wall', 'nightstand', 'box', 'food_cheese', 'bed', 'after_shave', 'lighter', 'diary', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'food_steak', 'light', 'dishwasher', 'clothes_shirt'] Task:Listen to music response: | { Turn on radio, put on favorite channel, listen to music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'detergent', 'cat', 'knife', 'drawing', 'hanger', 'bathroom_counter', 'desk', 'food_cake', 'purse', 'envelope', 'piano_bench', 'stovefan', 'toaster', 'stereo', 'balanceball', 'floor_lamp', 'powersocket', 'love_seat', 'newspaper', 'bed', 'photoframe', 'video_game_controller', 'diary', 'maindoor', 'light', 'soap', 'board_game'] Task:Read response: { thoughts : Sit on an easy chair. Turn on music. Take a book and read. Turn on lamp at night., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <newspaper>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'knifeblock', 'needle', 'wallshelf', 'bathroom_counter', 'phone', 'desk', 'food_cake', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'window', 'shower', 'stereo', 'food_peanut_butter', 'clothes_pants', 'pillow', 'bench', 'newspaper', 'bed', 'coffe_maker', 'television', 'lighter', 'dresser', 'cupboard', 'clothes_dress', 'table'] Task:Get ready for school response: | { Take clothes out of dressers and get dressed for school. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'chair', 'jelly', 'walllamp', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'envelope', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mousepad', 'wall', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table'] Task:Work response: { thoughts : Go into the office and sit down at the desk in front of the computer. Turn on the computer and look at it while clicking with the mouse and typing with the keyboard., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'napkin', 'spoon', 'table', 'light'] Task:Watch TV response: | { Sit on the couch and use the remote control to change channels } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'chair', 'freezer', 'band-aids', 'bathroom', 'food_carrot', 'drawing', 'floor', 'mat', 'window', 'couch', 'clothes_hat', 'form', 'pillow', 'bench', 'food_food', 'check', 'coffe_maker', 'toilet_paper', 'ice', 'centerpiece', 'doorjamb', 'cupboard', 'home_office', 'table', 'light', 'bathroom_cabinet', 'scrabble'] Task:Eat dinner response: { thoughts : In our dining room, my family eats dinner. Once the food has been prepared, we gather at the dining room table and prepare to eat., actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>'] } Scene_Objects:['pot', 'food_bread', 'chair', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'character', 'bedroom', 'keyboard', 'food_bacon', 'bookmark', 'stovefan', 'ceilinglamp', 'tvstand', 'picture', 'window', 'pillow', 'bench', 'love_seat', 'photoframe', 'novel', 'coin', 'curtain', 'towel_rack', 'mouse', 'pencil', 'sink', 'light', 'table', 'instrument_violin'] Task:Read book response: | { Obtain a book from the book shelf. Sit in the easy chair. Read the book. Mark the stopping point with a bookmark. Put the book back on the book shelf. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'food_bacon', 'mat', 'ceilinglamp', 'shower', 'wall', 'wall_clock', 'cup', 'photoframe', 'bed', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'coffee'] Task:Drink response: { thoughts : Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup, actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[TURNTO] <cup>', '[LOOKAT] <cup>', '[WALK] <cup>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[WALK] <freezer>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>'] } Scene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'faucet', 'window', 'oil', 'couch', 'wall', 'bench', 'powersocket', 'photoframe', 'bed', 'television', 'curtain', 'after_shave', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'light'] Task:Open bathroom window response: | { Make sure bathroom window is unlocked. Lift up bathroom window so it is open. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'tablelamp', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'oil', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'bed', 'coffe_maker', 'television', 'curtain', 'dresser', 'door', 'instrument_guitar', 'table'] Task:Watch TV response: { thoughts : I go to the living room, switch on the tv, take the remote and sit on the sofa., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'television', 'curtain', 'doorjamb', 'cd', 'pajamas', 'door', 'table', 'light', 'dishwasher'] Task:Watch TV response: | { Sitting on the couch watching my favorite television show. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'microwave', 'walllamp', 'milk', 'clothes_underwear', 'character', 'bedroom', 'keyboard', 'clothes_socks', 'candle', 'clothes_pants', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'bed', 'food_food', 'curtain', 'diary', 'shoes', 'headset', 'laundry_detergent', 'sink', 'home_office', 'table', 'colander', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: { thoughts : I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine., actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[DROP] <basket_for_clothes>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[GRAB] <laundry_detergent>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['pot', 'tea', 'microwave', 'chair', 'freezer', 'walllamp', 'milk', 'knifeblock', 'knife', 'drawing', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'stovefan', 'toaster', 'faucet', 'food_jam', 'pillow', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'tray', 'kitchen_counter', 'cupboard', 'controller', 'sink'] Task:Get something to drink response: | { Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'tea', 'chair', 'detergent', 'toothbrush', 'orchid', 'knifeblock', 'cpuscreen', 'kitchen_cabinet', 'floor', 'phone', 'bedroom', 'keyboard', 'ceilinglamp', 'faucet', 'window', 'dish_soap', 'food_jam', 'food_orange', 'pillow', 'wall', 'oven', 'bed', 'novel', 'coffe_maker', 'kitchen_counter', 'dishrack', 'cupboard', 'table', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTIN] <dish_soap> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['pot', 'filing_cabinet', 'dog', 'bathroom', 'knife', 'phone', 'character', 'desk', 'clothes_jacket', 'mat', 'ceilinglamp', 'window', 'mousepad', 'pillow', 'dining_room', 'photoframe', 'keys', 'coffe_maker', 'food_food', 'check', 'ice', 'tray', 'towel_rack', 'mouse', 'shoes', 'cupboard', 'bathtub', 'home_office', 'light', 'bathroom_cabinet'] Task:Get ready to leave response: | { Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'newspaper', 'coffee_table', 'novel', 'bed', 'oven_mitts', 'doorjamb', 'pencil', 'chessboard', 'dresser', 'door', 'food_steak', 'table', 'light'] Task:Read magazine response: | { Get magazine off coffee table. Sit in arm chair. Open magazine to first page. Read until finished. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'walllamp', 'bathroom', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'oven', 'newspaper', 'bed', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'bathroom_cabinet', 'table'] Task:Use computer response: { thoughts : Sit at desk, use the computer mouse, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[TURNTO] <computer>', '[POINTAT] <computer>'] } Scene_Objects:['tablelamp', 'blender', 'chair', 'bathroom', 'detergent', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'mat', 'tvstand', 'clothes_pants', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'novel', 'check', 'keys', 'tray', 'after_shave', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'tooth_paste'] Task:Read response: | { I like to read books in my bedroom. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'tablelamp', 'microwave', 'chair', 'wallshelf', 'hanger', 'floor', 'phone', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'powersocket', 'television', 'coin', 'food_donut', 'ice', 'rag', 'pencil', 'shoes', 'dresser', 'clothes_dress', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'light', 'home_office'] Task:Hang up jacket response: { thoughts : I put clothes on hangers and hang them in the closet, actions : ['[WALK] <bedroom>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[FIND] <hanger>', '[OPEN] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['crayon', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'cat', 'trashcan', 'orchid', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'shower', 'window', 'mousepad', 'microphone', 'dining_room', 'wall', 'pasta', 'bench', 'oven', 'newspaper', 'check', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'home_office', 'bathroom_cabinet'] Task:Read newspaper response: | { Pull out dining room chair. Sit in dining room chair. Open newspaper to section you'd like to read. Read section. Keep reading all sections you'd like. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_ice_cream', 'measuring_cup', 'freezer', 'ceilingfan', 'cpuscreen', 'longboard', 'ceiling', 'character', 'bedroom', 'toaster', 'stereo', 'balanceball', 'oil', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'nightstand', 'photoframe', 'coffe_maker', 'rag', 'doorjamb', 'towel_rack', 'shoes', 'controller', 'napkin', 'bathroom_cabinet', 'laser_pointer', 'dirt'] Task:Pick up phone response: { thoughts : Go to the living room. Find the telephone. Lift up the receiver., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['walllamp', 'knifeblock', 'knife', 'cpuscreen', 'ceiling', 'bookshelf', 'purse', 'face', 'mail', 'mat', 'deck_of_cards', 'tvstand', 'homework', 'pillow', 'dining_room', 'nightstand', 'powersocket', 'box', 'photoframe', 'bed', 'novel', 'check', 'coffe_maker', 'mirror', 'tray', 'hair', 'clothes_dress', 'sink', 'bathroom_cabinet', 'home_office'] Task:Check appearance in mirror response: | { Walk to full-length mirror. Look in mirror. Make sure everything about your appearance is adequate. Adjust clothes as needed. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'dog', 'bathroom', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'shower', 'electric_shaver', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'newspaper', 'bed', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light'] Task:Relax on sofa response: { thoughts : I walk to the living room and find the sofa. I sit on the sofa and get comfortable., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['tablelamp', 'chair', 'knifeblock', 'drawing', 'cpuscreen', 'orchid', 'floor', 'phone', 'bedroom', 'keyboard', 'mat', 'tvstand', 'floor_lamp', 'teeth', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'ice', 'tray', 'after_shave', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'light', 'coffee', 'creditcard'] Task:Turn on lights response: | { Walk to your lamp, switch it on, and lay on your bed } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'juice', 'freezer', 'blow_dryer', 'trashcan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'bookmark', 'ceilinglamp', 'mat', 'window', 'couch', 'microphone', 'clothes_hat', 'pillow', 'wall', 'bench', 'cup', 'keys', 'television', 'towel_rack', 'cd', 'cupboard', 'conditioner', 'door', 'home_office', 'table', 'vase'] Task:Relax on sofa response: { thoughts : Go to the living room and relax on the sofa with a book, actions : ['[RUN] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[DROP] <bookmark>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'chair', 'freezer', 'cat', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'stovefan', 'mat', 'tvstand', 'stereo', 'iron', 'food_kiwi', 'powersocket', 'newspaper', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'conditioner', 'bathtub', 'home_office', 'electrical_outlet'] Task:Turn on radio response: | { Go to the radio. Switch on the power button. Tune the station. Set the volume. Listen to the music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'chair', 'shampoo', 'ceiling', 'folder', 'face', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'oil', 'food_orange', 'dining_room', 'bench', 'box', 'newspaper', 'check', 'video_game_controller', 'mirror', 'curtain', 'towel_rack', 'hair', 'clothes_dress', 'laundry_detergent', 'bathroom_cabinet', 'table', 'clothes_skirt', 'vase', 'scrabble'] Task:Check appearance in mirror response: { thoughts : Walk to full-length mirror. Look in mirror. Make sure everything about your appearance is adequate. Adjust clothes as needed., actions : ['[WALK] <bedroom>', '[WALK] <mirror>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[LOOKAT] <mirror>', '[FIND] <face>', '[TURNTO] <face>', '[LOOKAT] <face>', '[FIND] <hair>', '[TURNTO] <hair>', '[LOOKAT] <hair>', '[FIND] <clothes_dress>', '[TURNTO] <clothes_dress>', '[LOOKAT] <clothes_dress>'] } Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'microwave', 'toilet', 'band-aids', 'bathroom', 'trashcan', 'wallshelf', 'character', 'computer', 'mat', 'faucet', 'couch', 'dining_room', 'wall', 'newspaper', 'oven_mitts', 'tray', 'curtain', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathroom_cabinet', 'table', 'scrabble'] Task:Shut front door response: | { Close the storm door. Lock the storm door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'food_cake', 'mat', 'tvstand', 'shoe-shine_kit', 'homework', 'oil', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'bench', 'oven', 'powersocket', 'toilet_paper', 'kitchen_counter', 'door', 'tooth_paste'] Task:Pick up phone response: { thoughts : walk over and pick up the phone, actions : ['[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'knifeblock', 'drawing', 'wallshelf', 'floor', 'desk', 'keyboard', 'mat', 'tvstand', 'shower', 'faucet', 'stereo', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathtub', 'table', 'dishwasher'] Task:Put in chair response: | { Take a comfortable chair. Place it in the entrance hall } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouse', 'vacuum_cleaner', 'bathtub', 'sink', 'table'] 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>'] } Scene_Objects:['walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'keys', 'television', 'curtain', 'food_onion', 'doorjamb', 'mouse', 'dresser', 'pajamas', 'sink', 'home_office', 'light', 'instrument_guitar'] Task:Turn off TV response: | { Walk over to tv and press power button } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'blender', 'freezer', 'walllamp', 'dough', 'orchid', 'drawing', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'picture', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'dishrack', 'door', 'sink', 'table'] Task:Watch TV response: { thoughts : Turn on the TV, sit on the couch, find a show, and watch it., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['spectacles', 'tablelamp', 'blender', 'microwave', 'chair', 'walllamp', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'mail', 'food_bacon', 'mat', 'stereo', 'faucet', 'homework', 'shower', 'dining_room', 'wall', 'oven', 'keys', 'television', 'food_onion', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'laundry_detergent', 'bag', 'spoon', 'table'] Task:Put away keys response: | { Return keys into a 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', 'drawing', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookshelf', 'mat', 'deck_of_cards', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'bed', 'coffee_filter', 'wine', 'curtain', 'doorjamb', 'kitchen_counter', 'pajamas', 'door', 'food_steak', 'bag', 'light', 'electrical_outlet'] Task:Turn on light response: { thoughts : I walk to the living room. I find the electric outlet. I switch on the light., actions : ['[WALK] <home_office>', '[WALK] <electrical_outlet>', '[FIND] <electrical_outlet>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['spectacles', 'glue', 'tea', 'chair', 'freezer', 'walllamp', 'knifeblock', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'keyboard', 'bookshelf', 'food_bacon', 'tvstand', 'faucet', 'window', 'mousepad', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'toilet_paper', 'diary', 'mouse', 'chessboard', 'spoon', 'home_office', 'table', 'light'] Task:Sit in chair response: | { I sit in a chair to rest and eat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'tablelamp', 'microwave', 'freezer', 'drawing', 'phone', 'bookshelf', 'toaster', 'stovefan', 'tvstand', 'mousepad', 'couch', 'clothes_hat', 'food_orange', 'wall', 'photoframe', 'clothes_gloves', 'bed', 'check', 'television', 'food_rice', 'tray', 'doorjamb', 'dresser', 'hairdryer', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'door'] 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>'] } Scene_Objects:['walllamp', 'nail_polish', 'trashcan', 'milk', 'drawing', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'computer', 'faucet', 'pillow', 'wall', 'photoframe', 'toilet_paper', 'check', 'coffe_maker', 'wine', 'after_shave', 'towel_rack', 'comb', 'controller', 'sink', 'bathroom_cabinet', 'light', 'table', 'instrument_violin', 'teeth'] Task:Get toilet paper response: | { There are extra toilet papers in the bottom cabinet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table'] Task:Change TV channel response: { thoughts : Walk into living room. Find television remote control. Pick up remote control. Press button., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['spectacles', 'pot', 'scissors', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'tvstand', 'faucet', 'dining_room', 'wall', 'bed', 'novel', 'food_food', 'mouthwash', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap', 'shoe_rack'] Task:Added meat to freezer response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'walllamp', 'bathroom', 'bills', 'needle', 'drawing', 'character', 'table_cloth', 'toaster', 'picture', 'floor_lamp', 'window', 'mousepad', 'microphone', 'food_kiwi', 'wall', 'wall_clock', 'newspaper', 'bed', 'television', 'tray', 'cupboard', 'controller', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office'] Task:Turn on light response: { thoughts : I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it., actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TOUCH] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'chair', 'freezer', 'drawing', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'bookshelf', 'keyboard', 'mat', 'shoe-shine_kit', 'window', 'foundation', 'cup', 'photoframe', 'check', 'coffe_maker', 'centerpiece', 'kitchen_counter', 'shoes', 'bathtub', 'sink', 'bathroom_cabinet', 'light', 'napkin', 'instrument_violin'] Task:Look at mirror response: | { I look at my reflection to check my cleanliness. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'mop', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'candle', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'check', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'door', 'bathroom_cabinet', 'light'] Task:Relax on sofa response: { thoughts : I go to the living room, switch off the light, sit in the sofa and do nothing., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'walllamp', 'detergent', 'trashcan', 'food_carrot', 'knifeblock', 'drawing', 'cpuscreen', 'knife', 'bathroom_counter', 'desk', 'keyboard', 'bookshelf', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'mousepad', 'pillow', 'dining_room', 'oven', 'photoframe', 'food_food', 'kitchen_counter', 'dresser', 'sink', 'home_office'] Task:Turn off light response: | { Walk to the lamp. Find the switch. Click the switch off. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'freezer', 'food_butter', 'drawing', 'food_egg', 'floor', 'ceiling', 'character', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'couch', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'novel', 'ice', 'curtain', 'doorjamb', 'kettle', 'pencil', 'headset', 'sink', 'bathroom_cabinet', 'light'] Task:Drink response: { thoughts : Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup, actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[TURNTO] <cup>', '[LOOKAT] <cup>', '[WALK] <cup>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[WALK] <freezer>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>'] } Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'toaster', 'mat', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'photoframe', 'coffe_maker', 'food_rice', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'home_office'] Task:Set up table response: | { Get dishes. Place dishes neatly around table. Get food. Place food on middle of 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', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'floor', 'desk', 'bookshelf', 'plate', 'faucet', 'picture', 'iron', 'window', 'dish_soap', 'food_jam', 'wall', 'nightstand', 'toy', 'cutting_board', 'food_food', 'television', 'curtain', 'pajamas', 'conditioner', 'light', 'dishwasher', 'tooth_paste', 'shoe_rack'] Task:Wash dishes with dishwasher response: { thoughts : Go to the kitchen. Find the dishwasher. Open the dishwasher. Find the plates. Load the plates into the dishwasher. Find the soap. Load the soap into the dishwasher. Close the dishwasher. Turn on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['tablelamp', 'chair', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'floor', 'dvd_player', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'electric_shaver', 'floor_lamp', 'mousepad', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'after_shave', 'cupboard', 'sink', 'home_office', 'table', 'tooth_paste'] Task:Turn on light response: | { Twist the lamp switch until the light goes on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'keys', 'television', 'curtain', 'food_onion', 'doorjamb', 'mouse', 'dresser', 'pajamas', 'sink', 'home_office', 'light', 'instrument_guitar'] Task:Turn off TV response: { thoughts : Walk over to tv and press power button, actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHOFF] <television>'] } Scene_Objects:['fork', 'pot', 'sheets', 'chair', 'freezer', 'walllamp', 'milk', 'knife', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'stovefan', 'window', 'food_jam', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'check', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'table'] Task:Look in refrigerator response: | { Approach the refrigerator. Use the handle to open the refrigerator door. Look at each shelf of the refrigerator. Look in each refrigerator drawer. Close the refrigerator door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'juice', 'tea', 'toilet', 'freezer', 'walllamp', 'dough', 'drawing', 'food_egg', 'floor', 'dvd_player', 'character', 'alcohol', 'stovefan', 'mat', 'shower', 'closetdrawer', 'clothes_hat', 'food_jam', 'wall', 'powersocket', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'laundry_detergent', 'door', 'light', 'dishwasher', 'table'] Task:Go to toilet response: { thoughts : I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[TURNTO] <toilet>', '[LOOKAT] <toilet>', '[WALK] <toilet>', '[TURNTO] <toilet>'] } Scene_Objects:['sponge', 'pot', 'dog', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'computer', 'stovefan', 'faucet', 'oil', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'keys', 'check', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub', 'light'] Task:Keep an eye on stove as something is cooking response: | { Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'pot', 'scissors', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'tvstand', 'faucet', 'dining_room', 'wall', 'bed', 'novel', 'food_food', 'mouthwash', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap', 'shoe_rack'] 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>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'freezer', 'knifeblock', 'drawing', 'wallshelf', 'ceiling', 'phone', 'desk', 'keyboard', 'face', 'toaster', 'laptop', 'tvstand', 'shower', 'stereo', 'homework', 'oil', 'towel', 'oven', 'basket_for_clothes', 'tray', 'towel_rack', 'hair', 'cupboard', 'door', 'bathtub', 'clothes_shirt'] Task:Rain welcome response: | { The robot would greet me and then hand me a towel. It would make an appropriate quip about the weather while I dried off. It would receive the wet towel when I was done. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'needle', 'floor', 'phone', 'mail', 'mat', 'plate', 'faucet', 'stereo', 'couch', 'dustpan', 'dining_room', 'wall', 'bench', 'oven', 'toy', 'cup', 'newspaper', 'standingmirror', 'food_food', 'razor', 'console', 'towel_rack', 'bathtub', 'table'] Task:Set up table response: { thoughts : Get dishes. Place dishes neatly around table. Get food. Place food on middle of table., actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>'] } Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'chair', 'bathroom', 'drawing', 'wallshelf', 'clothes_underwear', 'hanger', 'character', 'bookshelf', 'clothes_jacket', 'piano_bench', 'ceilinglamp', 'shower', 'mousepad', 'teeth', 'pillow', 'check', 'toothbrush_holder', 'coin', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee'] Task:Close door response: | { Push the door shut until it latches. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'jelly', 'drawing', 'floor', 'bedroom', 'table_cloth', 'stovefan', 'mat', 'plate', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'cutting_board', 'bed', 'novel', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'pencil', 'cd', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'vase', 'laser_pointer'] Task:Read book response: { thoughts : I would go lie down in my bed and open the book and start reading., actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['dry_pasta', 'pot', 'measuring_cup', 'microwave', 'chair', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'cleaning_solution', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'couch', 'clothes_pants', 'coffe_maker', 'mirror', 'curtain', 'rag', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'dishwasher'] Task:Clean mirror response: | { Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'chair', 'knifeblock', 'drawing', 'keyboard', 'button', 'stovefan', 'toaster', 'shower', 'window', 'dustpan', 'pillow', 'dining_room', 'nightstand', 'tape', 'novel', 'television', 'tray', 'curtain', 'after_shave', 'doorjamb', 'kitchen_counter', 'cupboard', 'clothes_dress', 'sink', 'bathroom_cabinet', 'light', 'dishwasher'] Task:Browse internet response: { thoughts : I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[TOUCH] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>'] } Scene_Objects:['tablelamp', 'food_salt', 'microwave', 'freezer', 'walllamp', 'bathroom', 'cpuscreen', 'bathroom_counter', 'ceiling', 'keyboard', 'computer', 'food_bacon', 'table_cloth', 'ceilinglamp', 'faucet', 'picture', 'clothes_socks', 'towel', 'dining_room', 'wall', 'pasta', 'bed', 'centerpiece', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'light', 'table', 'colander'] Task:Clean screen response: | { Use a soft rag to wipe the screen until there are no marks on it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'floor', 'ceiling', 'desk', 'keyboard', 'thread', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink', 'light', 'table', 'creditcard'] Task:Browse internet response: { thoughts : Walk to home office. Walk to computer. Switch on Computer., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['filing_cabinet', 'mop', 'chair', 'bathroom', 'food_carrot', 'woman', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'man', 'keyboard', 'mat', 'faucet', 'window', 'foundation', 'nightstand', 'powersocket', 'cup', 'coffe_maker', 'food_food', 'television', 'tray', 'towel_rack', 'cd', 'dresser', 'sink', 'clothes_scarf', 'light'] Task:Greet guests response: | { Stand next to the door. When the door opens from the outside, greet the guests. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_pizza', 'tablelamp', 'food_ice_cream', 'crayon', 'shampoo', 'keyboard', 'mail', 'bookmark', 'stovefan', 'faucet', 'pillow', 'dining_room', 'broom', 'wall', 'love_seat', 'photoframe', 'novel', 'food_food', 'wine', 'tray', 'after_shave', 'shaving_cream', 'kettle', 'headset', 'pajamas', 'laundry_detergent', 'door', 'bathroom_cabinet', 'shoe_rack'] Task:Read book response: { thoughts : Obtain a book from the book shelf. Sit in the easy chair. Read the book. Mark the stopping point with a bookmark. Put the book back on the book shelf., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>'] } Scene_Objects:['microwave', 'dog', 'freezer', 'walllamp', 'cat', 'knifeblock', 'bills', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'faucet', 'clothes_hat', 'broom', 'powersocket', 'bench', 'coffe_maker', 'food_food', 'television', 'mirror', 'rag', 'lighter', 'towel_rack', 'mouse', 'dresser', 'sink', 'table', 'clothes_skirt', 'shoe_rack'] Task:Clean mirror response: | { Spray glass cleaner on mirror. Wipe with a clean cloth. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['fork', 'pot', 'tablelamp', 'chair', 'walllamp', 'trashcan', 'knifeblock', 'bathroom_counter', 'keyboard', 'computer', 'brush', 'tvstand', 'shower', 'faucet', 'mousepad', 'wall', 'bench', 'cup', 'bed', 'photoframe', 'clothes_gloves', 'tray', 'wooden_spoon', 'towel_rack', 'dresser', 'cupboard', 'door', 'bathtub', 'napkin', 'bathroom_cabinet'] Task:Wash monitor response: | { Clean the grime off of my monitor screen when not in use } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'cat', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'phone', 'ceiling', 'dvd_player', 'desk', 'stovefan', 'faucet', 'shower', 'closetdrawer', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'bed', 'tray', 'mouse', 'dresser', 'home_office'] Task:Keep cats out of room response: { thoughts : Stand in the doorway and create a loud noise so the cats will stay out., actions : ['[WALK] <bedroom>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>'] } Scene_Objects:['sponge', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'mat', 'plate', 'faucet', 'ceilinglamp', 'dish_soap', 'mousepad', 'couch', 'dining_room', 'wall', 'oven', 'bench', 'basket_for_clothes', 'towel_rack', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'light'] Task:Wash dirty dishes response: | { Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'keys', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Write an email response: { thoughts : I need to send an email to my friend so I go into my office and sit down at the desk. I turn on the computer and type the email., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[TURNTO] <desk>', '[LOOKAT] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'microwave', 'toilet', 'freezer', 'bathroom', 'trashcan', 'knife', 'cpuscreen', 'ceiling', 'bedroom', 'bookshelf', 'brush', 'stovefan', 'toaster', 'window', 'couch', 'wall_clock', 'powersocket', 'toy', 'bed', 'television', 'ice', 'curtain', 'mouse', 'dresser', 'controller', 'bathroom_cabinet', 'shoe_rack'] Task:Pick up toys response: | { Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'window', 'electric_shaver', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'table', 'light'] Task:Watch TV response: { thoughts : watching TV from sofa, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[DROP] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['filing_cabinet', 'tea', 'chair', 'knifeblock', 'knife', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'character', 'desk', 'bedroom', 'bookshelf', 'food_bacon', 'mat', 'shoe-shine_kit', 'food_jam', 'wall', 'powersocket', 'oven', 'photoframe', 'novel', 'mouthwash', 'coffee_filter', 'tray', 'curtain', 'vacuum_cleaner', 'dresser', 'bathtub', 'soap'] Task:Read to child response: | { Read a book out loud to a 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:['chair', 'walllamp', 'bathroom', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'table_cloth', 'ceilinglamp', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'shelf', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office', 'light', 'table', 'laser_pointer'] Task:Write an email response: { thoughts : Find the computer. Turn on the computer. Open the e-mail program. Create a new message. Write the message., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'milk', 'floor', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'toy', 'basket_for_clothes', 'coffe_maker', 'video_game_controller', 'tray', 'doorjamb', 'kettle', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'table'] Task:Pick up toys response: | { Bend down and pick up the toys off of the floor. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'bookmark', 'stovefan', 'ceilinglamp', 'mat', 'mousepad', 'oil', 'food_peanut_butter', 'broom', 'wall', 'novel', 'diary', 'mouse', 'cupboard', 'clothes_dress', 'door', 'table', 'light', 'dirt'] Task:Browse internet response: { thoughts : Go to office. Turn on computer. Pull out chair. Sit in chair. Use keyboard and mouse., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>'] } Scene_Objects:['filing_cabinet', 'beer', 'crayon', 'freezer', 'walllamp', 'bathroom', 'detergent', 'wallshelf', 'floor', 'ceiling', 'purse', 'computer', 'mat', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'dining_room', 'wall', 'photoframe', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Wipe down baseboards please response: | { Use a rag to get all the dust off the baseboards please. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'chair', 'ground_coffee', 'food_butter', 'dough', 'drawing', 'floor', 'desk', 'bookmark', 'mat', 'faucet', 'floor_lamp', 'window', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'novel', 'television', 'curtain', 'doorjamb', 'chessboard', 'controller', 'maindoor', 'home_office', 'table'] Task:Read book response: { thoughts : First I walk into the living room, I find the lamp and switch it on. Then I find a book, grab it, sit in the sofa, open the book and read it. When I'm finished, I find a bookmark, grab it and put it in the book. Then I close the book, put it back, and switch off the lamp., actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>', '[SWITCHOFF] <floor_lamp>'] } Scene_Objects:['sponge', 'pot', 'microwave', 'walllamp', 'cat', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'toaster', 'faucet', 'window', 'dish_soap', 'dining_room', 'wall', 'oven', 'cup', 'drinking_glass', 'curtain', 'mouse', 'kitchen_counter', 'cd', 'dishrack', 'shoes', 'dresser', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'bathtub'] Task:Clean dishes response: | { Clean the dishes from the 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:['fork', 'pot', 'tablelamp', 'microwave', 'dog', 'walllamp', 'trashcan', 'knifeblock', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'faucet', 'ceilinglamp', 'oil', 'wall', 'oven', 'coffe_maker', 'drinking_glass', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'bag', 'dishwasher', 'colander'] Task:Unload dishwasher response: { thoughts : Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[PUTBACK] <drinking_glass> <cupboard>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <fork> <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTIN] <knife> <kitchen_cabinet>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTIN] <spoon> <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>'] } Scene_Objects:['sheets', 'food_ice_cream', 'toilet', 'walllamp', 'dough', 'drawing', 'knifeblock', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'basket_for_clothes', 'bed', 'food_food', 'television', 'doorjamb', 'mouse', 'pencil', 'dishrack', 'door', 'home_office', 'light', 'bathroom_cabinet'] Task:Turn off light response: | { Grasp light switch, flip light switch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'tablelamp', 'juice', 'cd_player', 'band-aids', 'walllamp', 'cpuscreen', 'bathroom_counter', 'ceiling', 'desk', 'stovefan', 'stereo', 'homework', 'food_orange', 'nightstand', 'bench', 'bed', 'newspaper', 'photoframe', 'coffe_maker', 'check', 'food_onion', 'curtain', 'doorjamb', 'dresser', 'door', 'sink', 'bathtub', 'light'] Task:Listen to music response: { thoughts : I walk in the living room, then I go the the stereo and the cd player and turn them on., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>'] } Scene_Objects:['sponge', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookmark', 'mat', 'mousepad', 'couch', 'food_orange', 'pillow', 'wall', 'wall_clock', 'bed', 'photoframe', 'coffe_maker', 'check', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'home_office', 'table', 'light', 'instrument_guitar', 'scrabble'] Task:Read magazine response: | { Please sit on the couch and read a magazine } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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_oatmeal', 'microwave', 'freezer', 'bathroom', 'nail_polish', 'dough', 'food_carrot', 'orchid', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'brush', 'mat', 'couch', 'pillow', 'food_cereal', 'wall', 'food_vegetable', 'food_food', 'television', 'console', 'cards', 'kitchen_counter', 'cupboard', 'hair', 'door', 'light'] Task:Put groceries in Fridge response: { thoughts : Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_vegetable> <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTIN] <food_carrot> <freezer>', '[FIND] <food_cereal>', '[GRAB] <food_cereal>', '[PUTIN] <food_cereal> <freezer>', '[FIND] <food_oatmeal>', '[GRAB] <food_oatmeal>', '[PUTIN] <food_oatmeal> <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[FIND] <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['glue', 'pot', 'filing_cabinet', 'walllamp', 'orchid', 'bathroom_counter', 'floor', 'phone', 'character', 'desk', 'computer', 'brush', 'toaster', 'mat', 'shower', 'faucet', 'electric_shaver', 'mousepad', 'dining_room', 'nightstand', 'oven', 'toy', 'cup', 'food_onion', 'mouse', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher'] Task:Put toys away response: | { Pick up all the toys on the floor and put them in their correct storage bin or shelf. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'bathroom', 'cpuscreen', 'desk', 'tea_bag', 'alcohol', 'tvstand', 'oven', 'tape', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'toilet_paper', 'television', 'coffee_filter', 'wooden_spoon', 'mouse', 'cd', 'controller', 'maindoor', 'sink', 'home_office', 'light', 'dishwasher', 'soap', 'dirt', 'shoe_rack'] Task:Listen to music response: { thoughts : Walk into living room. Turn on radio., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } 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: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'detergent', 'ceilingfan', 'trashcan', 'drawing', 'knife', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'picture', 'couch', 'wall', 'pasta', 'novel', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'maindoor', 'table', 'light', 'vase', 'tooth_paste'] Task:Watch TV response: { thoughts : I sit on my couch and watch TV in my living room, actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'dough', 'drawing', 'wallshelf', 'floor', 'character', 'bedroom', 'purse', 'mat', 'ceilinglamp', 'couch', 'food_jam', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'bed', 'food_food', 'coffe_maker', 'tray', 'towel_rack', 'mouse', 'headset', 'laundry_detergent', 'sink', 'home_office', 'table'] Task:Read book response: | { Climb into bed, then read the novel } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'freezer', 'detergent', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'shower', 'faucet', 'window', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'check', 'television', 'food_food', 'ice', 'rag', 'towel_rack', 'kitchen_counter', 'cupboard'] Task:Turn on light response: { thoughts : I go home and it's dark so I can not see anything, actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['glue', 'filing_cabinet', 'crayon', 'mop', 'toilet', 'chair', 'cpuscreen', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'stovefan', 'toaster', 'tvstand', 'faucet', 'stereo', 'electric_shaver', 'wall', 'oven', 'food_food', 'television', 'mirror', 'curtain', 'lighter', 'coffee_pot', 'cupboard', 'hairdryer', 'bathroom_cabinet', 'dishwasher'] Task:Shave response: | { Pick up razor. Push the button to turn it on. Move it in a linear motion against the beard growth. Make sure to get the bottom of your chin, your cheeks, and mustache area. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'pot', 'chair', 'freezer', 'detergent', 'trashcan', 'dough', 'clothes_underwear', 'folder', 'stamp', 'bookshelf', 'clothes_jacket', 'table_cloth', 'mousepad', 'couch', 'food_jam', 'clothes_hat', 'pillow', 'nightstand', 'bench', 'oven', 'cutting_board', 'bed', 'food_food', 'check', 'doorjamb', 'console', 'cupboard', 'home_office', 'table'] Task:Pick up phone response: { thoughts : i go find the phone. i pick up the phone, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['tablelamp', 'chair', 'freezer', 'food_carrot', 'milk', 'knifeblock', 'floor', 'ceiling', 'phone', 'bedroom', 'purse', 'toaster', 'stovefan', 'shower', 'faucet', 'couch', 'form', 'pillow', 'wall', 'oven', 'food_food', 'oven_mitts', 'shaving_cream', 'kitchen_counter', 'cd', 'dresser', 'cupboard', 'bathtub', 'table', 'tooth_paste'] Task:Get glass of milk response: | { Get an empty glass. Take milk from refrigerator and open it. Pour milk into 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:['food_salt', 'crayon', 'microwave', 'food_carrot', 'orchid', 'knifeblock', 'bills', 'floor', 'bedroom', 'stamp', 'envelope', 'clothes_jacket', 'bookmark', 'toaster', 'faucet', 'towel', 'dining_room', 'wall', 'coffe_maker', 'food_food', 'video_game_controller', 'tray', 'lighter', 'diary', 'kitchen_counter', 'cupboard', 'sink', 'soap', 'scrabble', 'hands_both'] Task:Wash hands response: { thoughts : I have had my lunch and walked towards the sink and applied soap to my hands and washed cleanly., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>'] } Scene_Objects:['ironing_board', 'sheets', 'tablelamp', 'detergent', 'knifeblock', 'bathroom_counter', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'window', 'couch', 'pillow', 'bowl', 'nightstand', 'food_cheese', 'video_game_controller', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'pajamas', 'bag', 'dishwasher', 'board_game', 'clothes_shirt'] Task:Iron shirt response: | { Set up an ironing board and an iron. Lay a shirt on board. Run iron over shirt until it is free of wrinkles. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'food_butter', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'mop_bucket', 'ceilinglamp', 'tvstand', 'iron', 'window', 'mousepad', 'microphone', 'towel', 'dining_room', 'bowl', 'wall', 'powersocket', 'bench', 'cup', 'novel', 'television', 'coin', 'rag', 'doorjamb', 'headset', 'light'] Task:Turn on light response: { thoughts : I walk in to the living room. I find the light switch. I turn on the lights., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['dry_pasta', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'deck_of_cards', 'mousepad', 'couch', 'pillow', 'wall', 'child', 'bed', 'coin', 'coffee_filter', 'doorjamb', 'centerpiece', 'door', 'table', 'light', 'dishwasher'] Task:Let baby learn how to walk response: | { The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blow_dryer', 'bathroom', 'food_carrot', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stamp', 'bedroom', 'food_cake', 'computer', 'shower', 'picture', 'oven', 'basket_for_clothes', 'photoframe', 'food_food', 'check', 'towel_rack', 'mouse', 'pencil', 'shoes', 'comb', 'hairbrush', 'cupboard', 'laundry_detergent', 'sink', 'napkin', 'light', 'washing_machine'] Task:Wash clothes response: { thoughts : Pick up my dirty clothes, load the washer, add detergent, turn on washer, actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>'] } Scene_Objects:['sheets', 'sponge', 'tablelamp', 'mop', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'stamp', 'wine_glass', 'clothes_socks', 'couch', 'pillow', 'wall', 'nightstand', 'food_cheese', 'bed', 'photoframe', 'food_food', 'check', 'doorjamb', 'door', 'sink', 'bag', 'bathroom_cabinet', 'table', 'light'] Task:Entertain response: | { Give guests wine, cheese, crackers and sit and talk } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'walllamp', 'orchid', 'floor', 'ceiling', 'character', 'desk', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'dish_soap', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'coffe_maker', 'food_food', 'kitchen_counter', 'cupboard', 'controller', 'sink', 'dishwasher', 'soap', 'clothes_shirt', 'teeth'] Task:Wash dishes with dishwasher response: { thoughts : Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['pot', 'microwave', 'walllamp', 'nail_polish', 'knifeblock', 'drawing', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'character', 'desk', 'faucet', 'stereo', 'shower', 'mousepad', 'couch', 'wall', 'oven', 'cup', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'chessboard', 'cupboard', 'sink', 'table', 'dirt'] Task:Get glass of water response: | { Get a glass from a cabinet. Hold it under the sink and turn the cold water on. Fill the glass. Turn off the water. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'measuring_cup', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'oven', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office'] Task:Make coffee response: { thoughts : Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['fork', 'filing_cabinet', 'blender', 'chair', 'freezer', 'walllamp', 'nail_polish', 'detergent', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'desk', 'computer', 'mat', 'ceilinglamp', 'plate', 'faucet', 'mousepad', 'candle', 'microphone', 'bowl', 'wall', 'nightstand', 'bench', 'bed', 'keys', 'food_food', 'table'] Task:Eat response: | { I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'tea', 'band-aids', 'walllamp', 'nail_polish', 'knifeblock', 'bills', 'cpuscreen', 'hanger', 'shampoo', 'phone', 'floor', 'bedroom', 'desk', 'toaster', 'stereo', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bowl', 'dining_room', 'bench', 'newspaper', 'clothes_gloves', 'coffe_maker', 'curtain', 'diary', 'hairbrush', 'bathroom_cabinet'] Task:Listen to music response: { thoughts : I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['sheets', 'pot', 'microwave', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'orchid', 'wallshelf', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'faucet', 'wall', 'oven', 'powersocket', 'bench', 'after_shave', 'curtain', 'centerpiece', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'soap'] Task:Wipe down counter response: | { Clean counter } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'light'] Task:Work response: { thoughts : you go into your office, switch on the light, find chair at desk, sit in the chair, switch on the computer and work., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['scissors', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'window', 'toaster', 'clothes_pants', 'broom', 'powersocket', 'bench', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'dresser', 'hair', 'door', 'sink', 'clothes_shirt'] Task:Get dressed response: | { Get some clothes together that make an appropriate outfit. Put them on } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'stovefan', 'toaster', 'laptop', 'faucet', 'closetdrawer', 'couch', 'bowl', 'dining_room', 'wall', 'oven', 'bench', 'bed', 'coffe_maker', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub'] Task:Cook some food response: { thoughts : I switch on the stove and cook my groceries there., actions : ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[SWITCHON] <oven>', '[FIND] <bowl>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <oven>', '[FIND] <food_food>', '[SWITCHOFF] <oven>'] } Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'desk', 'bookshelf', 'cleaning_solution', 'mat', 'tvstand', 'faucet', 'shower', 'couch', 'wall', 'nightstand', 'bench', 'toy', 'photoframe', 'mirror', 'tray', 'towel_rack', 'paper_towel', 'door', 'sink', 'clothes_scarf', 'bathroom_cabinet'] Task:Clean mirror response: | { First spray the mirrors with Windex or window type spray. Take paper towels and wipe until sparkly clean. If they have streaks, repeat the process. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'walllamp', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'ceilinglamp', 'plate', 'faucet', 'window', 'dish_soap', 'mousepad', 'bowl', 'wall', 'oven', 'powersocket', 'check', 'mouthwash', 'after_shave', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'bathtub', 'dishwasher'] Task:Wash dishes by hand response: { thoughts : I go to the kitchen and turn on the faucet. I get dish soap and put it into the sink. I grab a sponge and a bowl and start cleaning it. I put the bowl into the dishrack. I find a plate and clean it as well. I put it into the dishrack, turn off the faucet and put the sponge back., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <bowl>', '[GRAB] <bowl>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <bowl>', '[SCRUB] <bowl>', '[RINSE] <bowl>', '[FIND] <dishrack>', '[PUTBACK] <bowl> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>'] } Scene_Objects:['pot', 'microwave', 'toilet', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'tea_bag', 'mat', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'pasta', 'nightstand', 'photoframe', 'novel', 'food_food', 'tray', 'curtain', 'doorjamb', 'door', 'table', 'light', 'board_game'] Task:Read book response: | { Bring book, lie on the sofa, read book } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'walllamp', 'trashcan', 'orchid', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'bookshelf', 'clothes_jacket', 'faucet', 'couch', 'clothes_pants', 'form', 'wall', 'cutting_board', 'photoframe', 'check', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'washing_machine'] Task:Wash clothes response: { thoughts : Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes, actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_jacket>', '[GRAB] <clothes_jacket>', '[PUTBACK] <clothes_jacket> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['sheets', 'pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'drawing', 'ceiling', 'dvd_player', 'character', 'bookshelf', 'keyboard', 'brush', 'ceilinglamp', 'toaster', 'mat', 'window', 'nightstand', 'bench', 'photoframe', 'food_food', 'after_shave', 'diary', 'kettle', 'shoes', 'chessboard', 'dresser', 'door', 'bathroom_cabinet', 'colander'] Task:Dust response: | { Using soft brush, carefully dust both Indonesian wedding doll statues. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'freezer', 'trashcan', 'food_carrot', 'orchid', 'floor', 'ceiling', 'thread', 'mail', 'button', 'food_bacon', 'bookmark', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'wall', 'bench', 'cup', 'food_food', 'razor', 'television', 'food_donut', 'towel_rack', 'console', 'kitchen_counter', 'hairbrush', 'cupboard', 'sink', 'vase'] 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>'] } Scene_Objects:['microwave', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'stovefan', 'mat', 'window', 'electric_shaver', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'oven', 'toy', 'bed', 'mouthwash', 'tray', 'doorjamb', 'mouse', 'pencil', 'chessboard', 'door', 'bathtub', 'instrument_guitar', 'light', 'soap'] Task:Turn on light response: | { Hit light switch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'tablelamp', 'blender', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'orchid', 'character', 'bedroom', 'bookshelf', 'alcohol', 'button', 'toaster', 'stereo', 'homework', 'electric_shaver', 'mousepad', 'couch', 'bowl', 'toy', 'clothes_gloves', 'coffe_maker', 'kitchen_counter', 'conditioner', 'napkin', 'table', 'light', 'dishwasher'] 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:['tablelamp', 'crayon', 'toilet', 'chair', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'computer', 'tvstand', 'faucet', 'stereo', 'food_orange', 'photoframe', 'novel', 'television', 'curtain', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'home_office'] Task:Get dressed response: | { I get dressed in my bedroom in the mornings. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'tea_bag', 'mat', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'photoframe', 'check', 'mouthwash', 'food_food', 'food_donut', 'wine', 'curtain', 'doorjamb', 'console', 'dresser', 'door', 'light'] Task:Pick up toys response: { thoughts : Bend down and pick up the toys off of the floor., actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['pot', 'juice', 'measuring_cup', 'microwave', 'chair', 'freezer', 'band-aids', 'walllamp', 'detergent', 'knifeblock', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'couch', 'wall', 'oven', 'cup', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'food_snack', 'sink', 'napkin', 'home_office'] Task:Have snack response: | { Pour soda into a glass. Get pretzels out of bag. Eat and drink } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['water_glass', 'pot', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'oil', 'mousepad', 'food_peanut_butter', 'wall', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light'] Task:Drink response: { thoughts : I need to go to Kitchen. Get a cup. Fill cup. Drink, actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['spectacles', 'sheets', 'pot', 'tablelamp', 'tea', 'microwave', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'knifeblock', 'bathroom_counter', 'floor', 'remote_control', 'table_cloth', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'tvstand', 'wall', 'nightstand', 'bed', 'newspaper', 'photoframe', 'television', 'food_rice', 'console', 'pencil', 'bathroom_cabinet'] Task:Watch TV response: | { Watching tv with a remote is always fun; lay back, relax and enjoy; } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'dresser', 'sink', 'instrument_violin'] Task:Watch TV response: { thoughts : I go to the the living room, sit down on the sofa, and then I switch on the TV with the TV remote, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['sponge', 'tablelamp', 'chair', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'character', 'bookshelf', 'mat', 'tvstand', 'stereo', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bed', 'photoframe', 'video_game_controller', 'curtain', 'doorjamb', 'lighter', 'kitchen_counter', 'dresser', 'cupboard', 'bathroom_cabinet', 'instrument_guitar'] Task:Listen to music response: | { Put iPhone into speaker holder, open up the Pandora app, listen to music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'detergent', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'wall_clock', 'television', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'table', 'light'] Task:Pet cat response: { thoughts : I see my cat on the couch so I walk over, sit down and pet the cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>'] } Scene_Objects:['sheets', 'tablelamp', 'microwave', 'bathroom', 'detergent', 'wallshelf', 'hanger', 'floor', 'character', 'keyboard', 'envelope', 'clothes_jacket', 'stovefan', 'stereo', 'window', 'food_peanut_butter', 'nightstand', 'clothes_gloves', 'food_food', 'food_donut', 'after_shave', 'centerpiece', 'towel_rack', 'cupboard', 'door', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'table', 'home_office'] Task:Put on coat response: | { I remove my scarf from a coat peg in the entrance hall. I wrap the scarf around my neck } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'beer', 'toilet', 'freezer', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'ceiling', 'phone', 'character', 'keyboard', 'toaster', 'mat', 'floor_lamp', 'oil', 'pillow', 'dining_room', 'nightstand', 'wall_clock', 'bench', 'novel', 'television', 'curtain', 'doorjamb', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table'] Task:Read book response: { thoughts : Turn a light on and read a book in the bedroom., actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['fork', 'beer', 'microwave', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'dough', 'orchid', 'dvd_player', 'keyboard', 'piano_bench', 'brush', 'faucet', 'pillow', 'dining_room', 'powersocket', 'newspaper', 'coffe_maker', 'television', 'wine', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'conditioner', 'clothes_scarf', 'bathtub', 'bathroom_cabinet', 'creditcard'] Task:Lock door response: | { Turn the lock. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'freezer', 'walllamp', 'trashcan', 'food_carrot', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bedroom', 'character', 'ceilinglamp', 'tvstand', 'faucet', 'dustpan', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'photoframe', 'bed', 'food_food', 'television', 'food_donut', 'food_rice', 'doorjamb', 'shaving_cream', 'table', 'vase'] Task:Put groceries in Fridge response: { thoughts : walk to kitchen and seprate the groceries and arrange in fridge., actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>'] } Scene_Objects:['filing_cabinet', 'scissors', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'centerpiece', 'kitchen_counter', 'door', 'table', 'light', 'creditcard'] Task:Watch TV response: | { I like to set on my sofa.Turn on the tv. And watch Perry Mason. Monday's through Friday's. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'spectacles', 'food_salt', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'purse', 'computer', 'ceilinglamp', 'window', 'mousepad', 'food_noodles', 'wall', 'powersocket', 'clothes_gloves', 'food_food', 'toilet_paper', 'television', 'check', 'tray', 'doorjamb', 'cards', 'mouse', 'door', 'light', 'table'] Task:Put groceries in Fridge response: { thoughts : Open the fridge, put the groceries in the fridge and close it., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'microwave', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table'] Task:Watch TV response: | { Sit on the couch. Get comfortable. Switch on the television. Stare at the television. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'computer', 'mat', 'shoe-shine_kit', 'oil', 'pillow', 'wall', 'pasta', 'powersocket', 'cup', 'food_food', 'video_game_controller', 'toothbrush_holder', 'television', 'doorjamb', 'kettle', 'door', 'light', 'clothes_skirt', 'coffee'] Task:Turn on light response: { thoughts : switching on light in an area, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['beer', 'microwave', 'toilet', 'chair', 'freezer', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'window', 'pillow', 'wall', 'powersocket', 'oven', 'bench', 'food_cheese', 'bed', 'photoframe', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'lighter', 'kitchen_counter', 'cupboard', 'home_office'] Task:Eat cheese response: | { Open fridge. Get cheese. Eat it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'window', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'nightstand', 'cutting_board', 'shelf', 'clothes_gloves', 'food_food', 'coffe_maker', 'wooden_spoon', 'tray', 'kitchen_counter', 'sink', 'bathroom_cabinet'] Task:Keep an eye on stove as something is cooking response: { thoughts : Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done, actions : ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <pot>', '[TURNTO] <pot>', '[LOOKAT] <pot>', '[FIND] <wall_clock>', '[TURNTO] <wall_clock>', '[LOOKAT] <wall_clock>', '[SWITCHOFF] <oven>'] } Scene_Objects:['band-aids', 'trashcan', 'woman', 'drawing', 'orchid', 'floor', 'ceiling', 'man', 'envelope', 'tvstand', 'stereo', 'shoe-shine_kit', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'cup', 'food_food', 'coffe_maker', 'razor', 'tray', 'doorjamb', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table', 'light', 'home_office'] Task:Hang with friends response: | { Sit with friends. Talk } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'keyboard', 'brush', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'stovefan', 'shoe-shine_kit', 'pillow', 'wall', 'powersocket', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light'] Task:Watch TV response: { thoughts : Walk into the living room. Sit on the couch. Turn on TV., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'detergent', 'drawing', 'knifeblock', 'food_egg', 'floor', 'computer', 'toaster', 'stovefan', 'tvstand', 'stereo', 'window', 'food_noodles', 'mousepad', 'couch', 'pillow', 'dining_room', 'nightstand', 'pasta', 'bed', 'oven_mitts', 'tray', 'curtain', 'lighter', 'towel_rack', 'shoes', 'cd', 'pajamas'] Task:Put clothes away response: | { I take clean clothes and either place them in dresser drawers or hang them in a closet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'stovefan', 'mat', 'faucet', 'mousepad', 'towel', 'wall', 'wall_clock', 'oven', 'bench', 'cutting_board', 'shelf', 'food_rice', 'tray', 'after_shave', 'towel_rack', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'soap', 'laser_pointer', 'dirt', 'hands_both'] Task:Hand washing response: { thoughts : Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[WASH] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>'] } Scene_Objects:['pot', 'tablelamp', 'ground_coffee', 'walllamp', 'trashcan', 'knifeblock', 'hanger', 'floor', 'phone', 'character', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'mousepad', 'pillow', 'wall', 'oven', 'cutting_board', 'television', 'food_rice', 'water', 'tray', 'kitchen_counter', 'cd', 'dresser', 'cupboard', 'bathroom_cabinet', 'home_office'] Task:Make coffee response: | { Get my coffee pot going } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'food_ice_cream', 'hanger', 'floor', 'ceiling', 'character', 'bookshelf', 'mat', 'tvstand', 'faucet', 'ceilinglamp', 'wall', 'powersocket', 'photoframe', 'clothes_gloves', 'bed', 'food_food', 'check', 'ice', 'doorjamb', 'pencil', 'kitchen_counter', 'laundry_detergent', 'door', 'napkin', 'home_office', 'light', 'dishwasher'] Task:Turn on light response: { thoughts : switching on the light, actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light'] Task:Greet guests response: | { Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek. } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.