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:['sponge', 'microwave', 'toilet', 'jelly', 'freezer', 'ground_coffee', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'button', 'mat', 'shower', 'picture', 'dustpan', 'food_orange', 'form', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'light_bulb', 'food_food', 'doorjamb', 'cd', 'door', 'light'] Task:Added meat to freezer response: { thoughts : After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'beer', 'tea', 'freezer', 'walllamp', 'nail_polish', 'bathroom', 'needle', 'cpuscreen', 'keyboard', 'mail', 'computer', 'stovefan', 'ceilinglamp', 'iron', 'clothes_pants', 'food_orange', 'pillow', 'dining_room', 'bench', 'bed', 'coffe_maker', 'television', 'doorjamb', 'pencil', 'maindoor', 'napkin', 'instrument_violin'] Task:Pick up phone response: | { I walk to the home office, find where the phone is and lift the reciever. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dog', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'bathtub', 'sink', 'table', 'light', 'dishwasher'] Task:Relax on sofa response: { thoughts : walk into living room and go to sofa and turn on tv, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[DROP] <remote_control>'] } Scene_Objects:['filing_cabinet', 'band-aids', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'food_bacon', 'mat', 'tvstand', 'faucet', 'window', 'clothes_pants', 'wall', 'powersocket', 'after_shave', 'doorjamb', 'cd', 'dresser', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'vase'] Task:Turn on light response: | { Turning on lights } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'food_bread', 'freezer', 'food_carrot', 'milk', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'mousepad', 'garbage_can', 'clothes_hat', 'food_orange', 'food_dessert', 'wall', 'powersocket', 'food_vegetable', 'food_cheese', 'doorjamb', 'lighter', 'mouse', 'coffee', 'door', 'light', 'colander', 'teeth'] Task:Rotate stock in refrigerator response: { thoughts : Throw out expired items, put older items in front., actions : ['[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[TURNTO] <food_bread>', '[LOOKAT] <food_bread>', '[PUTOBJBACK] <food_bread>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[TURNTO] <food_cheese>', '[LOOKAT] <food_cheese>', '[FIND] <garbage_can>', '[PUTBACK] <food_cheese> <garbage_can>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[TURNTO] <food_cheese>', '[LOOKAT] <food_cheese>', '[PUTOBJBACK] <food_cheese>', '[FIND] <food_dessert>', '[TURNTO] <food_dessert>', '[LOOKAT] <food_dessert>', '[PUSH] <food_dessert>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <milk>', '[GRAB] <milk>', '[TURNTO] <milk>', '[LOOKAT] <milk>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>'] } Scene_Objects:['toilet', 'ceilingfan', 'drawing', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'remote_control', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'dining_room', 'wall', 'tape', 'photoframe', 'television', 'tray', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'sink', 'instrument_guitar', 'table', 'bathroom_cabinet'] Task:Watch TV response: | { Walk to living room. Find remote control. Find television. Point remote at television. Press \ on\ button. 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:['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: { thoughts : Clean counter, actions : ['[WALK] <dining_room>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <rag>', '[SQUEEZE] <rag>', '[SWITCHOFF] <faucet>', '[WALK] <kitchen_counter>', '[WIPE] <kitchen_counter>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'bookshelf', 'keyboard', 'computer', 'food_bacon', 'stovefan', 'mousepad', 'wall', 'nightstand', 'powersocket', 'photoframe', 'novel', 'check', 'television', 'food_rice', 'mouse', 'dresser', 'light', 'dishwasher', 'vase'] Task:Read book response: | { Walk to bookcase in office. Take book from desk. Take book over to chair. Sit down in the chair. Open book and then 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:['blender', 'freezer', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'brush', 'tvstand', 'stereo', 'window', 'closetdrawer', 'towel', 'wall', 'powersocket', 'tape', 'food_food', 'television', 'curtain', 'doorjamb', 'vacuum_cleaner', 'dresser', 'door', 'clothes_scarf', 'dishwasher', 'board_game'] Task:vacuum carpet response: { thoughts : I bring my vacuum cleaner into the living room. I plug it into the wall. I press the on switch on the vacuum cleaner. I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet. I turn the vacuum cleaner off. I take the vacuum cleaner back to the hall closet., actions : ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['juice', 'toilet', 'chair', 'blow_dryer', 'food_carrot', 'orchid', 'knifeblock', 'cpuscreen', 'desk', 'clothes_jacket', 'toaster', 'deck_of_cards', 'tvstand', 'dining_room', 'bench', 'basket_for_clothes', 'novel', 'television', 'after_shave', 'coffee_pot', 'mouse', 'cupboard', 'clothes_dress', 'hairdryer', 'home_office', 'colander', 'clothes_shirt', 'washing_machine', 'coffee', 'shoe_rack'] Task:Wash clothes response: | { Walk to the kitchen. Find the washing machine. Open the washing machine. Find the basket for clothes. Find the clothes_dress. Grab the clothes_dress. Put the clothes_dress into the washing machine. Find the clothes_shirt. Grab the clothes_shirt. Put the clothes_shirt into the washing machine. Close the washing machine. Switch on the washing machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'juice', 'microwave', 'freezer', 'bills', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'ceilinglamp', 'plate', 'window', 'mousepad', 'couch', 'dining_room', 'broom', 'wall', 'powersocket', 'novel', 'food_food', 'mouthwash', 'television', 'curtain', 'rag', 'towel_rack', 'kitchen_counter', 'comb', 'door', 'laser_pointer'] Task:Put groceries in Fridge response: { thoughts : Walk to the kitchen. Open the fridge, take the groceries and put in it. Closed the fridge,, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['food_bread', 'chair', 'detergent', 'food_carrot', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'toaster', 'balanceball', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'tray', 'doorjamb', 'cards', 'mouse', 'shaving_cream', 'shoes', 'dresser', 'cupboard', 'door', 'napkin', 'home_office', 'light', 'vase'] Task:Turn on light response: | { switching on light in an 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:['dry_pasta', 'pot', 'food_pizza', 'tablelamp', 'microwave', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_bacon', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'food_food', 'television', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light'] Task:Cook some food response: { thoughts : go to the kitchen and cook some thing to eat, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <oven>', '[OPEN] <oven>', '[FIND] <food_pizza>', '[GRAB] <food_pizza>', '[PUTIN] <food_pizza> <oven>', '[SWITCHON] <oven>'] } Scene_Objects:['dry_pasta', 'food_bread', 'microwave', 'dog', 'chair', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'oven', 'newspaper', 'check', 'television', 'coffee_filter', 'oven_mitts', 'coin', 'curtain', 'lighter', 'maindoor', 'napkin', 'table'] Task:Change TV channel response: | { Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'mop', 'chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'bookshelf', 'computer', 'toaster', 'faucet', 'mousepad', 'closetdrawer', 'clothes_hat', 'wall', 'powersocket', 'bed', 'standingmirror', 'television', 'doorjamb', 'cards', 'mouse', 'dresser', 'hair', 'light', 'table'] Task:Turn on light response: { thoughts : I walk to wall. I put my hand on the switch. I push the button. I turn on the lights., actions : ['[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['sponge', 'food_salt', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'desk', 'brush', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'clothes_pants', 'dining_room', 'wall', 'toy', 'basket_for_clothes', 'bed', 'television', 'coin', 'coffee_filter', 'food_rice', 'curtain', 'cupboard', 'controller', 'table', 'dishwasher'] Task:Watch TV response: | { Watch TV in the living room. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'pot', 'microwave', 'walllamp', 'food_butter', 'knifeblock', 'drawing', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'tvstand', 'balanceball', 'picture', 'shower', 'oil', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'television', 'coin', 'diary', 'mouse', 'cupboard', 'bag', 'bathroom_cabinet', 'vase', 'shoe_rack'] Task:Make popcorn response: { thoughts : Lay popcorn bag flat inside microwave and press popcorn button to start., actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <microwave>', '[TURNTO] <microwave>', '[OPEN] <microwave>', '[PUTIN] <food_food> <microwave>', '[CLOSE] <microwave>', '[SWITCHON] <microwave>'] } Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'food_bacon', 'alcohol', 'ceilinglamp', 'pillow', 'wall', 'powersocket', 'bed', 'curtain', 'doorjamb', 'kettle', 'mouse', 'dresser', 'cupboard', 'door', 'maindoor', 'light', 'creditcard'] Task:Turn on light response: | { I open the room door and press the light button 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:['filing_cabinet', 'microwave', 'trashcan', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'ceilinglamp', 'mat', 'faucet', 'shower', 'couch', 'towel', 'wall', 'bench', 'oven', 'photoframe', 'bed', 'mouse', 'kitchen_counter', 'dresser', 'pajamas', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : I go to the sink, turn on the water, put soap on my hands, rub them together, then rinse them off and turn off the water. I then towel off my hands., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[WIPE] <hands_both>'] } Scene_Objects:['fork', 'food_bread', 'blender', 'food_salt', 'toilet', 'jelly', 'freezer', 'trashcan', 'clothes_underwear', 'longboard', 'phone', 'character', 'keyboard', 'thread', 'clothes_jacket', 'mop_bucket', 'stereo', 'electric_shaver', 'window', 'pillow', 'dining_room', 'powersocket', 'cup', 'television', 'tray', 'curtain', 'shaving_cream', 'kitchen_counter', 'laundry_detergent', 'home_office'] Task:Listen to music response: | { turn radio on, 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:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'tvstand', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'food_jam', 'wall', 'nightstand', 'oven', 'newspaper', 'food_food', 'vacuum_cleaner', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table', 'hands_both'] Task:Wash hands response: { thoughts : I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>'] } Scene_Objects:['microwave', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'laptop', 'faucet', 'mousepad', 'candle', 'microphone', 'food_orange', 'wall', 'photoframe', 'check', 'mouthwash', 'after_shave', 'doorjamb', 'cupboard', 'pajamas', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'light', 'soap', 'clothes_shirt', 'hands_both'] Task:Wash hands response: | { I go into the bathroom and turn on the light. I walk to the sink and turn on the water. I grab the soap and wash my hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'chair', 'walllamp', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'mousepad', 'wall', 'bench', 'photoframe', 'novel', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'shaving_cream', 'door', 'bathroom_cabinet', 'light', 'home_office'] Task:Read response: { thoughts : We pick out a book from the bookshelf and read it., actions : ['[WALK] <novel>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['pot', 'blender', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'orchid', 'food_egg', 'kitchen_cabinet', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'ceilinglamp', 'toaster', 'faucet', 'wall', 'oven', 'food_cheese', 'food_food', 'food_donut', 'food_rice', 'wine', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'dishwasher'] Task:Cook some food response: | { Walk into kitchen. Open fridge. Take food from fridge. Close fridge. Put food on kitchen counter. Prepare food. Turn on stove. Open kitchen cabinet. Take pot. Close cabinet. Put food in pot. Put pot on stove. Cook 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:['glue', 'pot', 'microwave', 'freezer', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'alcohol', 'stovefan', 'toaster', 'tvstand', 'couch', 'wall', 'oven', 'cutting_board', 'toy', 'food_cheese', 'novel', 'coffe_maker', 'food_food', 'television', 'tray', 'shaving_cream', 'cards', 'kitchen_counter', 'shoes', 'light'] Task:Put groceries in Fridge response: { thoughts : put away groceries in fridge. open the door, put on shelf, close the door., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'blow_dryer', 'bathroom', 'detergent', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'shower', 'food_jam', 'towel', 'dining_room', 'wall', 'powersocket', 'after_shave', 'doorjamb', 'centerpiece', 'door', 'maindoor', 'light', 'coffee'] Task:Turn on light response: | { I walk to room. I enter room. I find where the lightswitch is. I turn on the lights with the lightswitch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'blender', 'food_ice_cream', 'microwave', 'chair', 'walllamp', 'bathroom', 'trashcan', 'milk', 'floor', 'bedroom', 'computer', 'toaster', 'plate', 'shoe-shine_kit', 'oil', 'wall', 'newspaper', 'coffe_maker', 'tray', 'centerpiece', 'console', 'pencil', 'kitchen_counter', 'cupboard', 'spoon', 'dishwasher', 'laser_pointer', 'clothes_shirt'] Task:Wash dishes with dishwasher response: { thoughts : I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['dry_pasta', 'food_bread', 'walllamp', 'bathroom', 'cpuscreen', 'kitchen_cabinet', 'floor', 'tea_bag', 'toaster', 'mat', 'stereo', 'balanceball', 'dish_soap', 'towel', 'wall', 'oven', 'bed', 'light_bulb', 'novel', 'coffe_maker', 'check', 'coin', 'food_donut', 'tray', 'doorjamb', 'towel_rack', 'sink', 'dishwasher', 'vase', 'clothes_shirt'] Task:Wash dishes with dishwasher response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'blender', 'walllamp', 'dough', 'knifeblock', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'bookshelf', 'clothes_jacket', 'faucet', 'balanceball', 'pillow', 'wall', 'oven', 'food_food', 'wooden_spoon', 'curtain', 'kitchen_counter', 'headset', 'dishrack', 'cupboard', 'maindoor', 'sink', 'table', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Washing Hands, actions : ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[TOUCH] <soap>', '[PUTOBJBACK] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['spectacles', 'sheets', 'drawing', 'cpuscreen', 'ceiling', 'desk', 'bookmark', 'mat', 'plate', 'stereo', 'deck_of_cards', 'mousepad', 'couch', 'clothes_hat', 'clothes_pants', 'bench', 'clothes_gloves', 'video_game_controller', 'curtain', 'towel_rack', 'cd', 'dishrack', 'chessboard', 'pajamas', 'laundry_detergent', 'maindoor', 'door', 'sink', 'bathroom_cabinet', 'clothes_shirt'] Task:Listen to music response: | { Find the radio; switch on the radio and 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', 'juice', 'walllamp', 'food_carrot', 'knife', 'orchid', 'cpuscreen', 'phone', 'dvd_player', 'desk', 'mop_bucket', 'toaster', 'laptop', 'tvstand', 'closetdrawer', 'food_jam', 'pillow', 'dining_room', 'food_food', 'television', 'oven_mitts', 'water', 'after_shave', 'pencil', 'hairbrush', 'clothes_dress', 'door', 'table', 'dishwasher', 'light'] Task:Drink response: { thoughts : I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass., actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>'] } Scene_Objects:['dry_pasta', 'pot', 'walllamp', 'drawing', 'bills', 'knifeblock', 'hanger', 'floor', 'phone', 'ceilinglamp', 'tvstand', 'faucet', 'iron', 'window', 'mousepad', 'couch', 'food_peanut_butter', 'clothes_hat', 'clothes_pants', 'wall', 'basket_for_clothes', 'clothes_gloves', 'check', 'television', 'after_shave', 'headset', 'maindoor', 'spoon', 'home_office', 'table'] Task:Relax on sofa response: | { allow sofa to support weight in order to decrease gravity induced entropy } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'walllamp', 'dough', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'novel', 'television', 'doorjamb', 'diary', 'shoes', 'dresser', 'door', 'clothes_shirt'] Task:Watch TV response: { thoughts : I walk into the living room. I sit on the couch. I pick up the remote control. I push the power button. I push the guide button and look for my favorite show The Middle. I click that channel and enjoy my show., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUSH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['glue', 'pot', 'food_bread', 'tablelamp', 'microwave', 'freezer', 'ceilingfan', 'food_carrot', 'orchid', 'longboard', 'bookshelf', 'mail', 'food_bacon', 'brush', 'ceilinglamp', 'tvstand', 'stereo', 'balanceball', 'clothes_pants', 'pillow', 'wall', 'bench', 'powersocket', 'curtain', 'mouse', 'controller', 'maindoor', 'home_office', 'board_game', 'shoe_rack'] Task:Listen to music response: | { Go to the living room. Find the radio. Turn on the radio. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'keys', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'light', 'table'] Task:Relax on sofa response: { thoughts : I want to relax on the sofa to some relaxing music in the living room., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <stereo>', '[PLUGIN] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['sheets', 'freezer', 'ground_coffee', 'bathroom', 'ceilingfan', 'drawing', 'clothes_underwear', 'floor', 'food_cake', 'toaster', 'mousepad', 'dining_room', 'oven', 'tape', 'box', 'photoframe', 'coin', 'curtain', 'shaving_cream', 'coffee_pot', 'headset', 'dishrack', 'cupboard', 'sink', 'clothes_scarf', 'home_office', 'dishwasher', 'soap', 'board_game', 'washing_machine'] Task:Wash clothes response: | { Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer 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:['sheets', 'tablelamp', 'detergent', 'ceilingfan', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'food_cake', 'clothes_jacket', 'button', 'laptop', 'tvstand', 'mat', 'dustpan', 'food_food', 'after_shave', 'towel_rack', 'pencil', 'kitchen_counter', 'laundry_detergent', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'table', 'vase', 'washing_machine', 'coffee'] Task:Wash clothes response: { thoughts : I walk to entrance hall I walk to bedroom I find basket of clothes I lift basket of clothes I walk to kitchen I find washing machine I open washing machine I put laundry in washing machine I add laundry detergent I close washing machine lid I switch washing machine on , actions : ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>'] } Scene_Objects:['pot', 'filing_cabinet', 'band-aids', 'freezer', 'nail_polish', 'bathroom', 'cat', 'orchid', 'cpuscreen', 'phone', 'character', 'keyboard', 'mat', 'faucet', 'wall', 'oven', 'bed', 'keys', 'coffe_maker', 'mouthwash', 'food_onion', 'curtain', 'centerpiece', 'console', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'home_office'] Task:Pet cat response: | { First I need to find the cat in the living room. Then I walk over to the cat and pet it gently. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'tea', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'table_cloth', 'mat', 'stereo', 'window', 'foundation', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'bench', 'keys', 'toilet_paper', 'food_food', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'vacuum_cleaner', 'comb', 'maindoor', 'bathtub', 'table'] Task:Relax on sofa response: { thoughts : move to living room, locate sofa, move to sofa, sit on sofa, lie on sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['food_salt', 'food_oatmeal', 'microwave', 'freezer', 'ceilingfan', 'food_carrot', 'orchid', 'drawing', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'longboard', 'bathroom_counter', 'stovefan', 'ceilinglamp', 'shower', 'food_cereal', 'wall', 'powersocket', 'nightstand', 'food_vegetable', 'food_food', 'doorjamb', 'shaving_cream', 'hairbrush', 'spoon', 'dishwasher', 'vase', 'coffee'] Task:Put groceries in Fridge response: | { Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'button', 'mat', 'balanceball', 'window', 'candle', 'wall', 'powersocket', 'photoframe', 'novel', 'coffee_filter', 'ice', 'doorjamb', 'kettle', 'console', 'door', 'bathroom_cabinet', 'light', 'home_office', 'table', 'soap'] Task:Turn on light response: { thoughts : I walk to wall. I put my hand on the switch. I push the button. I turn on the lights., actions : ['[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['sheets', 'pot', 'food_salt', 'walllamp', 'bathroom', 'trashcan', 'ceilingfan', 'floor', 'keyboard', 'computer', 'brush', 'window', 'candle', 'food_jam', 'pillow', 'food_kiwi', 'wall', 'pasta', 'wall_clock', 'bench', 'bed', 'wooden_spoon', 'curtain', 'towel_rack', 'mouse', 'pencil', 'maindoor', 'light', 'table', 'coffee'] Task:Go to sleep response: | { Enter bedroom, turn on the light, and shut door. Change into night clothes. Turn off light. Turn down comforter, climb into bed, lay head on pillow, and cover up with comforter. Close eyes and drift off to sleep. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'photoframe', 'food_food', 'television', 'after_shave', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet'] Task:Watch TV response: { thoughts : Turn on tv. Sit with kids., actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[FIND] <child>', '[GREET] <child>', '[FIND] <child>', '[GREET] <child>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['pot', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'remote_control', 'alcohol', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'curtain', 'rag', 'doorjamb', 'dresser', 'table', 'clothes_skirt'] Task:Watch TV response: | { go to living room, sit on couch, get remote, switch on tv, 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:['juice', 'detergent', 'knifeblock', 'cpuscreen', 'longboard', 'folder', 'character', 'bookshelf', 'table_cloth', 'toaster', 'stereo', 'picture', 'food_orange', 'nightstand', 'wall_clock', 'tape', 'light_bulb', 'coffe_maker', 'ice', 'tray', 'curtain', 'doorjamb', 'cd', 'shoes', 'dresser', 'door', 'sink', 'light', 'dishwasher', 'teeth'] Task:Listen to music response: { thoughts : I walk to the living room. I find a radio there and switch it on to listen to music., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['filing_cabinet', 'food_bread', 'freezer', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'thread', 'alcohol', 'ceilinglamp', 'shoe-shine_kit', 'balanceball', 'wall', 'oven', 'food_food', 'coffe_maker', 'toilet_paper', 'check', 'food_rice', 'tray', 'towel_rack', 'pencil', 'kitchen_counter', 'napkin', 'dishwasher', 'clothes_shirt'] Task:Put groceries in Fridge response: | { Open the fridge, and put groceries in the fridge. Close the fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'dry_pasta', 'tablelamp', 'walllamp', 'detergent', 'milk', 'orchid', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'wall', 'box', 'basket_for_clothes', 'keys', 'coffe_maker', 'food_food', 'curtain', 'food_sugar', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'bathtub', 'sink', 'home_office', 'coffee_cup', 'dishwasher', 'clothes_skirt'] Task:Make coffee response: { thoughts : walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[LOOKAT] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <milk>', '[GRAB] <milk>', '[PUTBACK] <milk> <coffe_maker>', '[FIND] <food_sugar>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>'] } Scene_Objects:['fork', 'water_glass', 'food_pizza', 'tablelamp', 'drawing', 'knifeblock', 'needle', 'bathroom_counter', 'floor', 'desk', 'purse', 'food_bacon', 'ceilinglamp', 'mat', 'faucet', 'picture', 'window', 'couch', 'wall', 'cup', 'check', 'toilet_paper', 'television', 'water', 'tray', 'hairbrush', 'cupboard', 'controller', 'clothes_scarf', 'table'] Task:Drink response: | { GOING TO DRINK WATER IN KITCHEN } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'coffe_maker', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'cupboard', 'controller', 'table'] Task:Browse internet response: { thoughts : I go to my desk. I turn on the computer. I open a web page and look at it., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['pot', 'crayon', 'freezer', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'orchid', 'floor', 'ceiling', 'clothes_jacket', 'brush', 'ceilinglamp', 'mat', 'balanceball', 'clothes_socks', 'couch', 'microphone', 'form', 'wall', 'food_food', 'check', 'oven_mitts', 'wine', 'mouse', 'cupboard', 'food_steak', 'spoon', 'table', 'tooth_paste'] Task:Cook some food response: | { Go kitchen and make something for 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:['tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table', 'clothes_skirt'] Task:Write an email response: { thoughts : enter office, find computer, turn it on,, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TOUCH] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['tea', 'microwave', 'band-aids', 'drawing', 'cpuscreen', 'hanger', 'floor', 'computer', 'ceilinglamp', 'balanceball', 'window', 'oil', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'coffe_maker', 'toilet_paper', 'television', 'kitchen_counter', 'chessboard', 'home_office', 'table', 'bathroom_cabinet', 'vase', 'light', 'coffee'] Task:Relax on sofa response: | { Sitting down and relaxing on the sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'scissors', 'drawing', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'shower', 'electric_shaver', 'food_kiwi', 'wall', 'bench', 'food_cheese', 'photoframe', 'newspaper', 'bed', 'food_food', 'standingmirror', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'door', 'soap', 'clothes_shirt', 'scrabble', 'coffee'] Task:Change TV channel response: { thoughts : Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control, actions : ['[WALK] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[PUTOBJBACK] <remote_control>'] } Scene_Objects:['filing_cabinet', 'blender', 'crayon', 'walllamp', 'ceilingfan', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'mat', 'stovefan', 'wall', 'powersocket', 'oven', 'bench', 'cutting_board', 'food_rice', 'doorjamb', 'cd', 'door', 'light', 'vase', 'creditcard'] Task:Turn on light response: | { I enter the bedroom and find the light. Then I turn it 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:['microwave', 'walllamp', 'detergent', 'floor', 'ceiling', 'toaster', 'faucet', 'stereo', 'electric_shaver', 'window', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'cutting_board', 'coffe_maker', 'television', 'drinking_glass', 'after_shave', 'shaving_cream', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'sink', 'bathroom_cabinet', 'vase', 'clothes_shirt'] Task:Drink response: { thoughts : First I go into the kitchen, open the cupboard and find a glass.Then I close the cupboard. Then I go to the sink, turn the faucet on fill the glass under the faucet. I turn off the faucet and then I drink., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>'] } Scene_Objects:['microwave', 'toilet', 'detergent', 'food_butter', 'dough', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'faucet', 'stereo', 'picture', 'dustpan', 'bowl', 'dining_room', 'wall', 'oven', 'powersocket', 'photoframe', 'wine', 'tray', 'console', 'pencil', 'sink', 'bathroom_cabinet', 'dishwasher', 'hands_both', 'shoe_rack'] Task:Wash hands response: | { I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under 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:['juice', 'food_salt', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'drawing', 'floor', 'stamp', 'table_cloth', 'plate', 'faucet', 'deck_of_cards', 'clothes_pants', 'wall', 'bench', 'powersocket', 'tape', 'photoframe', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee'] Task:Bring dirty plate to sink response: { thoughts : Stand up from the table. Pick up dirty plate. Walk to sink. Put plate in sink., actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>'] } Scene_Objects:['spectacles', 'sponge', 'filing_cabinet', 'tea', 'chair', 'walllamp', 'bathroom', 'ceilingfan', 'character', 'computer', 'food_bacon', 'mop_bucket', 'balanceball', 'foundation', 'form', 'bowl', 'wall', 'pasta', 'basket_for_clothes', 'bed', 'check', 'doorjamb', 'diary', 'hairbrush', 'cupboard', 'dresser', 'laundry_detergent', 'food_steak', 'light', 'scrabble'] Task:Listen to music response: | { 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:['sheets', 'tablelamp', 'detergent', 'ceilingfan', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'food_cake', 'clothes_jacket', 'button', 'laptop', 'tvstand', 'mat', 'dustpan', 'food_food', 'after_shave', 'towel_rack', 'pencil', 'kitchen_counter', 'laundry_detergent', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'table', 'vase', 'washing_machine', 'coffee'] Task:Wash clothes response: { thoughts : I walk to entrance hall I walk to bedroom I find basket of clothes I lift basket of clothes I walk to kitchen I find washing machine I open washing machine I put laundry in washing machine I add laundry detergent I close washing machine lid I switch washing machine on , actions : ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>'] } Scene_Objects:['glue', 'filing_cabinet', 'beer', 'chair', 'freezer', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'character', 'keyboard', 'bookmark', 'ceilinglamp', 'balanceball', 'window', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'food_cheese', 'coffe_maker', 'television', 'toothbrush_holder', 'mouse', 'pencil', 'maindoor', 'table', 'dishwasher', 'vase'] Task:Relax on sofa response: | { I go to the living room and sit in the sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'beer', 'measuring_cup', 'chair', 'ground_coffee', 'knifeblock', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mail', 'toaster', 'picture', 'dustpan', 'wall', 'bench', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'after_shave', 'dresser', 'maindoor', 'dishwasher'] Task:Make coffee response: { thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['pot', 'tablelamp', 'walllamp', 'cat', 'drawing', 'needle', 'bathroom_counter', 'dvd_player', 'folder', 'desk', 'bedroom', 'computer', 'toaster', 'tvstand', 'balanceball', 'mousepad', 'dining_room', 'nightstand', 'oven', 'powersocket', 'food_food', 'pencil', 'maindoor', 'sink', 'bag', 'bathroom_cabinet', 'table', 'home_office', 'light', 'laser_pointer'] Task:Pet cat response: | { Walk to living room. Find the cat. Walk over to the cat. Touch the cat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'scissors', 'crayon', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'window', 'homework', 'couch', 'wall', 'child', 'bench', 'photoframe', 'newspaper', 'coffe_maker', 'razor', 'television', 'kitchen_counter', 'cupboard', 'table', 'coffee'] Task:Let baby learn how to walk response: { thoughts : The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe., actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[GREET] <child>', '[FIND] <couch>', '[TURNTO] <couch>', '[POINTAT] <couch>', '[TURNTO] <child>', '[LOOKAT] <child>'] } Scene_Objects:['dog', 'walllamp', 'ceilingfan', 'drawing', 'orchid', 'knife', 'longboard', 'floor', 'ceiling', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'oil', 'couch', 'candle', 'pillow', 'wall', 'keys', 'coffe_maker', 'television', 'coin', 'curtain', 'dresser', 'conditioner', 'door', 'sink', 'table'] Task:Watch TV response: | { you go into the living room, sit on a chair/sofa, grab remote control, turn on tv, change channels, then watch somethign fun. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', '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: { 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:['sheets', 'pot', 'tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'knife', 'cpuscreen', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'powersocket', 'doorjamb', 'shaving_cream', 'mouse', 'bag', 'light'] Task:Work response: | { go to home office. turn the computer on. begin working } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'bed', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Watch TV response: { thoughts : Go the living room, sit in the chair. Take the remote control and switch on the TV., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[WATCH] <television>'] } Scene_Objects:['sponge', 'food_pizza', 'juice', 'toilet', 'freezer', 'blow_dryer', 'walllamp', 'ceilingfan', 'knifeblock', 'bathroom_counter', 'alcohol', 'button', 'stereo', 'form', 'towel', 'oven', 'basket_for_clothes', 'photoframe', 'light_bulb', 'toilet_paper', 'toothbrush_holder', 'kitchen_counter', 'shoes', 'chessboard', 'vacuum_cleaner', 'clothes_scarf', 'home_office', 'dishwasher', 'soap', 'shoe_rack'] Task:Wash hands response: | { I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'basket_for_clothes', 'cup', 'television', 'food_rice', 'curtain', 'doorjamb', 'diary', 'shoes', 'door', 'spoon', 'bathroom_cabinet', 'table'] Task:Watch TV response: { thoughts : I walk into the living room and sit on the sofa to watch tv, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['tablelamp', 'food_salt', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'mousepad', 'couch', 'food_kiwi', 'wall', 'bench', 'cup', 'check', 'television', 'curtain', 'napkin', 'table', 'soap', 'instrument_violin'] Task:Watch TV response: | { I walk into the living room. I sit on the couch. I pick up the remote control. I push the power button. I push the guide button and look for my favorite show \ The Middle.\ I click that channel and enjoy my 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:['tablelamp', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'stamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'dining_room', 'wall', 'toy', 'bed', 'food_food', 'toilet_paper', 'mouthwash', 'doorjamb', 'pencil', 'kitchen_counter', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'home_office', 'bathroom_cabinet', 'dishwasher', 'washing_machine'] Task:Wash clothes response: { thoughts : I walk to entrance hall I walk to bedroom I find basket of clothes I lift basket of clothes I walk to kitchen I find washing machine I open washing machine I put laundry in washing machine I add laundry detergent I close washing machine lid I switch washing machine on , actions : ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>'] } Scene_Objects:['filing_cabinet', 'tea', 'ceilingfan', 'drawing', 'floor', 'bookshelf', 'ceilinglamp', 'shower', 'window', 'couch', 'food_orange', 'towel', 'dining_room', 'wall', 'powersocket', 'television', 'tray', 'wooden_spoon', 'rag', 'lighter', 'towel_rack', 'pencil', 'dresser', 'clothes_dress', 'hairdryer', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt'] Task:Relax on sofa response: | { walk to living room, find sofa, sit in sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'alcohol', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'bench', 'photoframe', 'food_food', 'television', 'curtain', 'doorjamb', 'door', 'sink', 'light', 'table'] Task:Watch TV response: { thoughts : walk to living room, find the television, switch on the television, find the sofa, walk to sofa, sit in sofa, watch the television, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['sheets', 'freezer', 'bathroom', 'ceilingfan', 'drawing', 'bills', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'toy', 'tape', 'bed', 'television', 'curtain', 'comb', 'hair', 'home_office', 'table', 'soap'] Task:Watch TV response: | { Go to the living room and sit on the couch. Turn on television using remote control. Use remote control buttons to navigate to desired channel. Watch television. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['tablelamp', 'detergent', 'ceilingfan', 'drawing', 'needle', 'knifeblock', 'floor', 'ceiling', 'phone', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'bench', 'check', 'television', 'oven_mitts', 'curtain', 'conditioner', 'food_steak', 'home_office', 'table', 'vase', 'clothes_shirt'] Task:Watch TV response: | { I walk into the living room and sit on the sofa to 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', 'food_pizza', 'juice', 'board_game', 'dog', 'food_butter', 'orchid', 'drawing', 'bathroom_counter', 'bookshelf', 'stovefan', 'mat', 'laptop', 'tvstand', 'picture', 'window', 'couch', 'nightstand', 'wall_clock', 'toy', 'clothes_gloves', 'toilet_paper', 'television', 'ice', 'bathroom_cabinet', 'table', 'light', 'vase', 'instrument_violin'] Task:Set up table response: { thoughts : Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room, actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <home_office>', '[DROP] <plate>', '[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <home_office>', '[DROP] <cup>', '[WALK] <dining_room>', '[WALK] <fork>', '[FIND] <fork>', '[GRAB] <fork>', '[WALK] <home_office>', '[DROP] <fork>'] } 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: | { Turn on computer, pull up browser, browse the internet } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'table', 'light'] Task:Watch TV response: { thoughts : Go to the living room. Find the remote. Pick up the remote. Find the sofa. Sit on the sofa. Look at the television. Aim the remote at the television. Press the power button. Flip the channels., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUSH] <remote_control>', '[WATCH] <television>'] } Scene_Objects:['pot', 'filing_cabinet', 'juice', 'ground_coffee', 'detergent', 'trashcan', 'hanger', 'floor', 'folder', 'desk', 'bedroom', 'bookshelf', 'mop_bucket', 'toaster', 'ceilinglamp', 'balanceball', 'microphone', 'clothes_hat', 'form', 'food_kiwi', 'nightstand', 'bench', 'photoframe', 'newspaper', 'kitchen_counter', 'hair', 'maindoor', 'door', 'food_steak', 'hairdryer'] Task:Turn on light response: | { Walk to the living room, walk to the lamp, switch on the lamp. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'faucet', 'stereo', 'shower', 'candle', 'wall', 'oven', 'cup', 'photoframe', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'light'] Task:Drink response: { thoughts : Walk to kitchen, walk to cupboard, open cupboard, grab cup, walk to sink, pour water in cup, drink water., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>'] } Scene_Objects:['tablelamp', 'walllamp', 'food_butter', 'ceilingfan', 'trashcan', 'floor', 'ceiling', 'bedroom', 'mat', 'plate', 'balanceball', 'faucet', 'oil', 'clothes_pants', 'food_orange', 'wall', 'bench', 'tape', 'cup', 'bed', 'light_bulb', 'video_game_controller', 'razor', 'food_rice', 'diary', 'towel_rack', 'mouse', 'headset', 'dishrack', 'spoon'] Task:Listen to music response: | { walk to living room ,find radio ,switch on radio ,listen to music 4 } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'basket_for_clothes', 'cup', 'television', 'food_rice', 'curtain', 'doorjamb', 'diary', 'shoes', 'door', 'spoon', 'bathroom_cabinet', 'table'] Task:Watch TV response: { thoughts : I walk into the living room and sit on the sofa to watch tv, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['microwave', 'chair', 'nail_polish', 'knifeblock', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'shampoo', 'bookshelf', 'computer', 'ceilinglamp', 'food_kiwi', 'wall', 'bench', 'newspaper', 'bed', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'conditioner', 'door', 'hairdryer', 'light', 'table', 'tooth_paste', 'shoe_rack'] Task:Turn on light response: | { Walk into living room. Find wall. Find light button. Switch on light 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:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['jelly', 'nail_polish', 'detergent', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'dvd_player', 'computer', 'ceilinglamp', 'plate', 'balanceball', 'faucet', 'window', 'stereo', 'couch', 'wall', 'oven', 'newspaper', 'television', 'tray', 'rag', 'mouse', 'hair', 'controller', 'laundry_detergent', 'napkin', 'home_office', 'table', 'creditcard'] Task:Listen to music response: | { walk to living room, look at the DVD player, switch on the dvd player, look at the sofa, sit on the sofa and listen 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:['pot', 'food_salt', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'stereo', 'couch', 'wall', 'nightstand', 'bench', 'powersocket', 'tape', 'bed', 'coffe_maker', 'check', 'tray', 'curtain', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Go to the bathroom and to the sink, turn the faucet on, push the bottle of soap onto your hands and scrub them. Then rinse your hands out and turn the faucet off., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[PUSH] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['microwave', 'toilet', 'chair', 'band-aids', 'drawing', 'knifeblock', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'computer', 'bookmark', 'ceilinglamp', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'television', 'tray', 'doorjamb', 'dresser', 'cupboard', 'door', 'light', 'table', 'dishwasher', 'board_game'] Task:Pick up phone response: | { My friend is calling and I want to pick up the phone and chat with him for a little while on the couch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'cat', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'cutting_board', 'coffee_table', 'novel', 'food_food', 'television', 'towel_rack', 'mouse', 'shoes', 'door', 'light'] Task:Read book response: { thoughts : I walk to the living room and pick up a book from the coffee table. I find my favorite chair. I sit in the armchair and open the book. I read., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[WALK] <coffee_table>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'envelope', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'check', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light'] Task:Work response: | { I go to the home office to work on my project. I turn on the light and walk to my desk. I turn on the computer. Then I look through the documents. After I'm done, I turn off the computer. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'phone', 'dvd_player', 'character', 'bedroom', 'ceilinglamp', 'balanceball', 'iron', 'window', 'couch', 'food_orange', 'wall', 'tape', 'cup', 'basket_for_clothes', 'check', 'wooden_spoon', 'console', 'mouse', 'kitchen_counter', 'hairbrush', 'food_steak', 'sink', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Wash hands with soap, actions : ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>'] } Scene_Objects:['fork', 'water_glass', 'blender', 'food_salt', 'microwave', 'nail_polish', 'trashcan', 'drawing', 'hanger', 'longboard', 'floor', 'character', 'computer', 'food_bacon', 'mat', 'electric_shaver', 'mousepad', 'dining_room', 'bench', 'bed', 'food_food', 'video_game_controller', 'water', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'bathroom_cabinet', 'table', 'dirt'] Task:Drink response: | { walk to kitchen, hold drinking glass, lift glass, pour water in drinking 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', 'filing_cabinet', 'beer', 'freezer', 'walllamp', 'bathroom', 'bathroom_counter', 'character', 'bedroom', 'desk', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'clothes_pants', 'towel', 'bench', 'basket_for_clothes', 'bed', 'coin', 'food_donut', 'curtain', 'towel_rack', 'mouse', 'cd', 'comb', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'washing_machine'] Task:Wash clothes response: { thoughts : Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on., actions : ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['fork', 'toilet', 'chair', 'freezer', 'walllamp', 'bills', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'computer', 'toaster', 'mat', 'plate', 'faucet', 'couch', 'form', 'wall', 'wall_clock', 'television', 'food_onion', 'doorjamb', 'towel_rack', 'dresser', 'cupboard', 'door', 'light', 'table'] Task:Turn on light response: | { I walk in to the living room. I find the light switch. I turn on the lights. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'filing_cabinet', 'beer', 'tea', 'freezer', 'shampoo', 'character', 'desk', 'piano_bench', 'ceilinglamp', 'iron', 'picture', 'mousepad', 'couch', 'bowl', 'nightstand', 'wall_clock', 'toy', 'bed', 'coffe_maker', 'television', 'coin', 'after_shave', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'shoes', 'bathroom_cabinet'] Task:Change TV channel response: { thoughts : take remote control, push change channel button, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>'] } Scene_Objects:['pot', 'tablelamp', 'tea', 'measuring_cup', 'toilet', 'walllamp', 'bathroom', 'knifeblock', 'orchid', 'floor', 'ceiling', 'folder', 'bookshelf', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'nightstand', 'pasta', 'cup', 'food_food', 'television', 'water', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'light', 'vase'] Task:Drink response: | { Walk to kitchen, walk to cupboard, open cupboard, grab cup, walk to sink, pour water in cup, drink water. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', '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: { thoughts : Pet my dog in hall, actions : ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>'] } Scene_Objects:['tablelamp', 'food_salt', 'measuring_cup', 'jelly', 'freezer', 'nail_polish', 'ceilingfan', 'drawing', 'orchid', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'deck_of_cards', 'mousepad', 'couch', 'clothes_pants', 'wall', 'television', 'curtain', 'kitchen_counter', 'chessboard', 'spoon', 'table'] Task:Change TV channel response: | { I walk in living room. I find TV remote. I grab TV remote. I sit on sofa. I switch on TV. I switch channel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'window', 'pillow', 'wall', 'powersocket', 'tray', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bathtub', 'light', 'teeth', 'shoe_rack'] Task:Go to toilet response: { thoughts : walk to bathroom , run to toilet, actions : ['[WALK] <bathroom>', '[RUN] <toilet>'] } Scene_Objects:['tablelamp', 'food_salt', 'beer', 'dog', 'freezer', 'walllamp', 'trashcan', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'clothes_jacket', 'toaster', 'ceilinglamp', 'plate', 'mousepad', 'microphone', 'food_orange', 'wall', 'wall_clock', 'bench', 'food_food', 'oven_mitts', 'coffee_filter', 'kitchen_counter', 'cd', 'cupboard', 'maindoor', 'home_office'] Task:Put groceries in Fridge response: | { I pick up groceries. I open fridge. I put groceries in the fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'filing_cabinet', 'juice', 'freezer', 'walllamp', 'drawing', 'orchid', 'phone', 'ceiling', 'character', 'cleaning_solution', 'button', 'toaster', 'ceilinglamp', 'homework', 'oil', 'mousepad', 'pillow', 'dining_room', 'food_kiwi', 'pasta', 'oven', 'coffe_maker', 'food_food', 'television', 'rag', 'towel_rack', 'bathtub', 'instrument_guitar', 'vase'] Task:Clean response: { thoughts : Spray counter tops with all purpose cleaner. Using towel, wipe counter, removing all dirt and grime until clean., actions : ['[WALK] <dining_room>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[PUTOBJBACK] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[PUTOBJBACK] <rag>'] } 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: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'cpuscreen', 'kitchen_cabinet', 'bathroom_counter', 'desk', 'bedroom', 'thread', 'faucet', 'shower', 'electric_shaver', 'microphone', 'towel', 'dining_room', 'wall', 'oven', 'cutting_board', 'photoframe', 'water', 'drinking_glass', 'curtain', 'food_onion', 'doorjamb', 'kettle', 'kitchen_counter', 'dresser', 'laundry_detergent', 'light', 'table', 'dirt'] Task:Drink response: { thoughts : You walk to the kitchen and open the kitchen cabinet and grab a drinking glass. You find the water and pour the water into the drinking glass. You drink the water from the glass., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <drinking_glass>', '[DRINK] <drinking_glass>'] } Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'mop', 'freezer', 'blow_dryer', 'bathroom', 'detergent', 'milk', 'bathroom_counter', 'ceiling', 'character', 'mop_bucket', 'stovefan', 'shoe-shine_kit', 'balanceball', 'deck_of_cards', 'stereo', 'shower', 'mousepad', 'microphone', 'pillow', 'light_bulb', 'coffee_filter', 'doorjamb', 'towel_rack', 'pencil', 'cupboard', 'light', 'dishwasher'] Task:Browse internet response: | { The task is browse and surf on the internet regarding a particular topic } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'mousepad', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table'] Task:Browse internet response: { thoughts : Walk to the Home Office. Find the computer. Turn on the computer., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['chair', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'bedroom', 'keyboard', 'piano_bench', 'bookmark', 'laptop', 'electric_shaver', 'food_kiwi', 'wall', 'powersocket', 'toothbrush_holder', 'curtain', 'rag', 'doorjamb', 'shaving_cream', 'cards', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'light', 'coffee'] Task:Turn on light response: | { I walk into the dining room and turn on the lights } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Work response: { thoughts : I sit at my desk and work on the computer., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['food_ice_cream', 'chair', 'detergent', 'milk', 'knife', 'drawing', 'cpuscreen', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'faucet', 'couch', 'wall', 'photoframe', 'bed', 'water', 'after_shave', 'mouse', 'controller', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: | { Walk to bathroom. Walk to sink and turn on the water. Grab the soap and wash the hands. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'freezer', 'blow_dryer', 'food_carrot', 'milk', 'drawing', 'floor', 'phone', 'keyboard', 'bookshelf', 'button', 'piano_bench', 'laptop', 'plate', 'oil', 'mousepad', 'wall', 'bench', 'photoframe', 'keys', 'food_food', 'check', 'tray', 'kitchen_counter', 'dishrack', 'hair', 'table', 'soap', 'teeth'] Task:Set up table response: { thoughts : I walk to the table. I put down the dish. I put down the silverware. I put down the napkin., actions : ['[WALK] <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>'] } Scene_Objects:['tablelamp', 'food_ice_cream', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'balanceball', 'window', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'newspaper', 'doorjamb', 'mouse', 'shoes', 'light'] Task:Browse internet response: | { Go to home office, turn on the computer, open the internet and browse around the internet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'floor_lamp', 'electric_shaver', 'wall', 'nightstand', 'powersocket', 'bed', 'doorjamb', 'shoes', 'hairbrush', 'door', 'light', 'table', 'soap'] Task:Turn on light response: { thoughts : walk to wall, find light switch, turn on lights, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[WALK] <bedroom>', '[WALK] <light>', '[SWITCHON] <light>'] } Scene_Objects:['food_pizza', 'tablelamp', 'juice', 'food_salt', 'measuring_cup', 'ceilingfan', 'orchid', 'shampoo', 'bedroom', 'desk', 'table_cloth', 'toaster', 'tvstand', 'stereo', 'plate', 'bench', 'basket_for_clothes', 'coffee_filter', 'ice', 'tray', 'pencil', 'headset', 'cupboard', 'maindoor', 'napkin', 'bag', 'light', 'soap', 'washing_machine', 'creditcard'] Task:Wash clothes response: | { Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'toaster', 'stovefan', 'faucet', 'towel', 'pillow', 'wall', 'wall_clock', 'bed', 'check', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'controller', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Cleaning hands, actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['sheets', 'spectacles', 'food_bread', 'microwave', 'walllamp', 'ground_coffee', 'detergent', 'longboard', 'floor', 'character', 'desk', 'shower', 'picture', 'balanceball', 'food_peanut_butter', 'pillow', 'dining_room', 'pasta', 'powersocket', 'basket_for_clothes', 'cup', 'food_food', 'razor', 'after_shave', 'mouse', 'paper_towel', 'cupboard', 'maindoor', 'board_game', 'hands_both'] Task:Go to toilet response: | { Walking towards Toilet room, And dispose of human waste. Cleaning your hands with tissue paper or 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:['tablelamp', 'toilet', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Work response: { thoughts : Find home office. Walk to home office. Find computer. Find chair at desk. Sit in chair. Switch on computer. Work on computer., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>'] } Scene_Objects:['spectacles', 'tablelamp', 'toilet', 'chair', 'dog', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'mat', 'balanceball', 'mousepad', 'bowl', 'wall', 'nightstand', 'food_food', 'check', 'television', 'doorjamb', 'mouse', 'light'] Task:Write an email response: | { I go to the home office to find the computer. I turn switch computer on , i open the email. i write the email and send 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:['tablelamp', 'juice', 'toilet', 'chair', 'freezer', 'dough', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'mat', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'curtain', 'centerpiece', 'doorjamb', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bag', 'dishwasher'] Task:Put groceries in Fridge response: { thoughts : walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in fridge., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>'] } Scene_Objects:['sheets', 'dry_pasta', 'pot', 'food_salt', 'freezer', 'food_carrot', 'drawing', 'food_egg', 'floor', 'shampoo', 'ceiling', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'window', 'mousepad', 'couch', 'wall', 'food_food', 'television', 'lighter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'vase', 'scrabble'] Task:Relax on sofa response: | { I sit on the sofa. I put my legs on the sofa and recline. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'television', 'coin', 'doorjamb', 'mouse', 'chessboard', 'bathtub', 'table'] Task:Write school paper response: { thoughts : Writing and drafting a paper for class work, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>'] } Scene_Objects:['filing_cabinet', 'detergent', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'folder', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'tvstand', 'shower', 'homework', 'oil', 'dustpan', 'dining_room', 'wall', 'powersocket', 'bench', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'home_office', 'light'] Task:Turn on light response: | { Walk into the bedroom and walk to the light switch. Flip the 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:['filing_cabinet', 'food_salt', 'freezer', 'orchid', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'phone', 'character', 'bedroom', 'keyboard', 'toaster', 'mat', 'plate', 'picture', 'foundation', 'dish_soap', 'clothes_socks', 'pillow', 'powersocket', 'cutting_board', 'basket_for_clothes', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'sink', 'spoon', 'home_office'] Task:Wash dishes by hand response: { thoughts : Pick up dish. Put in soapy water. Wash dish., actions : ['[WALK] <dining_room>', '[WALK] <dish_soap>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <dish_soap> <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WIPE] <plate>'] } Scene_Objects:['sheets', 'jelly', 'detergent', 'orchid', 'knifeblock', 'drawing', 'hanger', 'longboard', 'bedroom', 'desk', 'envelope', 'computer', 'button', 'window', 'foundation', 'mousepad', 'couch', 'pasta', 'bench', 'powersocket', 'cup', 'clothes_gloves', 'video_game_controller', 'coffee_filter', 'centerpiece', 'towel_rack', 'hairbrush', 'cupboard', 'vase', 'electrical_outlet'] Task:Turn on light response: | { walk to living room ,find electrical outlet , switch on eletrical outlet } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'wall', 'powersocket', 'oven', 'coffe_maker', 'television', 'coffee_filter', 'food_rice', 'tray', 'curtain', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'dirt'] Task:Watch TV response: { thoughts : I like to set on my sofa.Turn on the tv. And watch Perry Mason. Monday's through Friday's., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>'] } Scene_Objects:['sheets', 'food_bread', 'toilet', 'chair', 'freezer', 'bathroom', 'food_carrot', 'hanger', 'keyboard', 'envelope', 'mail', 'tvstand', 'clothes_pants', 'bowl', 'dining_room', 'oven', 'powersocket', 'bed', 'clothes_gloves', 'check', 'wine', 'curtain', 'food_onion', 'kettle', 'dresser', 'vase', 'home_office', 'light', 'clothes_skirt', 'dishwasher'] Task:Pick up phone response: | { I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'dustpan', 'pillow', 'wall', 'wall_clock', 'powersocket', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'table'] Task:Browse internet response: { thoughts : Browsing the internet for information., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[TOUCH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['pot', 'food_pizza', 'microwave', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'orchid', 'floor', 'ceiling', 'character', 'thread', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'clothes_hat', 'food_orange', 'wall', 'oven', 'box', 'food_cheese', 'food_food', 'television', 'food_rice', 'after_shave', 'dresser', 'clothes_scarf', 'light', 'clothes_skirt', 'tooth_paste'] Task:Put groceries in Fridge response: | { I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'measuring_cup', 'toilet', 'drawing', 'needle', 'hanger', 'floor', 'computer', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'bed', 'novel', 'food_food', 'video_game_controller', 'coffe_maker', 'tray', 'food_onion', 'doorjamb', 'lighter', 'cd', 'clothes_dress', 'bathroom_cabinet', 'light', 'soap'] 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:['filing_cabinet', 'toilet', 'chair', 'trashcan', 'food_carrot', 'drawing', 'knifeblock', 'hanger', 'floor', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'window', 'homework', 'couch', 'dustpan', 'food_orange', 'dining_room', 'wall', 'nightstand', 'photoframe', 'clothes_gloves', 'coffe_maker', 'check', 'television', 'mouse', 'pencil', 'table', 'laser_pointer'] Task:Relax on sofa response: | { Walk to the living room, turn to the sofa. Sit on the sofa and relax. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['filing_cabinet', 'toothbrush', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'mat', 'tvstand', 'towel', 'wall', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'coffee_filter', 'food_rice', 'after_shave', 'doorjamb', 'cards', 'door', 'napkin', 'light', 'vase'] Task:Turn on light response: | { Walk to the bedroom and use the button on the wall, next to the door to turn on the lights. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'mat', 'laptop', 'faucet', 'wall', 'box', 'photoframe', 'coffe_maker', 'colander', 'curtain', 'pencil', 'headset', 'dishrack', 'pajamas', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'clothes_shirt', 'hands_both'] Task:Wash hands response: { thoughts : I walk in to the bathroom. I find the soap. I find the faucet. I turn on the faucet. I wash my hands. I put the soap back. I rinse my hands. I turn the faucet off., actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['glue', 'tablelamp', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'food_carrot', 'bathroom_counter', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'clothes_socks', 'clothes_pants', 'wall', 'pasta', 'bench', 'powersocket', 'coffe_maker', 'check', 'food_food', 'coffee_filter', 'tray', 'doorjamb', 'kettle', 'kitchen_counter', 'napkin', 'bathroom_cabinet', 'dishwasher', 'vase'] Task:Make coffee response: | { Make coffee in the kitchen. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'television', 'ice', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'table'] Task:Change TV channel response: { thoughts : walk to living room.grab remote control. look at television. switch on television. lift remote control. push remote control. watch television. switch off television. put back remote control., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[PUSH] <remote_control>', '[WATCH] <television>', '[SWITCHOFF] <television>', '[PUTOBJBACK] <remote_control>'] } Scene_Objects:['juice', 'crayon', 'walllamp', 'trashcan', 'dough', 'floor', 'phone', 'bedroom', 'tea_bag', 'toaster', 'mat', 'plate', 'ceilinglamp', 'dish_soap', 'wall', 'pasta', 'oven', 'cutting_board', 'food_cheese', 'newspaper', 'coffe_maker', 'check', 'food_food', 'tray', 'towel_rack', 'pencil', 'dresser', 'conditioner', 'home_office', 'dishwasher'] Task:Wash dishes with dishwasher response: | { I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'nail_polish', 'detergent', 'orchid', 'drawing', 'hanger', 'floor', 'phone', 'desk', 'button', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'dining_room', 'nightstand', 'wall_clock', 'oven', 'cup', 'photoframe', 'bed', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office'] Task:Listen to music response: { thoughts : I go into the living room and turn on the radio. Then, I select the station I want, which is usually a preset., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['tea', 'walllamp', 'detergent', 'cat', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'remote_control', 'mail', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'couch', 'wall', 'bench', 'clothes_gloves', 'coffe_maker', 'television', 'curtain', 'coffee_pot', 'home_office', 'table', 'coffee'] Task:Change TV channel response: | { walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'cpuscreen', 'clothes_underwear', 'ceiling', 'folder', 'desk', 'computer', 'stovefan', 'shower', 'mousepad', 'candle', 'clothes_hat', 'dining_room', 'newspaper', 'photoframe', 'food_food', 'video_game_controller', 'oven_mitts', 'curtain', 'pencil', 'kitchen_counter', 'dishrack', 'laundry_detergent', 'door', 'light', 'dishwasher', 'soap', 'tooth_paste', 'washing_machine'] Task:Wash clothes response: { thoughts : Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on., actions : ['[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['tablelamp', 'microwave', 'toilet', 'jelly', 'ceilingfan', 'food_carrot', 'drawing', 'knife', 'clothes_underwear', 'floor', 'phone', 'ceilinglamp', 'tvstand', 'stereo', 'window', 'mousepad', 'couch', 'food_jam', 'wall', 'nightstand', 'cup', 'television', 'ice', 'mouse', 'kitchen_counter', 'home_office', 'table', 'soap', 'board_game', 'shoe_rack'] Task:Listen to music response: | { sitting down to listen to music on the radio } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tea', 'microwave', 'band-aids', 'drawing', 'cpuscreen', 'hanger', 'floor', 'computer', 'ceilinglamp', 'balanceball', 'window', 'oil', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'coffe_maker', 'toilet_paper', 'television', 'kitchen_counter', 'chessboard', 'home_office', 'table', 'bathroom_cabinet', 'vase', 'light', 'coffee'] Task:Relax on sofa response: { thoughts : Sitting down and relaxing on the sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'computer', 'toaster', 'ceilinglamp', 'window', 'food_noodles', 'couch', 'microphone', 'pillow', 'wall', 'newspaper', 'novel', 'coffe_maker', 'television', 'coin', 'toothbrush_holder', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'bathroom_cabinet', 'table', 'vase', 'laser_pointer', 'creditcard'] Task:Read book response: | { Sit on couch. Grab book. Open book. 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:['pot', 'tablelamp', 'microwave', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'wall', 'pasta', 'oven', 'powersocket', 'box', 'water', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'sauce_pan', 'cupboard', 'door', 'light', 'dishwasher', 'tooth_paste', 'teeth'] Task:Cook some food response: { thoughts : Cook some pasta on the stove, actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pasta>', '[GRAB] <pasta>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <sauce_pan>', '[POUR] <water> <sauce_pan>', '[FIND] <oven>', '[SWITCHON] <oven>', '[PUTBACK] <pasta> <sauce_pan>', '[FIND] <sauce_pan>', '[GRAB] <sauce_pan>', '[PUTBACK] <sauce_pan> <oven>'] } Scene_Objects:['sponge', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'mousepad', 'pillow', 'wall', 'cutting_board', 'box', 'toilet_paper', 'doorjamb', 'centerpiece', 'towel_rack', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'door', 'light', 'dishwasher', 'shoe_rack'] Task:Pick up phone response: | { Walk to living room. Go near telephone. take the receiver and then talk to other person on that side. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'walllamp', 'bathroom', 'detergent', 'bathroom_counter', 'button', 'toaster', 'brush', 'stereo', 'shower', 'faucet', 'food_orange', 'pillow', 'oven', 'photoframe', 'check', 'television', 'tray', 'kettle', 'mouse', 'cupboard', 'conditioner', 'door', 'home_office', 'table', 'dishwasher', 'clothes_skirt', 'soap'] Task:Listen to music response: { thoughts : Walk into living room, look for radio, grab on button, actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>'] } Scene_Objects:['scissors', 'mop', 'ground_coffee', 'ceilingfan', 'trashcan', 'toothbrush', 'drawing', 'needle', 'bookshelf', 'keyboard', 'laptop', 'balanceball', 'stereo', 'mousepad', 'wall_clock', 'bench', 'coffe_maker', 'food_food', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'kettle', 'controller', 'napkin', 'home_office', 'light', 'vase', 'soap', 'tooth_paste'] Task:Brush teeth response: | { walk to bathroom, look at the toothbrush holder, take toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now brush teeth } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'dog', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'wall', 'nightstand', 'oven', 'photoframe', 'novel', 'television', 'lighter', 'towel_rack', 'mouse', 'dresser', 'door'] Task:Read book response: { thoughts : Reading a book, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <bookmark>', '[READ] <novel>'] } Scene_Objects:['ground_coffee', 'nail_polish', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'button', 'mail', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'tape', 'television', 'curtain', 'food_onion', 'cupboard', 'table', 'shoe_rack'] Task:Watch TV response: | { Go to the living room, sit on the couch, find the remote, switch on the TV 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:['blender', 'milk', 'drawing', 'orchid', 'needle', 'hanger', 'bathroom_counter', 'floor', 'phone', 'computer', 'bookmark', 'toaster', 'mat', 'tvstand', 'electric_shaver', 'clothes_socks', 'closetdrawer', 'couch', 'nightstand', 'wall', 'bed', 'keys', 'photoframe', 'tray', 'centerpiece', 'dresser', 'bag', 'soap', 'clothes_shirt', 'teeth'] Task:Read book response: { thoughts : Climb into bed, then read the novel, actions : ['[WALK] <bedroom>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <bed>', '[LIE] <bed>', '[READ] <novel>'] } Scene_Objects:['tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'phone', 'dvd_player', 'character', 'bedroom', 'ceilinglamp', 'balanceball', 'iron', 'window', 'couch', 'food_orange', 'wall', 'tape', 'cup', 'basket_for_clothes', 'check', 'wooden_spoon', 'console', 'mouse', 'kitchen_counter', 'hairbrush', 'food_steak', 'sink', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: | { Wash hands with soap } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'walllamp', 'orchid', 'bills', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'bed', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'comb', 'door', 'home_office', 'light', 'table'] Task:Browse internet response: { thoughts : I go to the living room, where my computer is. I locate it, switch it on and type desired URL adress in the web browser., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'homework', 'towel', 'dining_room', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bag', 'napkin', 'soap'] Task:Put groceries in Fridge response: | { Walk to kitchen counter, grab a grocery, walk to fridge, open fridge, put the grocery into fridge, and close fridge } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tea', 'toilet', 'chair', 'detergent', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'character', 'bookshelf', 'purse', 'envelope', 'toaster', 'tvstand', 'shower', 'window', 'pillow', 'tape', 'cup', 'coffe_maker', 'check', 'oven_mitts', 'curtain', 'rag', 'lighter', 'mouse', 'pencil', 'hairbrush', 'table', 'vase'] Task:Pet cat response: { thoughts : find the cat, go near the cat and pet the cat, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['fork', 'juice', 'tea', 'walllamp', 'toothbrush', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'button', 'table_cloth', 'brush', 'mat', 'faucet', 'food_jam', 'wall', 'powersocket', 'photoframe', 'mouse', 'vacuum_cleaner', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'tooth_paste', 'teeth'] Task:Wash teeth response: | { I walk in to the bathroom. I turn on the faucet. I find the toothbrush and toothpaste. I grab the toothbrush and toothpaste. I rinse off the toothbrush. I add toothpaste to the toothbrush. I put back the toothpaste. I wash my teeth with the toothbrush. I rinse off the toothbrush. I put the toothbrush back. I rinse my mouth out. I turn the faucet 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', '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: { thoughts : Close the storm door. Lock the storm door., actions : ['[WALK] <home_office>'] } Scene_Objects:['tablelamp', 'food_salt', 'crayon', 'freezer', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'shampoo', 'desk', 'mail', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'stovefan', 'mat', 'electric_shaver', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'pasta', 'basket_for_clothes', 'food_food', 'diary', 'towel_rack', 'dresser', 'clothes_dress'] Task:Put groceries in Fridge response: | { in my home i walk to the kitchen with some groceries and locate the fridge,then open the fridge put the groceries into the fridge and closed. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'laptop', 'stovefan', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'table'] Task:Use laptop response: { thoughts : Sit down on a couch and perform tasks such as navigating the internet on a laptop, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <keyboard>', '[LOOKAT] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>'] } Scene_Objects:['sponge', 'food_salt', 'beer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'bookshelf', 'mail', 'computer', 'button', 'toaster', 'plate', 'shower', 'dish_soap', 'mousepad', 'pillow', 'wall', 'oven', 'photoframe', 'clothes_gloves', 'coffe_maker', 'tray', 'food_onion', 'doorjamb', 'dresser', 'hairdryer', 'sink', 'dishwasher', 'clothes_shirt'] Task:Wash dishes with dishwasher response: | { Put dishes in the dishwasher and start the dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'freezer', 'blow_dryer', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'shoe-shine_kit', 'couch', 'microphone', 'food_jam', 'wall', 'coffe_maker', 'check', 'television', 'curtain', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'colander', 'tooth_paste'] Task:Watch TV response: { thoughts : Walk to the living room. Find the television. Walk to the television. Switch on the television. Find the sofa. Walk to the sofa. Sit on the sofa. Find the remote control. Grab the remote control. Look at the television., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[WALK] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['dry_pasta', 'sheets', 'mop', 'microwave', 'chair', 'freezer', 'blow_dryer', 'nail_polish', 'orchid', 'knife', 'floor', 'keyboard', 'stovefan', 'stereo', 'foundation', 'couch', 'soap', 'food_orange', 'pillow', 'wall', 'powersocket', 'check', 'toilet_paper', 'coffe_maker', 'curtain', 'pencil', 'shoes', 'vacuum_cleaner', 'colander', 'shoe_rack'] Task:Pet cat response: | { Petting the cat } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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:['blender', 'measuring_cup', 'microwave', 'freezer', 'trashcan', 'food_butter', 'orchid', 'longboard', 'floor', 'desk', 'keyboard', 'mat', 'plate', 'ceilinglamp', 'homework', 'couch', 'candle', 'clothes_pants', 'bench', 'bed', 'check', 'mouthwash', 'television', 'food_onion', 'controller', 'maindoor', 'sink', 'spoon', 'napkin', 'bathroom_cabinet'] Task:Turn on light response: | { Walk over to light switch, flip the switch to the on 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:['walllamp', 'trashcan', 'toothbrush', 'drawing', 'orchid', 'needle', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'remote_control', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'wall', 'powersocket', 'television', 'food_rice', 'doorjamb', 'pencil', 'chessboard', 'door', 'hairdryer', 'bathroom_cabinet', 'table', 'scrabble'] Task:Change TV channel response: { thoughts : I go to the livingroom. The TV is on. I pick up the remote and press the next channel button. I look at the television, and see that the channel has changed., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['food_pizza', 'filing_cabinet', 'tea', 'toilet', 'ceilingfan', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'clothes_jacket', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'couch', 'form', 'dining_room', 'wall', 'nightstand', 'oven', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'table'] Task:Watch TV response: | { Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. 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:['tablelamp', 'toilet', 'ground_coffee', 'walllamp', 'food_butter', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'thread', 'stovefan', 'toaster', 'tvstand', 'faucet', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'coffe_maker', 'food_food', 'oven_mitts', 'coffee_filter', 'water', 'wine', 'wooden_spoon', 'controller', 'bathroom_cabinet', 'home_office', 'dishwasher'] Task:Make coffee response: { thoughts : Walk to kitchen, open coffee maker, find coffee filter, grab coffee filter, put coffee filter in coffee maker, find ground coffee, put ground coffee in coffee maker, pour water in coffee maker, close coffee maker and switch on coffee maker., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['sheets', 'tablelamp', 'jelly', 'food_egg', 'hanger', 'desk', 'bedroom', 'food_bacon', 'toaster', 'mat', 'balanceball', 'window', 'food_peanut_butter', 'clothes_hat', 'tape', 'basket_for_clothes', 'photoframe', 'clothes_gloves', 'newspaper', 'coffe_maker', 'food_food', 'coin', 'after_shave', 'kitchen_counter', 'laundry_detergent', 'napkin', 'light', 'table', 'washing_machine', 'teeth'] Task:Wash clothes response: | { Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'freezer', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'tea_bag', 'keyboard', 'computer', 'button', 'stovefan', 'mat', 'ceilinglamp', 'homework', 'closetdrawer', 'couch', 'wall', 'oven', 'cutting_board', 'toilet_paper', 'television', 'curtain', 'diary', 'pencil', 'shoes', 'dresser', 'table'] 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:['filing_cabinet', 'tablelamp', 'blender', 'microwave', 'toilet', 'dog', 'freezer', 'drawing', 'knifeblock', 'longboard', 'floor', 'folder', 'computer', 'ceilinglamp', 'window', 'couch', 'wall', 'nightstand', 'bench', 'cup', 'bed', 'clothes_gloves', 'novel', 'television', 'curtain', 'towel_rack', 'cupboard', 'sink', 'home_office', 'table'] Task:Relax on sofa response: | { I'm tired and want to relax on the sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'bathroom', 'food_butter', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mop_bucket', 'toaster', 'shower', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'toy', 'bed', 'razor', 'television', 'after_shave', 'doorjamb', 'dresser', 'conditioner', 'door', 'light'] Task:Turn on light response: { thoughts : Walk into the bedroom and walk to the light switch. Flip the switch., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['water_glass', 'filing_cabinet', 'pot', 'tablelamp', 'measuring_cup', 'freezer', 'walllamp', 'ceilingfan', 'knifeblock', 'drawing', 'longboard', 'floor', 'ceiling', 'keyboard', 'button', 'clothes_jacket', 'tvstand', 'couch', 'form', 'dining_room', 'bowl', 'nightstand', 'light_bulb', 'check', 'curtain', 'mouse', 'hair', 'cupboard', 'hairdryer', 'vase'] Task:Drink response: | { Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : Pick up all the toys on the floor and put them in their correct storage bin or shelf., actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>'] } Scene_Objects:['sheets', 'water_glass', 'scissors', 'crayon', 'freezer', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'keyboard', 'thread', 'table_cloth', 'stovefan', 'ceilinglamp', 'shower', 'foundation', 'wall', 'nightstand', 'toy', 'water', 'ice', 'tray', 'wooden_spoon', 'vacuum_cleaner', 'door', 'light'] Task:Drink response: | { go to kitchen, find water glass and grab it, find fridge and open grab water and pour into it, then 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:['sheets', 'filing_cabinet', 'tablelamp', 'dog', 'detergent', 'needle', 'hanger', 'floor', 'ceiling', 'envelope', 'table_cloth', 'ceilinglamp', 'broom', 'wall', 'cutting_board', 'photoframe', 'bed', 'coffe_maker', 'check', 'coffee_filter', 'water', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'controller', 'table', 'dishwasher', 'clothes_skirt', 'coffee'] Task:Make coffee response: { thoughts : I find the coffee machine, fill it with water and coffee then press the button to make the coffee, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[WALK] <coffee>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['beer', 'crayon', 'ceilingfan', 'drawing', 'needle', 'floor', 'ceiling', 'shampoo', 'keyboard', 'remote_control', 'thread', 'food_bacon', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'photoframe', 'bed', 'television', 'coffee_filter', 'curtain', 'mouse', 'table', 'light', 'laser_pointer'] Task:Watch TV response: | { I go into the living room. I find the remote. I turn on the tv. I sit on the couch and 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', 'beer', 'toilet', 'chair', 'ceilingfan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'folder', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'couch', 'microphone', 'wall', 'bench', 'light_bulb', 'television', 'curtain', 'food_steak', 'sink', 'napkin', 'home_office', 'table'] Task:Watch TV response: { thoughts : I walk into my living room, find the remote and sit on my sofa. I look at the remote and switch on the television. I look at the Television., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['scissors', 'cat', 'drawing', 'hanger', 'longboard', 'floor', 'phone', 'character', 'desk', 'purse', 'stovefan', 'ceilinglamp', 'iron', 'stereo', 'window', 'oil', 'couch', 'wall', 'bench', 'toy', 'food_food', 'television', 'food_rice', 'towel_rack', 'console', 'hairbrush', 'napkin', 'table', 'vase', 'dirt'] Task:Pet cat response: | { I would walk into the living room. Then sit on the couch and pet the cat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'freezer', 'ground_coffee', 'food_carrot', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'thread', 'brush', 'ceilinglamp', 'mat', 'picture', 'clothes_socks', 'couch', 'microphone', 'food_orange', 'wall', 'powersocket', 'oven', 'tape', 'cup', 'keys', 'novel', 'food_food', 'check', 'mouthwash', 'curtain', 'pajamas', 'sink'] Task:Put groceries in Fridge response: { thoughts : take every item from groceries bag and put them in the fridge, actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>'] } Scene_Objects:['food_bread', 'jelly', 'drawing', 'knifeblock', 'floor', 'computer', 'food_bacon', 'mail', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'shower', 'window', 'couch', 'food_kiwi', 'wall', 'box', 'food_food', 'television', 'coffee_filter', 'after_shave', 'doorjamb', 'kettle', 'mouse', 'hair', 'cupboard', 'conditioner', 'sink', 'home_office', 'table'] Task:Relax on sofa response: | { walk to living room, walk to sofa, sit in sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['mop', 'freezer', 'trashcan', 'milk', 'knifeblock', 'orchid', 'clothes_underwear', 'bookshelf', 'purse', 'thread', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'couch', 'microphone', 'wall', 'cutting_board', 'basket_for_clothes', 'keys', 'toothbrush_holder', 'oven_mitts', 'curtain', 'doorjamb', 'diary', 'chessboard', 'home_office', 'bathroom_cabinet', 'clothes_skirt', 'light'] Task:Hang up car keys response: { thoughts : Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall., actions : ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>'] } Scene_Objects:['pot', 'filing_cabinet', 'cd_player', 'toilet', 'freezer', 'trashcan', 'food_carrot', 'milk', 'music_stand', 'clothes_underwear', 'longboard', 'desk', 'bedroom', 'tea_bag', 'stovefan', 'ceilinglamp', 'faucet', 'electric_shaver', 'mousepad', 'food_jam', 'wall', 'nightstand', 'toy', 'bed', 'food_food', 'kitchen_counter', 'door', 'sink', 'dishwasher', 'coffee'] Task:Listen to music response: | { Walk to the living and turn to the music stand. Switch on the CD player to 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:['fork', 'food_pizza', 'filing_cabinet', 'tablelamp', 'freezer', 'nail_polish', 'cat', 'food_carrot', 'drawing', 'orchid', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'stamp', 'ceilinglamp', 'plate', 'candle', 'dining_room', 'wall', 'bench', 'food_vegetable', 'newspaper', 'food_food', 'television', 'after_shave', 'cards', 'cd', 'clothes_dress', 'table'] Task:Fix snack response: { thoughts : Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTBACK] <food_carrot> <plate>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[PUTBACK] <food_vegetable> <plate>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <plate> <table>'] } Scene_Objects:['glue', 'food_pizza', 'filing_cabinet', 'toilet', 'walllamp', 'detergent', 'orchid', 'food_egg', 'floor', 'phone', 'ceiling', 'character', 'keyboard', 'alcohol', 'toaster', 'tvstand', 'faucet', 'balanceball', 'picture', 'wall', 'oven', 'tape', 'food_cheese', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'towel_rack', 'table', 'dishwasher'] Task:Wash dishes with dishwasher response: | { Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'chair', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'bills', 'cpuscreen', 'bathroom_counter', 'bedroom', 'computer', 'mail', 'bookmark', 'shower', 'couch', 'towel', 'pillow', 'wall_clock', 'oven', 'powersocket', 'bench', 'bed', 'photoframe', 'television', 'mirror', 'curtain', 'towel_rack', 'kitchen_counter', 'home_office', 'dirt'] Task:Look at mirror response: { thoughts : I look at my reflection to check my cleanliness., actions : ['[WALK] <bathroom>', '[WALK] <mirror>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[LOOKAT] <mirror>'] } Scene_Objects:['beer', 'freezer', 'band-aids', 'ceilingfan', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'food_chicken', 'character', 'ceilinglamp', 'faucet', 'electric_shaver', 'couch', 'microphone', 'wall', 'bench', 'food_food', 'toothbrush_holder', 'television', 'lighter', 'mouse', 'kitchen_counter', 'dresser', 'controller', 'table', 'clothes_shirt', 'teeth'] Task:Put groceries in Fridge response: | { Put the groceries on the table into the fridge } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'toilet', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'bathroom_counter', 'purse', 'alcohol', 'bookmark', 'stovefan', 'toaster', 'stereo', 'food_jam', 'dining_room', 'powersocket', 'food_food', 'mouthwash', 'tray', 'after_shave', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office', 'laser_pointer'] Task:Walk through response: { thoughts : Walk through the hallway., actions : ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>'] } Scene_Objects:['sheets', 'tablelamp', 'crayon', 'freezer', 'bathroom', 'toothbrush', 'drawing', 'knifeblock', 'floor', 'phone', 'mail', 'brush', 'ceilinglamp', 'picture', 'window', 'couch', 'bowl', 'wall', 'pasta', 'bench', 'tape', 'newspaper', 'light_bulb', 'television', 'toothbrush_holder', 'shaving_cream', 'vacuum_cleaner', 'spoon', 'bathroom_cabinet', 'table'] Task:Relax on sofa response: | { I get home from work and walk into the living room. I see the couch and go to sit 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:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'tvstand', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'food_jam', 'wall', 'nightstand', 'oven', 'newspaper', 'food_food', 'vacuum_cleaner', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table', 'hands_both'] Task:Wash hands response: { thoughts : I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>'] } Scene_Objects:['toilet', 'dog', 'walllamp', 'nail_polish', 'ceilingfan', 'orchid', 'knife', 'character', 'mat', 'stereo', 'form', 'wall', 'cup', 'food_cheese', 'bed', 'food_food', 'video_game_controller', 'doorjamb', 'cards', 'hair', 'controller', 'conditioner', 'maindoor', 'laundry_detergent', 'door', 'napkin', 'light', 'vase', 'clothes_shirt', 'scrabble'] Task:Change TV channel response: | { I walk to the living room. I find the TV remote. I change the channel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['glue', 'dry_pasta', 'filing_cabinet', 'microwave', 'toilet', 'freezer', 'ground_coffee', 'walllamp', 'orchid', 'drawing', 'bills', 'bathroom_counter', 'floor', 'clothes_jacket', 'bookmark', 'ceilinglamp', 'mat', 'tvstand', 'floor_lamp', 'window', 'couch', 'wall', 'bed', 'novel', 'television', 'curtain', 'doorjamb', 'sink', 'table', 'board_game'] Task:Read book response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'hanger', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'computer', 'toaster', 'mat', 'plate', 'faucet', 'brush', 'oil', 'candle', 'broom', 'wall', 'tape', 'bed', 'coffe_maker', 'ice', 'rag', 'console', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'colander'] Task:Clean sink response: { thoughts : Squirt soap into the sink. Get a wet rag. Wipe out the sink. Rinse out the sink and the rag. Hang the rag out to dry., actions : ['[WALK] <dining_room>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <cleaning_solution>', '[WALK] <sink>', '[POUR] <cleaning_solution> <sink>', '[PUTOBJBACK] <cleaning_solution>', '[WIPE] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <sink>', '[RINSE] <rag>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['filing_cabinet', 'tea', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'piano_bench', 'mat', 'shoe-shine_kit', 'balanceball', 'oil', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouthwash', 'doorjamb', 'towel_rack', 'vacuum_cleaner', 'door', 'home_office', 'light', 'soap'] Task:Turn on light response: | { switching on the light } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'blender', 'beer', 'toilet', 'detergent', 'food_butter', 'phone', 'bookshelf', 'remote_control', 'alcohol', 'button', 'table_cloth', 'piano_bench', 'toaster', 'tvstand', 'pillow', 'nightstand', 'pasta', 'wall_clock', 'tape', 'coffe_maker', 'doorjamb', 'cards', 'pencil', 'controller', 'clothes_dress', 'maindoor', 'sink', 'home_office', 'light'] Task:Change TV channel response: { thoughts : I pick up the remote. I press button on remote., actions : ['[WALK] <bedroom>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['beer', 'microwave', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'keyboard', 'ceilinglamp', 'mat', 'picture', 'window', 'couch', 'dining_room', 'wall', 'oven', 'powersocket', 'toy', 'photoframe', 'television', 'oven_mitts', 'tray', 'centerpiece', 'kettle', 'towel_rack', 'pencil', 'dishrack', 'table', 'vase'] Task:Relax on sofa response: | { go to the living room and sit on the couch, ease into the sofa and relax. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['nail_polish', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'thread', 'faucet', 'couch', 'dining_room', 'wall', 'nightstand', 'bench', 'wall_clock', 'photoframe', 'coffe_maker', 'food_food', 'lighter', 'doorjamb', 'towel_rack', 'diary', 'shoes', 'comb', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap', 'dirt', 'hands_both'] Task:Wash hands response: { thoughts : Go to the bathroom. turn on the water in the sink. apply soap to hands. rub hands together. rinse hands with water. turn off the water., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[WIPE] <hands_both>'] } Scene_Objects:['filing_cabinet', 'drawing', 'orchid', 'clothes_underwear', 'hanger', 'desk', 'clothes_jacket', 'mop_bucket', 'bookmark', 'shower', 'electric_shaver', 'clothes_socks', 'clothes_pants', 'food_kiwi', 'bench', 'basket_for_clothes', 'photoframe', 'bed', 'coffe_maker', 'food_rice', 'shaving_cream', 'dishrack', 'cupboard', 'clothes_dress', 'laundry_detergent', 'clothes_skirt', 'soap', 'board_game', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: | { I go to the bathroom, take the dirt clothes and put into the washing machine, then put the soap, set the cleaning program and switch on the machine } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['scissors', 'chair', 'freezer', 'band-aids', 'walllamp', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'keyboard', 'toaster', 'ceilinglamp', 'plate', 'stereo', 'mat', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'oven', 'check', 'food_food', 'food_rice', 'ice', 'food_onion', 'console', 'kitchen_counter', 'table'] Task:Set up table response: { thoughts : Walk to the kitchen. Open the kitchen cabinet. Grab the plate and put it on the table., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <table>', '[PUTBACK] <plate> <table>'] } Scene_Objects:['glue', 'pot', 'tablelamp', 'blender', 'microwave', 'toilet', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'shampoo', 'character', 'desk', 'keyboard', 'computer', 'mousepad', 'wall', 'bench', 'powersocket', 'photoframe', 'television', 'tray', 'mouse', 'dresser', 'controller', 'maindoor', 'home_office', 'clothes_skirt'] Task:Go to toilet response: | { Walk to bathroom, find toilet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'cup', 'newspaper', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Start computer response: { thoughts : Sit in desk chair, press power button, let computer power on, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['glue', 'tablelamp', 'blender', 'walllamp', 'dough', 'knifeblock', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'bookshelf', 'clothes_jacket', 'faucet', 'balanceball', 'pillow', 'wall', 'oven', 'food_food', 'wooden_spoon', 'curtain', 'kitchen_counter', 'headset', 'dishrack', 'cupboard', 'maindoor', 'sink', 'table', 'soap', 'hands_both'] Task:Wash hands response: | { Washing Hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'alcohol', 'mat', 'shower', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'coffee'] Task:Put groceries in Fridge response: { thoughts : I get my groceries and go to the fridge. I open the fridge and put the groceries there., actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'tablelamp', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'homework', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'photoframe', 'check', 'curtain', 'doorjamb', 'mouse', 'light', 'dirt'] Task:Work response: | { Find a PC and do homework } |
Subsets and Splits