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:['tablelamp', 'food_salt', 'microwave', 'freezer', 'walllamp', 'bathroom', 'cpuscreen', 'bathroom_counter', 'ceiling', 'keyboard', 'computer', 'food_bacon', 'table_cloth', 'ceilinglamp', 'faucet', 'picture', 'clothes_socks', 'towel', 'dining_room', 'wall', 'pasta', 'bed', 'centerpiece', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'light', 'table', 'colander'] Task:Clean screen response: { thoughts : Use a soft rag to wipe the screen until there are no marks on it., actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <computer>', '[WIPE] <computer>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'fork', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'character', 'alcohol', 'faucet', 'mousepad', 'dustpan', 'wall', 'nightstand', 'oven', 'cup', 'photoframe', 'coffe_maker', 'razor', 'after_shave', 'cards', 'dishrack', 'sink', 'spoon', 'bathroom_cabinet', 'clothes_skirt', 'vase', 'clothes_shirt', 'dirt'] Task:Shut off alarm response: | { Shutting of the alarm clock } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'walllamp', 'bathroom', 'trashcan', 'dough', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'faucet', 'window', 'food_noodles', 'mousepad', 'pillow', 'dining_room', 'wall', 'bed', 'food_food', 'razor', 'rag', 'console', 'mouse', 'towel_rack', 'kitchen_counter', 'door', 'sink', 'bathtub', 'bathroom_cabinet'] Task:Clean sink response: { thoughts : Take a premoistened cleaning wipe and wipe down top of sink and faucet. Next clean the sink bowl. Let air dry., actions : ['[WALK] <bathroom>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[WIPE] <faucet>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['chair', 'walllamp', 'bills', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'television', 'toothbrush_holder', 'wine', 'doorjamb', 'mouse', 'dresser', 'hairbrush', 'controller', 'clothes_dress', 'home_office', 'light', 'table'] Task:Turn on computer response: | { Press the power button on the computer to 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:['filing_cabinet', 'scissors', 'tablelamp', 'crayon', 'microwave', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'longboard', 'shampoo', 'dvd_player', 'folder', 'mail', 'bookmark', 'toaster', 'shower', 'homework', 'couch', 'bed', 'clothes_gloves', 'towel_rack', 'mouse', 'pencil', 'cupboard', 'maindoor', 'table', 'laser_pointer'] Task:Pet cat response: { thoughts : I walk into the living room and I pet the cat, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['pot', 'jelly', 'chair', 'phone', 'ceiling', 'desk', 'bedroom', 'table_cloth', 'bookmark', 'stovefan', 'mat', 'tvstand', 'stereo', 'shoe-shine_kit', 'faucet', 'toaster', 'mousepad', 'powersocket', 'cutting_board', 'shelf', 'food_cheese', 'television', 'wooden_spoon', 'after_shave', 'food_onion', 'doorjamb', 'shoes', 'dishrack', 'vase', 'electrical_outlet'] Task:Turn on radio response: | { Go to the radio. Switch on the power button. Tune the station. Set the volume. Listen to the music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'cat', 'food_carrot', 'toothbrush', 'drawing', 'orchid', 'floor', 'mail', 'stovefan', 'ceilinglamp', 'window', 'mousepad', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'photoframe', 'mouthwash', 'tray', 'curtain', 'coffee_pot', 'pajamas', 'door', 'sink', 'bathroom_cabinet', 'table', 'light', 'tooth_paste'] Task:Relax response: { thoughts : Lie down on the couch., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['toilet', 'walllamp', 'bathroom', 'drawing', 'knife', 'laptop', 'tvstand', 'faucet', 'shower', 'window', 'mat', 'clothes_socks', 'closetdrawer', 'pillow', 'photoframe', 'standingmirror', 'newspaper', 'toothbrush_holder', 'lighter', 'centerpiece', 'kitchen_counter', 'shoes', 'cd', 'hair', 'conditioner', 'maindoor', 'bathtub', 'sink', 'table', 'vase'] Task:Leave home response: | { Put on shoes. Put on coat. Open door and exit through it. Lock door behind you. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bookshelf', 'computer', 'stovefan', 'toaster', 'food_noodles', 'wall', 'oven', 'toy', 'food_vegetable', 'food_food', 'video_game_controller', 'water', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'dishwasher', 'scrabble'] Task:Cook some food response: { thoughts : walk to kicthen , find stove , find cooking pot , find vegetables , find water ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove, actions : ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[FIND] <pot>', '[FIND] <food_vegetable>', '[FIND] <water>', '[GRAB] <water>', '[WASH] <food_vegetable>', '[POUR] <water> <pot>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <oven>', '[SWITCHON] <oven>'] } Scene_Objects:['pot', 'food_pizza', 'filing_cabinet', 'microwave', 'chair', 'bathroom', 'orchid', 'character', 'desk', 'bedroom', 'thread', 'computer', 'brush', 'ceilinglamp', 'faucet', 'stereo', 'closetdrawer', 'dining_room', 'wall', 'pasta', 'toy', 'cup', 'standingmirror', 'television', 'wine', 'doorjamb', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'clothes_shirt'] Task:Open door response: | { Open the door when leaving or coming in. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'tea_bag', 'mat', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'photoframe', 'check', 'mouthwash', 'food_food', 'food_donut', 'wine', 'curtain', 'doorjamb', 'console', 'dresser', 'door', 'light'] Task:Pick up toys response: { thoughts : Bend down and pick up the toys off of the floor., actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['drawing', 'hanger', 'floor', 'ceiling', 'computer', 'brush', 'mat', 'ceilinglamp', 'faucet', 'stovefan', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cutting_board', 'shelf', 'toy', 'standingmirror', 'television', 'curtain', 'doorjamb', 'towel_rack', 'controller', 'home_office', 'table', 'soap', 'shoe_rack'] Task:Turn off TV response: | { Walk over to tv and press power button } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] 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:['food_bread', 'microwave', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'alcohol', 'piano_bench', 'stovefan', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'oil', 'food_peanut_butter', 'creditcard', 'form', 'wall', 'nightstand', 'oven', 'cutting_board', 'toy', 'newspaper', 'coffe_maker', 'tray', 'kitchen_counter', 'dresser', 'sink', 'electrical_outlet'] Task:Toast bread response: | { Place two slices of bread in the toaster. Select medium toast on toaster. Push down button to begin toasting. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'tablelamp', 'juice', 'scissors', 'beer', 'chair', 'freezer', 'bathroom', 'ceilingfan', 'hanger', 'floor', 'computer', 'food_bacon', 'mat', 'couch', 'creditcard', 'dining_room', 'oven', 'tape', 'bed', 'light_bulb', 'novel', 'food_food', 'mouse', 'cupboard', 'conditioner', 'home_office', 'table', 'scrabble', 'shoe_rack'] Task:Pet dog response: { thoughts : Pet my dog in hall, actions : ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>'] } Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'laptop', 'faucet', 'mat', 'closetdrawer', 'teeth', 'dining_room', 'wall', 'pasta', 'toy', 'shelf', 'standingmirror', 'novel', 'check', 'television', 'curtain', 'console', 'dresser', 'napkin', 'table', 'light', 'scrabble', 'coffee'] Task:Look at painting response: | { Walk to the painting. Look up at the painting. Admire it on the wall. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'photoframe', 'novel', 'television', 'mouse', 'kitchen_counter', 'door', 'sink', 'clothes_skirt', 'clothes_shirt'] Task:Read book response: { thoughts : Go to home office, find the book. Sit in the chair and read the book., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['spectacles', 'measuring_cup', 'blow_dryer', 'ground_coffee', 'bathroom', 'cat', 'phone', 'ceiling', 'character', 'man', 'keyboard', 'computer', 'mat', 'window', 'mousepad', 'clothes_pants', 'powersocket', 'cutting_board', 'cup', 'standingmirror', 'bed', 'coffe_maker', 'television', 'food_rice', 'wine', 'controller', 'sink', 'napkin', 'laser_pointer', 'shoe_rack'] Task:Answer door response: | { Walk up to the door. Open the door and greet whomever is out 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:['dry_pasta', 'filing_cabinet', 'beer', 'chair', 'bills', 'knife', 'hanger', 'bathroom_counter', 'floor', 'computer', 'stovefan', 'mat', 'tvstand', 'window', 'couch', 'pillow', 'towel', 'dining_room', 'food_kiwi', 'wall', 'toy', 'photoframe', 'novel', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'bag', 'table'] Task:Read book response: { thoughts : Sit on couch. Grab book. Open book. Read book., actions : ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['fork', 'beer', 'microwave', 'freezer', 'walllamp', 'dough', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'oven', 'cutting_board', 'shelf', 'coffe_maker', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'kitchen_counter', 'maindoor', 'bathtub', 'table'] Task:Drink response: | { Get a can of beer, open it, sit on couch, 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:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'orchid', 'hanger', 'phone', 'computer', 'piano_bench', 'nightstand', 'pasta', 'wall_clock', 'powersocket', 'toy', 'food_cheese', 'clothes_gloves', 'check', 'toilet_paper', 'television', 'after_shave', 'doorjamb', 'door', 'hairdryer', 'sink', 'home_office', 'light', 'table', 'clothes_scarf', 'soap'] Task:Read book response: { thoughts : go to bedroom, sit down, pick up book, read, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['sponge', 'scissors', 'tablelamp', 'measuring_cup', 'microwave', 'chair', 'band-aids', 'bathroom', 'milk', 'wallshelf', 'phone', 'character', 'computer', 'mail', 'button', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'standingmirror', 'centerpiece', 'kitchen_counter', 'shoes', 'maindoor', 'sink', 'bathtub', 'bathroom_cabinet', 'table'] Task:Turn off light response: | { Walk to the lamp. Find the switch. Click the switch off. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'band-aids', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'homework', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'keys', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'light', 'soap'] Task:Change TV channels response: { thoughts : Take remote. Change to desired channel by you., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>'] } Scene_Objects:['food_bread', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'needle', 'floor', 'phone', 'mail', 'mat', 'plate', 'faucet', 'stereo', 'couch', 'dustpan', 'dining_room', 'wall', 'bench', 'oven', 'toy', 'cup', 'newspaper', 'standingmirror', 'food_food', 'razor', 'console', 'towel_rack', 'bathtub', 'table'] Task:Set up table response: | { Get dishes. Place dishes neatly around table. Get food. Place food on middle of table. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'toaster', 'plate', 'faucet', 'stereo', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bathtub', 'dishwasher', 'clothes_skirt', 'laser_pointer'] Task:Wash dishes with dishwasher response: { thoughts : Take a dish and put it in the dishwasher to be washed, actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['blow_dryer', 'bathroom', 'food_carrot', 'toothbrush', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'mousepad', 'closetdrawer', 'clothes_pants', 'wall', 'powersocket', 'bench', 'cutting_board', 'bed', 'photoframe', 'television', 'food_onion', 'mouse', 'dresser', 'hairbrush', 'controller', 'light', 'clothes_shirt'] Task:Organize closet response: | { Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'drawing', 'needle', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'dustpan', 'dining_room', 'wall', 'nightstand', 'powersocket', 'food_food', 'toilet_paper', 'doorjamb', 'coffee_pot', 'mouse', 'kettle', 'dresser', 'light'] Task:Turn on light response: { thoughts : walk into living room, walk to light, turn on light switch., actions : ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>'] } Scene_Objects:['tablelamp', 'microwave', 'freezer', 'walllamp', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'mail', 'stovefan', 'laptop', 'window', 'towel', 'dining_room', 'food_kiwi', 'wall', 'oven', 'cutting_board', 'bed', 'coffe_maker', 'food_food', 'check', 'tray', 'kitchen_counter', 'dishrack', 'conditioner', 'food_steak', 'bathtub', 'table', 'vase'] Task:Look in refrigerator response: | { Approach the refrigerator. Use the handle to open the refrigerator door. Look at each shelf of the refrigerator. Look in each refrigerator drawer. Close the refrigerator door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'detergent', 'milk', 'knifeblock', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'faucet', 'iron', 'couch', 'wall', 'oven', 'food_food', 'television', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'laser_pointer', 'scrabble'] Task:Cook some food response: { thoughts : Cooking a meal, actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[CLOSE] <kitchen_cabinet>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <pot> <sink>', '[GRAB] <pot>', '[SWITCHOFF] <faucet>', '[WALK] <oven>', '[PUTBACK] <pot> <oven>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[CLOSE] <freezer>', '[WALK] <oven>', '[PUTBACK] <food_food> <pot>', '[SWITCHON] <oven>'] } Scene_Objects:['pot', 'crayon', 'chair', 'bathroom', 'food_butter', 'phone', 'ceiling', 'bedroom', 'tea_bag', 'laptop', 'ceilinglamp', 'shower', 'iron', 'clothes_socks', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'standingmirror', 'photoframe', 'toothbrush_holder', 'food_donut', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'controller', 'door', 'table'] Task:Switch on lamp response: | { Press the button so the light comes 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:['glue', 'filing_cabinet', 'mop', 'microwave', 'dog', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'form', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'centerpiece', 'sink', 'scrabble'] Task:Relax on sofa response: { thoughts : I walk into the living room. I bend down. I sit on the sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'window', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'nightstand', 'cutting_board', 'shelf', 'clothes_gloves', 'food_food', 'coffe_maker', 'wooden_spoon', 'tray', 'kitchen_counter', 'sink', 'bathroom_cabinet'] Task:Keep an eye on stove as something is cooking response: | { Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'chair', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'toaster', 'mat', 'ceilinglamp', 'plate', 'stovefan', 'dish_soap', 'broom', 'wall', 'bench', 'food_food', 'coffe_maker', 'tray', 'wooden_spoon', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'table', 'dishwasher', 'instrument_violin'] Task:Wash dishes with dishwasher response: { thoughts : I go the in kitchen then grab the plate on the table. I put the plate and dish soap in the dishwasher. Finally, I turn on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'freezer', 'blow_dryer', 'walllamp', 'nail_polish', 'bathroom', 'toothbrush', 'drawing', 'hanger', 'floor', 'shampoo', 'character', 'desk', 'bookshelf', 'purse', 'envelope', 'mat', 'ceilinglamp', 'window', 'towel', 'wall', 'powersocket', 'toy', 'cup', 'food_food', 'coffe_maker', 'sink', 'duster'] Task:Dust response: | { Apply duster to shelves and clean them until dust is gone } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'microwave', 'trashcan', 'hanger', 'floor', 'bedroom', 'computer', 'button', 'brush', 'mat', 'shower', 'faucet', 'window', 'clothes_hat', 'wall', 'child', 'oven', 'bed', 'newspaper', 'novel', 'curtain', 'centerpiece', 'doorjamb', 'mouse', 'cd', 'dresser', 'hairdryer', 'clothes_scarf', 'vase', 'board_game'] Task:Story reading time response: { thoughts : Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures, actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[TURNTO] <child>', '[LOOKAT] <child>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>'] } Scene_Objects:['dry_pasta', 'glue', 'blender', 'food_salt', 'character', 'bedroom', 'mat', 'tvstand', 'food_noodles', 'garbage_can', 'couch', 'nightstand', 'wall_clock', 'bench', 'powersocket', 'toy', 'cutting_board', 'tape', 'food_vegetable', 'food_food', 'food_donut', 'tray', 'mouse', 'pencil', 'door', 'bathtub', 'home_office', 'table', 'colander', 'pantry'] Task:Organize pantry response: | { Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_ice_cream', 'freezer', 'walllamp', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'oven', 'powersocket', 'cup', 'ice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light'] Task:Get something to drink response: { thoughts : Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy, actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[CLOSE] <freezer>', '[POUR] <milk> <cup>', '[DRINK] <cup>'] } Scene_Objects:['measuring_cup', 'dog', 'chair', 'dough', 'wallshelf', 'hanger', 'cleaning_solution', 'keyboard', 'computer', 'ceilinglamp', 'plate', 'shower', 'faucet', 'window', 'homework', 'clothes_hat', 'nightstand', 'wall_clock', 'cup', 'photoframe', 'novel', 'check', 'oven_mitts', 'curtain', 'rag', 'towel_rack', 'shoes', 'hairbrush', 'maindoor', 'spoon'] Task:Clean mirror response: | { Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'food_salt', 'milk', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'photoframe', 'check', 'mouthwash', 'razor', 'television', 'coin', 'coffe_maker', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'table'] Task:Relax on sofa response: { thoughts : I walk into the living room and I lie down on the sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>'] } Scene_Objects:['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: | { Sit down on a couch and perform tasks such as navigating the internet on a laptop } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'toilet', 'bathroom', 'trashcan', 'milk', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'clothes_jacket', 'toaster', 'stovefan', 'tvstand', 'picture', 'window', 'dustpan', 'pillow', 'dining_room', 'wall', 'box', 'bed', 'wine', 'curtain', 'kettle', 'home_office', 'light', 'dishwasher'] Task:Look out window response: { thoughts : I head into my child's room and look out the window to view the neighborhood from a different area in the house., actions : ['[WALK] <bedroom>', '[WALK] <window>', '[TURNTO] <window>', '[LOOKAT] <window>'] } Scene_Objects:['pot', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'dough', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'wall', 'powersocket', 'shelf', 'toilet_paper', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'light', 'table', 'vase'] Task:Vacuum response: | { Keep my keyboard vacuumed and free of debris. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'bed', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Work response: { thoughts : Type on a computer in the home office., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['microwave', 'chair', 'dog', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'powersocket', 'box', 'television', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'door', 'bathtub', 'light', 'table'] Task:Clean screen response: | { Use a soft rag to wipe the screen until there are no marks on it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'button', 'ceilinglamp', 'faucet', 'oil', 'teeth', 'clothes_hat', 'towel', 'wall', 'photoframe', 'bed', 'doorjamb', 'diary', 'kitchen_counter', 'dishrack', 'coffee', 'hairbrush', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Go to the bathroom. Turn on the sink. Rinse hands. Apply soap and scrub your hands together. Rinse hands again. Turn off faucet. Dry hands on a towel., actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['glue', 'pot', 'filing_cabinet', 'food_bread', 'microwave', 'walllamp', 'dough', 'woman', 'toothbrush', 'wallshelf', 'ceiling', 'character', 'man', 'toaster', 'stereo', 'window', 'couch', 'dustpan', 'pillow', 'nightstand', 'bench', 'newspaper', 'keys', 'standingmirror', 'television', 'curtain', 'sink', 'instrument_guitar', 'table', 'light'] Task:Greet guests response: | { Stand next to the door. When the door opens from the outside, greet the guests. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'laptop', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dishrack', 'door', 'light', 'shoe_rack'] Task:Browse internet response: { thoughts : Walk to home office, walk to desk, sit in chair, turn on laptop, grab mouse, open a web page to look at it, move mouse, keep looking at laptop screen., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>'] } Scene_Objects:['food_butter', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'bench', 'cutting_board', 'cup', 'check', 'food_donut', 'food_rice', 'curtain', 'centerpiece', 'mouse', 'vacuum_cleaner', 'shoes', 'dresser', 'light', 'teeth'] Task:Vacuum response: | { Run the vacuum cleaner across the floor, back and forth a couple of times until clean. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', '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: { thoughts : go to living room, sit on couch, get remote, switch on tv, watch tv, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>'] } 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: | { Spray counter tops with all purpose cleaner. Using towel, wipe counter, removing all dirt and grime until clean. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'beer', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'foundation', 'window', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'door', 'table', 'light'] Task:Change TV channel response: { thoughts : Walk into the Living room. Find the television remote. Use it to turn on the television. Point the remote at the television. Press the channel button on the remote., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['tablelamp', 'food_salt', 'microwave', 'chair', 'blow_dryer', 'nail_polish', 'trashcan', 'dough', 'needle', 'cpuscreen', 'stamp', 'thread', 'stereo', 'floor_lamp', 'mousepad', 'form', 'pillow', 'dining_room', 'nightstand', 'oven', 'bench', 'cup', 'standingmirror', 'coffe_maker', 'food_donut', 'kettle', 'door', 'home_office', 'light', 'vase'] Task:Clean response: | { Clean 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:['sponge', 'glue', 'toilet', 'chair', 'detergent', 'dough', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'keyboard', 'alcohol', 'stovefan', 'ceilinglamp', 'couch', 'microphone', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'doorjamb', 'kitchen_counter', 'hairbrush', 'cupboard', 'home_office', 'dishwasher', 'coffee', 'shoe_rack'] Task:Make coffee response: { thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[PUTBACK] <coffee> <coffe_maker>'] } Scene_Objects:['filing_cabinet', 'crayon', 'cat', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'food_cake', 'computer', 'brush', 'electric_shaver', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'toy', 'food_food', 'towel_rack', 'mouse', 'dresser', 'pajamas', 'sink', 'napkin', 'light', 'colander', 'tooth_paste'] Task:Pick up toys response: | { Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'filing_cabinet', 'walllamp', 'toothbrush', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'bench', 'box', 'cup', 'photoframe', 'novel', 'mouthwash', 'television', 'curtain', 'doorjamb', 'comb', 'light', 'table'] Task:Read book response: { thoughts : Sit and read, actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[WALK] <couch>', '[SIT] <couch>', '[READ] <novel>'] } Scene_Objects:['filing_cabinet', 'mop', 'band-aids', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'cleaning_solution', 'bookshelf', 'computer', 'stereo', 'oil', 'mousepad', 'wall', 'wall_clock', 'nightstand', 'shelf', 'newspaper', 'food_food', 'video_game_controller', 'coin', 'rag', 'mouse', 'pencil', 'bathtub', 'bathroom_cabinet', 'light', 'coffee', 'creditcard'] Task:Clean mirror response: | { GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'bathroom', 'ceilingfan', 'knife', 'drawing', 'needle', 'knifeblock', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'phone', 'piano_bench', 'faucet', 'window', 'teeth', 'clothes_pants', 'wall', 'photoframe', 'check', 'oven_mitts', 'tray', 'pencil', 'clothes_dress', 'sink', 'bathroom_cabinet', 'home_office', 'clothes_skirt', '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:['fork', 'chair', 'milk', 'drawing', 'cpuscreen', 'shampoo', 'folder', 'bookshelf', 'computer', 'table_cloth', 'ceilinglamp', 'mat', 'oil', 'mousepad', 'couch', 'towel', 'nightstand', 'wall', 'cutting_board', 'cup', 'photoframe', 'bed', 'food_donut', 'mouse', 'kitchen_counter', 'pajamas', 'sink', 'napkin', 'home_office', 'tooth_paste'] Task:Open front door response: | { Walk over to the front door, turn the knob, and open the door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'fork', 'filing_cabinet', 'tablelamp', 'chair', 'band-aids', 'floor', 'ceiling', 'stamp', 'alcohol', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'towel', 'wall', 'toy', 'bed', 'keys', 'photoframe', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'dresser', 'cupboard', 'food_steak', 'sink', 'table'] Task:Wash dishes response: { thoughts : Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <plate>', '[PUTOBJBACK] <towel>', '[WALK] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>'] } Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'floor', 'ceiling', 'bedroom', 'window', 'clothes_socks', 'couch', 'dustpan', 'clothes_pants', 'food_orange', 'food_kiwi', 'wall', 'toy', 'bed', 'photoframe', 'food_food', 'coffe_maker', 'wine', 'doorjamb', 'diary', 'console', 'mouse', 'door', 'bathroom_cabinet', 'light', 'vase', 'soap'] Task:Turn off light response: | { Grasp light switch, flip light switch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'food_kiwi', 'wall', 'powersocket', 'clothes_gloves', 'food_food', 'coffe_maker', 'doorjamb', 'coffee_pot', 'headset', 'door', 'hairdryer', 'light', 'tooth_paste'] Task:Turn on light response: { thoughts : I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['filing_cabinet', 'scissors', 'walllamp', 'orchid', 'needle', 'clothes_underwear', 'dvd_player', 'character', 'desk', 'mop_bucket', 'table_cloth', 'brush', 'ceilinglamp', 'mat', 'stereo', 'dining_room', 'nightstand', 'powersocket', 'toy', 'shelf', 'check', 'toothbrush_holder', 'mouse', 'chessboard', 'dresser', 'laundry_detergent', 'home_office', 'bathroom_cabinet', 'teeth', 'creditcard'] Task:Put toys away response: | { Pick up all the toys on the floor and put them in their correct storage bin or shelf. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'video_game_console', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'cup', 'video_game_controller', 'television', 'curtain', 'dishrack', 'napkin', 'table', 'vase', 'scrabble', 'shoe_rack'] Task:Play games response: { thoughts : Turn on game. Use controller, actions : ['[WALK] <home_office>', '[WALK] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[PLUGIN] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['filing_cabinet', 'food_bread', 'crayon', 'tea', 'freezer', 'walllamp', 'bathroom', 'detergent', 'blow_dryer', 'drawing', 'floor', 'desk', 'thread', 'mop_bucket', 'tvstand', 'towel', 'wall', 'toy', 'cup', 'check', 'razor', 'food_donut', 'wine', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'laundry_detergent', 'light', 'soap'] Task:Vacuum response: | { Robot has a vacuum underneath its feat/body that will allow it to clean the surface of the floor. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'sheets', 'food_bread', 'food_pizza', 'tablelamp', 'scissors', 'toilet', 'walllamp', 'woman', 'knifeblock', 'hanger', 'bathroom_counter', 'man', 'tea_bag', 'keyboard', 'mail', 'stereo', 'window', 'couch', 'child', 'powersocket', 'photoframe', 'novel', 'coffe_maker', 'video_game_controller', 'ice', 'rag', 'headset', 'chessboard', 'maindoor'] Task:Greet guests response: { thoughts : Greet guests when they knock on the door and invite them to enter my home, actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>'] } Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'ground_coffee', 'cpuscreen', 'floor', 'ceiling', 'keyboard', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'food_orange', 'bowl', 'wall', 'wall_clock', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'mouthwash', 'coffee_filter', 'water', 'doorjamb', 'pencil', 'kitchen_counter', 'hair', 'controller', 'sink', 'soap'] Task:Make coffee response: | { Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'keyboard', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'bed', 'check', 'television', 'tray', 'curtain', 'mouse', 'cupboard', 'door', 'table'] Task:Relax on sofa response: { thoughts : Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['dry_pasta', 'microwave', 'toilet', 'freezer', 'walllamp', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'phone', 'character', 'mail', 'food_bacon', 'stovefan', 'mat', 'mousepad', 'couch', 'dining_room', 'broom', 'wall', 'oven', 'cutting_board', 'coffe_maker', 'food_food', 'tray', 'cards', 'mouse', 'kitchen_counter', 'home_office', 'soap'] Task:Put away groceries response: | { Place groceries in refrigerator from shopping at the grocery store. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'walllamp', 'trashcan', 'drawing', 'floor', 'ceiling', 'button', 'toaster', 'window', 'mousepad', 'clothes_pants', 'wall', 'basket_for_clothes', 'coffe_maker', 'check', 'television', 'toothbrush_holder', 'ice', 'diary', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'pajamas', 'napkin', 'coffee_cup', 'dishwasher', 'soap', 'coffee'] Task:Make coffee response: { thoughts : Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[OPEN] <coffe_maker>', '[POUR] <coffee> <coffe_maker>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>'] } Scene_Objects:['sponge', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'oven', 'bench', 'shelf', 'check', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'light', 'table', 'vase'] Task:Research response: | { I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'walllamp', 'trashcan', 'drawing', 'floor', 'bookshelf', 'toaster', 'ceilinglamp', 'stereo', 'picture', 'window', 'couch', 'towel', 'wall', 'nightstand', 'oven', 'cup', 'television', 'tray', 'kitchen_counter', 'cd', 'dresser', 'hairbrush', 'cupboard', 'home_office', 'table', 'bathroom_cabinet', 'light'] Task:Listen to music response: { thoughts : Walk to living room. Walk to radio. Switch on the radio. Walk to sofa and sit on it., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['toilet', 'band-aids', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'desk', 'keyboard', 'mail', 'button', 'table_cloth', 'bookmark', 'electric_shaver', 'pillow', 'food_kiwi', 'nightstand', 'shelf', 'food_cheese', 'light_bulb', 'check', 'coffe_maker', 'razor', 'mirror', 'food_food', 'centerpiece', 'kitchen_counter', 'sink', 'bathtub', 'home_office', 'table'] Task:Shave response: | { Pick up razor. Push the button to turn it on. Move it in a linear motion against the beard growth. Make sure to get the bottom of your chin, your cheeks, and mustache area. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'chair', 'bathroom', 'food_carrot', 'knifeblock', 'floor', 'phone', 'bedroom', 'envelope', 'mail', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'tvstand', 'shower', 'window', 'candle', 'microphone', 'pillow', 'basket_for_clothes', 'toilet_paper', 'check', 'rag', 'chessboard', 'laundry_detergent', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'washing_machine', 'coffee'] Task:Wash clothes response: { thoughts : Pick up my dirty clothes, load the washer, add detergent, turn on washer, actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>'] } Scene_Objects:['microwave', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'stereo', 'shower', 'mousepad', 'closetdrawer', 'dustpan', 'wall', 'powersocket', 'box', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'light', 'table', 'printing_paper'] Task:Print out papers response: | { Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'glue', 'pot', 'toilet', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'photoframe', 'food_food', 'television', 'doorjamb', 'kettle', 'shaving_cream', 'kitchen_counter', 'chessboard', 'dresser', 'controller', 'light'] Task:Relax on sofa response: { thoughts : I get home from work and walk into the living room. I see the couch and go to sit on it., actions : ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['ironing_board', 'sheets', 'glue', 'microwave', 'toilet', 'walllamp', 'blow_dryer', 'bathroom_counter', 'bedroom', 'computer', 'stovefan', 'tvstand', 'iron', 'faucet', 'mousepad', 'clothes_socks', 'couch', 'toy', 'cup', 'keys', 'coffe_maker', 'after_shave', 'towel_rack', 'mouse', 'kitchen_counter', 'controller', 'maindoor', 'bathtub', 'tooth_paste', 'clothes_shirt'] Task:Iron shirt response: | { Set up an ironing board and an iron. Lay a shirt on board. Run iron over shirt until it is free of wrinkles. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'beer', 'crayon', 'detergent', 'drawing', 'food_egg', 'floor', 'ceiling', 'bedroom', 'brush', 'mat', 'ceilinglamp', 'shower', 'balanceball', 'window', 'couch', 'towel', 'wall', 'bench', 'light_bulb', 'television', 'water', 'curtain', 'mouse', 'kitchen_counter', 'door', 'home_office', 'soap', 'laser_pointer'] Task:Take shower response: { thoughts : Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel., actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[TURNTO] <shower>', '[FIND] <water>', '[RINSE] <water>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <water>', '[FIND] <towel>', '[GRAB] <towel>', '[SCRUB] <towel>'] } Scene_Objects:['sheets', 'filing_cabinet', 'chair', 'cpuscreen', 'floor', 'toaster', 'mat', 'iron', 'window', 'electric_shaver', 'homework', 'clothes_socks', 'couch', 'candle', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'standingmirror', 'razor', 'television', 'tray', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'comb', 'door', 'table'] Task:Pull up carpet response: | { Pry up a corner of your old dirty carpet. Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'filing_cabinet', 'chair', 'trashcan', 'drawing', 'clothes_underwear', 'floor', 'phone', 'character', 'keyboard', 'mat', 'ceilinglamp', 'plate', 'tvstand', 'shower', 'faucet', 'mousepad', 'couch', 'wall', 'bench', 'powersocket', 'newspaper', 'bed', 'television', 'mouse', 'controller', 'table', 'light', 'instrument_violin', 'creditcard'] 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:['filing_cabinet', 'food_carrot', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'stovefan', 'mat', 'faucet', 'mousepad', 'towel', 'pillow', 'wall', 'wall_clock', 'oven', 'toy', 'cup', 'hands_both', 'standingmirror', 'food_donut', 'tray', 'mouse', 'kitchen_counter', 'hairdryer', 'sink', 'bathroom_cabinet', 'soap', 'teeth', 'shoe_rack'] Task:Wash hands response: | { Turn faucet clockwise to turn on water. Place hands under stream of water, pick up soap, rub hands with soap. Put soap back down. Rub hands together with soap on them. Rinse hands under water from faucet. Turn faucet counterclockwise to turn water off. Dry hands by rubbing them on a towel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'detergent', 'trashcan', 'floor', 'ceiling', 'bedroom', 'toaster', 'mat', 'stereo', 'pillow', 'wall', 'cup', 'bed', 'coffe_maker', 'food_food', 'coffee_filter', 'water', 'food_donut', 'wooden_spoon', 'food_onion', 'doorjamb', 'pencil', 'kitchen_counter', 'cupboard', 'napkin', 'spoon', 'dishwasher', '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:['measuring_cup', 'food_butter', 'knife', 'orchid', 'floor', 'character', 'desk', 'food_bacon', 'table_cloth', 'piano_bench', 'mat', 'picture', 'window', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'child', 'light_bulb', 'toilet_paper', 'television', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'bathtub', 'table', 'board_game'] Task:Let baby learn how to walk response: | { The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'tablelamp', 'mop', 'toilet', 'chair', 'trashcan', 'knifeblock', 'hanger', 'longboard', 'floor', 'phone', 'keyboard', 'balanceball', 'foundation', 'pillow', 'wall', 'powersocket', 'box', 'photoframe', 'bed', 'check', 'rag', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'maindoor', 'light', 'colander'] Task:Sit response: { thoughts : We sit at the dining room table, actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>'] } Scene_Objects:['scissors', 'microwave', 'toilet', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'stovefan', 'mat', 'faucet', 'mousepad', 'towel', 'wall', 'wall_clock', 'oven', 'bench', 'cutting_board', 'shelf', 'food_rice', 'tray', 'after_shave', 'towel_rack', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'soap', 'laser_pointer', 'dirt', 'hands_both'] Task:Hand washing response: | { Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry 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', 'filing_cabinet', 'blow_dryer', 'cat', 'wallshelf', 'ceiling', 'desk', 'bedroom', 'keyboard', 'stovefan', 'mousepad', 'powersocket', 'oven', 'bed', 'food_food', 'check', 'wooden_spoon', 'towel_rack', 'mouse', 'dishrack', 'comb', 'maindoor', 'bathtub', 'napkin', 'home_office', 'light', 'table', 'soap', 'laser_pointer', 'scrabble'] Task:Read book response: { thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker., actions : ['[WALK] <home_office>', '[WALK] <address_book>', '[FIND] <address_book>', '[GRAB] <address_book>', '[READ] <address_book>'] } Scene_Objects:['microwave', 'chair', 'freezer', 'detergent', 'food_carrot', 'orchid', 'floor', 'wine_glass', 'food_cake', 'mat', 'picture', 'window', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'wall', 'pasta', 'shelf', 'food_cheese', 'newspaper', 'food_food', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'bathtub', 'table', 'vase'] Task:Entertain response: | { Give guests wine, cheese, crackers and sit and talk } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'drawing', 'needle', 'knife', 'clothes_underwear', 'hanger', 'floor', 'envelope', 'computer', 'ceilinglamp', 'oil', 'mousepad', 'pillow', 'bowl', 'wall', 'nightstand', 'child', 'bed', 'novel', 'food_food', 'coffe_maker', 'television', 'doorjamb', 'dishrack', 'comb', 'laundry_detergent', 'conditioner', 'sink', 'instrument_violin'] Task:Story reading time response: { thoughts : Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures, actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[TURNTO] <child>', '[LOOKAT] <child>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>'] } Scene_Objects:['blender', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'clothes_jacket', 'table_cloth', 'mat', 'floor_lamp', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'light_bulb', 'novel', 'mouthwash', 'television', 'ice', 'curtain', 'after_shave', 'doorjamb', 'console', 'kettle', 'conditioner', 'bathtub', 'sink', 'table', 'vase'] Task:Read book response: | { A person brings a book into the living room and sits down in a comfortable chair. If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read. The person begins reading the book until they need to stop for some reason. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'orchid', 'knifeblock', 'floor', 'tea_bag', 'keyboard', 'computer', 'stovefan', 'tvstand', 'stereo', 'window', 'dustpan', 'candle', 'food_jam', 'wall', 'pasta', 'bed', 'photoframe', 'coffe_maker', 'television', 'tray', 'curtain', 'wooden_spoon', 'towel_rack', 'pencil', 'chessboard', 'cupboard', 'maindoor', 'light'] Task:Listen to music response: { thoughts : Put iPhone into speaker holder, open up the Pandora app, listen to music., actions : ['[WALK] <bedroom>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[WALK] <stereo>', '[PLUGIN] <phone>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[SIT] <bed>'] } Scene_Objects:['food_bread', 'filing_cabinet', 'food_ice_cream', 'beer', 'microwave', 'toilet', 'freezer', 'walllamp', 'food_egg', 'floor', 'ceiling', 'phone', 'keyboard', 'toaster', 'stovefan', 'brush', 'faucet', 'food_peanut_butter', 'clothes_pants', 'wall', 'oven', 'powersocket', 'cutting_board', 'food_cheese', 'coffe_maker', 'food_food', 'tray', 'kitchen_counter', 'comb', 'sink'] Task:Make toast response: | { Place slices of bread in a toaster ,wait for the bread to pop up .Set aside. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'measuring_cup', 'microwave', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'face', 'mop_bucket', 'tvstand', 'faucet', 'food_peanut_butter', 'towel', 'wall', 'oven', 'face_soap', 'tape', 'photoframe', 'bed', 'keys', 'rag', 'cards', 'comb', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet'] Task:Wash face response: { thoughts : Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <rag>', '[GRAB] <rag>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[WASH] <rag>', '[FIND] <face_soap>', '[GRAB] <face_soap>', '[POUR] <face_soap> <rag>', '[PUTOBJBACK] <face_soap>', '[FIND] <face>', '[SCRUB] <face>', '[PUTBACK] <rag> <sink>', '[RINSE] <face>', '[RINSE] <rag>', '[SWITCHOFF] <faucet>', '[GRAB] <rag>', '[PUTOBJBACK] <rag>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['spectacles', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'legs_both', 'desk', 'keyboard', 'face', 'computer', 'toaster', 'mousepad', 'closetdrawer', 'dustpan', 'towel', 'wall', 'feet_both', 'powersocket', 'arms_both', 'basket_for_clothes', 'cup', 'check', 'mouse', 'shoes', 'dresser', 'hairbrush', 'controller', 'light', 'clothes_shirt'] Task:Try yourself off response: | { After your shower, go into your bedroom and use a towel to dry water off of yourself before dressing. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'ground_coffee', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'folder', 'purse', 'computer', 'toaster', 'laptop', 'shower', 'picture', 'couch', 'wall', 'pasta', 'nightstand', 'box', 'photoframe', 'coffe_maker', 'television', 'coffee_filter', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'instrument_violin'] Task:Make coffee response: { thoughts : Open the coffee maker and put a filer, grab ground coffee and put it in the coffee maker, then close the coffee maker and switch it on, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[FIND] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['pot', 'tea', 'walllamp', 'bathroom', 'wallshelf', 'ceiling', 'dvd_player', 'tea_bag', 'food_bacon', 'toaster', 'homework', 'clothes_pants', 'nightstand', 'wall', 'powersocket', 'toy', 'newspaper', 'standingmirror', 'novel', 'bed', 'console', 'mouse', 'shoes', 'controller', 'door', 'sink', 'bathtub', 'home_office', 'table', 'vase'] Task:Watch fly response: | { Look around for a fly, often on a wall or ceiling. Follow it's movements. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'foundation', 'couch', 'wall', 'pasta', 'toy', 'box', 'television', 'curtain', 'diary', 'towel_rack', 'kitchen_counter', 'cupboard', 'clothes_scarf', 'home_office', 'table', 'vase', 'coffee'] Task:Change TV channels response: { thoughts : Take remote. Change to desired channel by you., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>'] } Scene_Objects:['fork', 'tablelamp', 'juice', 'nail_polish', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'mat', 'shower', 'window', 'closetdrawer', 'wall', 'nightstand', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'television', 'curtain', 'mouse', 'pencil', 'vacuum_cleaner', 'hair', 'maindoor', 'table', 'vase'] Task:Read book response: | { I lie on my bed and read a 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:['toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'dresser', 'hairbrush', 'clothes_dress', 'door', 'sink', 'spoon', 'table', 'light'] Task:Change TV channel response: { thoughts : I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['sponge', 'tablelamp', 'detergent', 'wallshelf', 'hanger', 'floor', 'phone', 'shampoo', 'character', 'desk', 'mop_bucket', 'bookmark', 'toaster', 'mat', 'window', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'mouthwash', 'television', 'razor', 'curtain', 'after_shave', 'doorjamb', 'bathroom_cabinet', 'table', 'light'] Task:Read book response: | { Pick up a book and open to the last page you were on. Read the 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:['tablelamp', 'chair', 'cat', 'ceilingfan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'oil', 'couch', 'wall', 'wall_clock', 'powersocket', 'oven', 'bench', 'newspaper', 'mouthwash', 'television', 'diary', 'towel_rack', 'mouse', 'dresser', 'hairbrush', 'hairdryer', 'soap'] Task:Check email response: { thoughts : Sit in teak deck chair, have wooden drawing board on lap, laptop on wooden drawing board, log in to my two email accounts, go through new emails and respond., actions : ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <chair>', '[SIT] <chair>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>'] } Scene_Objects:['microwave', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'plate', 'iron', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'cutting_board', 'clothes_gloves', 'check', 'coffe_maker', 'food_food', 'curtain', 'food_onion', 'mouse', 'comb', 'dresser', 'clothes_dress', 'sink', 'light', 'coffee'] Task:Hang up jacket response: | { I put clothes on hangers and hang them in the closet } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'juice', 'jelly', 'freezer', 'walllamp', 'nail_polish', 'knifeblock', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'button', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'mousepad', 'pillow', 'wall', 'oven', 'powersocket', 'bench', 'cup', 'food_food', 'food_rice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'table', 'board_game'] Task:Grab some juice response: { thoughts : I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <juice>', '[GRAB] <juice>', '[POUR] <juice> <cup>', '[PUTOBJBACK] <juice>', '[CLOSE] <freezer>', '[FIND] <table>', '[PUTBACK] <cup> <table>'] } Scene_Objects:['pot', 'tablelamp', 'chair', 'toothbrush', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'mat', 'faucet', 'window', 'towel', 'pillow', 'wall', 'wall_clock', 'oven', 'bench', 'cutting_board', 'television', 'food_rice', 'ice', 'wooden_spoon', 'tray', 'comb', 'sink', 'bathroom_cabinet', 'tooth_paste', 'teeth'] Task:Brush teeth response: | { Put toothpaste on toothbrush, brush teeth, rinse mouth } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'toilet', 'cat', 'wallshelf', 'bathroom_counter', 'floor', 'dvd_player', 'bookshelf', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'shower', 'faucet', 'tvstand', 'couch', 'towel', 'wall', 'bench', 'cutting_board', 'bed', 'razor', 'television', 'curtain', 'kitchen_counter', 'dresser', 'home_office', 'light'] Task:Pet cat response: { thoughts : Pet Cat, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['spectacles', 'filing_cabinet', 'food_salt', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'deck_of_cards', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'powersocket', 'toy', 'tape', 'light_bulb', 'check', 'food_food', 'television', 'curtain', 'doorjamb', 'mouse', 'pencil', 'dresser', 'conditioner', 'spoon', 'light', 'table', 'colander'] Task:Re arrange office response: | { Walk in.Turn on light.Move furniture. Change the 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:['tablelamp', 'crayon', 'jelly', 'freezer', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'food_cake', 'mop_bucket', 'stovefan', 'mat', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'food_food', 'television', 'wine', 'tray', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'light', 'clothes_skirt'] Task:Put groceries in Fridge response: { thoughts : Go to kitchen, open fridge, get groceries, put groceries in fridge, close fridge, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['food_ice_cream', 'bathroom', 'food_carrot', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'stamp', 'faucet', 'stereo', 'shower', 'oil', 'closetdrawer', 'microphone', 'clothes_hat', 'wall', 'nightstand', 'oven', 'tape', 'cup', 'keys', 'toilet_paper', 'curtain', 'shoes', 'maindoor', 'sink', 'bathtub', 'food_steak', 'light', 'coffee'] Task:Take dishes out of dishwasher response: | { Take clean dishes out of the dishwasher and put away } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'dog', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'form', 'wall', 'powersocket', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'mouse', 'cupboard', 'bathtub', 'sink', 'table'] Task:Work response: { thoughts : go to home office. turn the computer on. begin working, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['dry_pasta', 'food_ice_cream', 'toothbrush', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'alcohol', 'brush', 'shoe-shine_kit', 'faucet', 'mousepad', 'closetdrawer', 'candle', 'clothes_pants', 'wall', 'standingmirror', 'food_food', 'television', 'tray', 'coffee_pot', 'towel_rack', 'dresser', 'bathtub', 'bathroom_cabinet', 'vase'] Task:Dust response: | { Using soft brush, carefully dust both Indonesian wedding doll statues. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_bread', 'filing_cabinet', 'tablelamp', 'crayon', 'woman', 'wallshelf', 'shampoo', 'floor', 'phone', 'desk', 'man', 'bookshelf', 'closetdrawer', 'couch', 'dining_room', 'nightstand', 'child', 'bed', 'photoframe', 'standingmirror', 'toilet_paper', 'oven_mitts', 'towel_rack', 'kitchen_counter', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'vase'] Task:Say goodbye to guests leaving response: { thoughts : Tell them bye, actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[FIND] <man>', '[TOUCH] <man>', '[FIND] <woman>', '[TOUCH] <woman>'] } Scene_Objects:['food_bread', 'chair', 'cpuscreen', 'ceiling', 'character', 'video_game_console', 'bookshelf', 'keyboard', 'computer', 'mat', 'faucet', 'window', 'mousepad', 'wall_clock', 'tape', 'cutting_board', 'food_cheese', 'check', 'video_game_controller', 'mouthwash', 'food_onion', 'rag', 'coffee_pot', 'towel_rack', 'pencil', 'vacuum_cleaner', 'cd', 'dresser', 'home_office', 'dirt'] Task:Playing video game response: | { Playing video games on various video game systems such as wii u and xbox } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['water_glass', 'scissors', 'measuring_cup', 'freezer', 'food_butter', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'food_cake', 'mat', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'food_food', 'check', 'television', 'water', 'kitchen_counter', 'cupboard', 'door', 'light', 'clothes_skirt'] Task:Drink response: { thoughts : go to kitchen, find water glass and grab it, find fridge and open grab water and pour into it, then drink., actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[FIND] <freezer>', '[OPEN] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[CLOSE] <freezer>', '[DRINK] <water_glass>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'bathroom', 'milk', 'floor', 'bookshelf', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'bench', 'oven', 'toy', 'cutting_board', 'shelf', 'cup', 'standingmirror', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'console', 'pencil', 'comb', 'sink', 'home_office', 'scrabble'] Task:Pick up toys response: | { Grab toys off floor. Put it in a container. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_salt', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'computer', 'button', 'tvstand', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'oven', 'coffee_table', 'novel', 'television', 'curtain', 'doorjamb', 'lighter', 'dresser', 'home_office', 'table'] Task:Change TV channel response: { thoughts : Go to the living room, find the remote control on the coffee table, and change the TV channel., actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <coffee_table>', '[WALK] <coffee_table>', '[TURNTO] <coffee_table>', '[LOOKAT] <coffee_table>', '[FIND] <remote_control>', '[TOUCH] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[TOUCH] <button>', '[PUSH] <button>'] } Scene_Objects:['toilet', 'chair', 'bathroom', 'food_butter', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'shoe-shine_kit', 'shower', 'mousepad', 'closetdrawer', 'clothes_hat', 'wall', 'powersocket', 'cup', 'photoframe', 'novel', 'doorjamb', 'mouse', 'dresser', 'clothes_dress', 'light', 'clothes_skirt', 'vase'] Task:Sew response: | { Using the sewing machine to fix and make clothes } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'ceilingfan', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'face', 'mail', 'table_cloth', 'faucet', 'food_jam', 'towel', 'dining_room', 'wall', 'face_soap', 'toy', 'photoframe', 'keys', 'water', 'rag', 'pencil', 'shoes', 'dresser', 'sink', 'bathroom_cabinet', 'home_office', 'colander', 'hands_both'] Task:Wash face response: { thoughts : Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel., actions : ['[WALK] <bathroom>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <rag> <sink>', '[GRAB] <rag>', '[FIND] <face_soap>', '[GRAB] <face_soap>', '[POUR] <face_soap> <rag>', '[PUTOBJBACK] <face_soap>', '[FIND] <face>', '[SCRUB] <face>', '[PUTBACK] <rag> <sink>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <hands_both>', '[POUR] <water> <hands_both>', '[RINSE] <face>', '[WASH] <rag>', '[GRAB] <rag>', '[PUTOBJBACK] <rag>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['mop', 'walllamp', 'food_butter', 'food_carrot', 'drawing', 'cpuscreen', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'food_bacon', 'electric_shaver', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'photoframe', 'curtain', 'rag', 'mouse', 'shoes', 'dresser', 'hairdryer', 'bag', 'light', 'tooth_paste'] Task:Take off shoes response: | { Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'stamp', 'envelope', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'powersocket', 'standingmirror', 'television', 'curtain', 'doorjamb', 'mouse', 'bag', 'home_office', 'table', 'soap'] Task:Relax on sofa response: { thoughts : I walk to my living room and switch on the television, and lay on the sofa., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>'] } Scene_Objects:['sheets', 'glue', 'tablelamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'clothes_jacket', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'bed', 'novel', 'mouse', 'shoes', 'dresser', 'clothes_dress', 'light', 'table'] Task:Get ready for day response: | { Grab shoes, purse etc and head out the door! } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['band-aids', 'trashcan', 'wallshelf', 'clothes_underwear', 'desk', 'keyboard', 'mail', 'computer', 'tvstand', 'shower', 'window', 'clothes_socks', 'couch', 'food_peanut_butter', 'pillow', 'basket_for_clothes', 'keys', 'coffe_maker', 'television', 'food_donut', 'tray', 'rag', 'headset', 'clothes_scarf', 'bathtub', 'sink', 'light', 'dishwasher', 'soap', 'washing_machine'] Task:Wash clothes response: { thoughts : 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, actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['knife', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'folder', 'desk', 'keyboard', 'computer', 'mat', 'stereo', 'mousepad', 'closetdrawer', 'clothes_pants', 'wall', 'powersocket', 'cup', 'newspaper', 'novel', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'spoon', 'light', 'soap', 'board_game', 'clothes_shirt', 'scrabble'] Task:Get dressed response: | { Pick out the clothes you are going to wear and put them on your body } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'tablelamp', 'microwave', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'bench', 'cup', 'doorjamb', 'mouse', 'address_book', 'hairbrush', 'hairdryer', 'light', 'creditcard'] Task:Work response: { thoughts : Walk to home office. Walk to computer. Switch on computer. Open the address book., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[FIND] <address_book>'] } Scene_Objects:['juice', 'blender', 'beer', 'microwave', 'freezer', 'walllamp', 'detergent', 'floor', 'ceiling', 'character', 'stovefan', 'faucet', 'couch', 'clothes_hat', 'food_orange', 'broom', 'wall', 'oven', 'cutting_board', 'shelf', 'food_cheese', 'bed', 'coffe_maker', 'food_food', 'tray', 'after_shave', 'lighter', 'kitchen_counter', 'vase', 'coffee'] Task:Eat cheese response: | { Open fridge. Get cheese. Eat it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'chair', 'dog', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'pasta', 'light_bulb', 'clothes_gloves', 'television', 'curtain', 'doorjamb', 'conditioner', 'door', 'light'] Task:Relax on sofa response: { thoughts : I walk into the living room and turn on the light. I walk to the couch then sit on the couch., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['spectacles', 'microwave', 'chair', 'dog', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'laptop', 'mat', 'mousepad', 'closetdrawer', 'couch', 'wall', 'powersocket', 'coffe_maker', 'wine', 'doorjamb', 'kettle', 'mouse', 'pencil', 'dresser', 'light'] Task:Work response: | { I walk in. Turn on the light. Set in my chair. Turn on lap top. And start to work. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'mop', 'bathroom', 'dough', 'knifeblock', 'hanger', 'keyboard', 'alcohol', 'toaster', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'pasta', 'basket_for_clothes', 'check', 'television', 'razor', 'tray', 'doorjamb', 'chessboard', 'dishrack', 'hairbrush', 'napkin', 'bathroom_cabinet', 'light', 'dishwasher', 'table'] Task:Pick up phone response: { thoughts : go to living room, find phone, pick up phone, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['sheets', 'freezer', 'nail_polish', 'woman', 'bathroom_counter', 'floor', 'shampoo', 'man', 'keyboard', 'purse', 'stovefan', 'mat', 'window', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'wall_clock', 'bench', 'shelf', 'standingmirror', 'check', 'television', 'curtain', 'doorjamb', 'pencil', 'bag', 'table', 'soap'] Task:Hang with friends response: | { Sit with friends. Talk } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'milk', 'floor', 'ceiling', 'desk', 'keyboard', 'button', 'mop_bucket', 'toaster', 'stereo', 'window', 'wall', 'powersocket', 'bench', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'food_sugar', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'coffee_cup', 'dishwasher', 'light', 'clothes_shirt'] 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:['pot', 'tablelamp', 'walllamp', 'woman', 'drawing', 'phone', 'desk', 'man', 'toaster', 'laptop', 'mat', 'shower', 'electric_shaver', 'oil', 'form', 'pillow', 'dining_room', 'oven', 'shelf', 'bed', 'standingmirror', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'tooth_paste', 'scrabble'] Task:Greet guests response: | { Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'bedroom', 'tea_bag', 'laptop', 'tvstand', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_hat', 'wall', 'nightstand', 'powersocket', 'photoframe', 'coffe_maker', 'check', 'television', 'doorjamb', 'towel_rack', 'cards', 'dresser', 'door', 'home_office', 'light'] Task:Turn on light response: { thoughts : I walk into the dining room and turn on the lights, actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['sheets', 'tablelamp', 'dough', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'window', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'check', 'curtain', 'mouse', 'pencil', 'dresser', 'light', 'table', 'vase', 'shoe_rack'] Task:Read book response: | { Put child in bed, sit down,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:['chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'desk', 'food_cake', 'stovefan', 'toaster', 'deck_of_cards', 'faucet', 'candle', 'pillow', 'dining_room', 'oven', 'photoframe', 'check', 'food_food', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'soap', 'board_game', 'clothes_shirt'] Task:Pet cat response: { thoughts : Walk to living room. Find cat. Walk to cat. Pull cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[PULL] <cat>'] } Scene_Objects:['sheets', 'spectacles', 'filing_cabinet', 'food_salt', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'character', 'shower', 'stereo', 'microphone', 'wall', 'toy', 'cutting_board', 'cup', 'novel', 'food_food', 'check', 'food_onion', 'coffee_pot', 'console', 'shaving_cream', 'towel_rack', 'shoes', 'cd', 'hairbrush', 'maindoor', 'soap', 'coffee'] Task:Read response: | { Read a book 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:['sheets', 'glue', 'toilet', 'chair', 'bathroom', 'drawing', 'longboard', 'floor', 'ceiling', 'food_cake', 'mat', 'ceilinglamp', 'shower', 'deck_of_cards', 'balanceball', 'shoe-shine_kit', 'tvstand', 'candle', 'food_kiwi', 'wall', 'nightstand', 'powersocket', 'bench', 'food_cheese', 'novel', 'coffe_maker', 'curtain', 'towel_rack', 'home_office', 'dishwasher'] Task:Take shower response: { thoughts : Walk to the bathroom and wash with the shower., actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[WASH] <shower>'] } Scene_Objects:['chair', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'tvstand', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'oven', 'cup', 'standingmirror', 'check', 'television', 'centerpiece', 'console', 'mouse', 'vacuum_cleaner', 'shoes', 'comb', 'dresser', 'hairbrush', 'sink', 'bag', 'napkin', 'bathroom_cabinet', 'vase'] Task:vacuum carpet response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'stovefan', 'faucet', 'window', 'mousepad', 'closetdrawer', 'couch', 'towel', 'wall', 'nightstand', 'curtain', 'towel_rack', 'mouse', 'coffee_pot', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : I go to the bathroom and locate the sink. I turn the faucet so that water is running, and rinse my hands briefly. Then I grab the soap and squeeze some onto my hands. I spend a few minutes rubbing my hands together, then I rinse them again. Finally, I turn the faucet off and wipe my hands on a towel., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SQUEEZE] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>'] } Scene_Objects:['food_bread', 'tablelamp', 'blender', 'tea', 'chair', 'freezer', 'drawing', 'orchid', 'hanger', 'floor', 'shampoo', 'stamp', 'bedroom', 'desk', 'computer', 'mat', 'stereo', 'mousepad', 'food_jam', 'dining_room', 'wall', 'wall_clock', 'bench', 'photoframe', 'food_food', 'dresser', 'napkin', 'home_office', 'table', 'spoon'] Task:Eat dinner response: | { In our dining room, my family eats dinner. Once the food has been prepared, we gather at the dining room table and prepare to eat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'door', 'light', 'table'] Task:Vacuum response: { thoughts : Keep my keyboard vacuumed and free of debris., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>'] } Scene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'thread', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'photoframe', 'toilet_paper', 'television', 'razor', 'coin', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table'] Task:Turn on computer response: | { Push power button. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'plate', 'couch', 'pillow', 'wall', 'newspaper', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'bathtub', 'light', 'table'] Task:Pet cat response: { thoughts : My cat looks like it wants attention, so I will go pet it on the couch., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['filing_cabinet', 'blender', 'band-aids', 'freezer', 'orchid', 'cpuscreen', 'floor', 'bookshelf', 'envelope', 'toaster', 'stovefan', 'plate', 'shower', 'faucet', 'foundation', 'oil', 'mousepad', 'food_jam', 'microphone', 'dining_room', 'bench', 'oven', 'toy', 'box', 'food_food', 'food_onion', 'diary', 'kitchen_counter', 'cupboard', 'colander'] Task:Get out dish response: | { Open cupboard. Get out the dish. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'dining_room', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'soap'] Task:Work response: { thoughts : I go to my home office, sit on the chair and turn on the computer. I open my email account to look for all the information I need.I pull up my online task on the computer to look at what the assigned task is., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['fork', 'sheets', 'food_salt', 'tea', 'blow_dryer', 'wallshelf', 'ceiling', 'character', 'food_cake', 'computer', 'tvstand', 'window', 'mousepad', 'cutting_board', 'basket_for_clothes', 'cup', 'newspaper', 'light_bulb', 'novel', 'photoframe', 'coin', 'food_donut', 'rag', 'cards', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'maindoor', 'bag', 'creditcard'] Task:Clean response: | { Clean the welcome mat } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'toilet', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'light_bulb', 'novel', 'television', 'curtain', 'cupboard', 'bathtub', 'table'] Task:Read book response: { thoughts : I go to the living room, take a book from the shelf, sit in the sofa and read the book, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>'] } Scene_Objects:['sheets', 'fork', 'scissors', 'food_salt', 'dog', 'milk', 'drawing', 'needle', 'hanger', 'bedroom', 'keyboard', 'bookshelf', 'stovefan', 'tvstand', 'closetdrawer', 'wall_clock', 'oven', 'toy', 'photoframe', 'novel', 'toilet_paper', 'food_food', 'check', 'food_onion', 'kitchen_counter', 'hairdryer', 'bathtub', 'vase', 'instrument_violin', 'creditcard'] Task:Read book response: | { Go to the book shelf, get a book, open the book and read the 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:['filing_cabinet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'powersocket', 'clothes_gloves', 'television', 'razor', 'curtain', 'doorjamb', 'console', 'mouse', 'door', 'bag', 'table', 'dishwasher'] Task:Change TV channel response: { thoughts : I walk in living room. I find TV remote. I grab TV remote. I sit on sofa. I switch on TV. I switch channel., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[PUSH] <remote_control>'] } Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'phone', 'button', 'mat', 'stereo', 'window', 'homework', 'foundation', 'couch', 'pillow', 'wall', 'toy', 'cup', 'light_bulb', 'television', 'razor', 'curtain', 'after_shave', 'doorjamb', 'rag', 'coffee_pot', 'laundry_detergent', 'bathtub', 'table'] Task:Arrange furniture response: | { Move furniture where you want 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:['sheets', 'filing_cabinet', 'measuring_cup', 'toilet', 'chair', 'cat', 'milk', 'orchid', 'phone', 'video_game_console', 'bookshelf', 'keyboard', 'purse', 'table_cloth', 'brush', 'mat', 'iron', 'couch', 'cup', 'basket_for_clothes', 'video_game_controller', 'oven_mitts', 'food_donut', 'doorjamb', 'console', 'dresser', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'home_office'] Task:Playing video game response: { thoughts : Playing video games on various video game systems such as wii u and xbox, actions : ['[WALK] <home_office>', '[WALK] <video_game_console>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[PUTOBJBACK] <video_game_controller>', '[SWITCHOFF] <video_game_console>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>'] } Scene_Objects:['chair', 'walllamp', 'ground_coffee', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'bookmark', 'ceilinglamp', 'window', 'foundation', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'television', 'coffee_filter', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'sink', 'light', 'table', 'shoe_rack'] Task:Write an email response: | { Compose an email in the home office. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'bathroom', 'orchid', 'wallshelf', 'ceiling', 'phone', 'stamp', 'bookshelf', 'mail', 'computer', 'tvstand', 'shower', 'couch', 'pillow', 'oven', 'powersocket', 'box', 'bed', 'clothes_gloves', 'photoframe', 'check', 'curtain', 'pencil', 'dresser', 'cupboard', 'door', 'sink', 'bathtub', 'home_office', 'dishwasher'] Task:Pet cat response: { thoughts : find a cat, touch it gently, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['sheets', 'toilet', 'dog', 'band-aids', 'walllamp', 'ground_coffee', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'phone', 'food_cake', 'computer', 'toaster', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'table', 'light', 'scrabble'] Task:Relax on sofa response: | { I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'food_pizza', 'food_salt', 'freezer', 'drawing', 'knife', 'cpuscreen', 'knifeblock', 'floor', 'character', 'bookshelf', 'laptop', 'plate', 'mousepad', 'candle', 'dining_room', 'wall', 'light_bulb', 'food_food', 'coffe_maker', 'tray', 'kitchen_counter', 'chessboard', 'dishrack', 'shoes', 'cupboard', 'laundry_detergent', 'dishwasher', 'instrument_violin'] 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:['pot', 'microwave', 'freezer', 'walllamp', 'food_butter', 'dough', 'food_carrot', 'drawing', 'food_egg', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'faucet', 'oil', 'wall', 'pasta', 'powersocket', 'oven', 'wall_clock', 'cutting_board', 'food_food', 'coffe_maker', 'oven_mitts', 'wooden_spoon', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'maindoor', 'sink', 'bathroom_cabinet', 'light'] Task:Cook some food response: | { I walk into the kitchen and walk over the cabinent. I pull out a pan and walk to the stove. I put the pan on the stove and walk over to the fridge. I pull out out meat from the fridge and walk back over the stove. Then I put the meat in the pan. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_salt', 'microwave', 'ceilingfan', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'stovefan', 'mat', 'iron', 'electric_shaver', 'food_noodles', 'mousepad', 'couch', 'clothes_pants', 'pillow', 'powersocket', 'keys', 'coffe_maker', 'oven_mitts', 'wine', 'shaving_cream', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'light', 'tooth_paste'] Task:Hang up car keys response: { thoughts : Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall., actions : ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>'] } Scene_Objects:['microwave', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'mat', 'window', 'clothes_socks', 'couch', 'pillow', 'towel', 'broom', 'wall', 'bench', 'oven', 'toy', 'bed', 'coffe_maker', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'food_onion', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table', 'scrabble'] Task:Relax on sofa response: | { Walk to living room. Find couch. Sit on couch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'juice', 'measuring_cup', 'microwave', 'walllamp', 'trashcan', 'floor', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'candle', 'pillow', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'newspaper', 'coffe_maker', 'tray', 'kitchen_counter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer'] Task:Wash dishes with dishwasher response: { thoughts : Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['toilet', 'chair', 'walllamp', 'floor', 'dvd_player', 'bedroom', 'bookshelf', 'food_cake', 'shower', 'picture', 'foundation', 'mousepad', 'closetdrawer', 'tooth_paste', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'shelf', 'food_food', 'doorjamb', 'coffee_pot', 'mouse', 'pencil', 'kitchen_counter', 'towel_rack', 'door', 'napkin', 'bathroom_cabinet', 'board_game'] Task:Go to toilet response: | { I go to the bathroom. I locate the toilet. I walk to the 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:['glue', 'walllamp', 'ceilingfan', 'drawing', 'hanger', 'floor', 'bedroom', 'computer', 'ceilinglamp', 'deck_of_cards', 'iron', 'window', 'electric_shaver', 'couch', 'food_orange', 'wall', 'wall_clock', 'bed', 'novel', 'check', 'television', 'toothbrush_holder', 'wooden_spoon', 'after_shave', 'towel_rack', 'dresser', 'conditioner', 'maindoor', 'table', 'vase'] Task:Relax on sofa response: { thoughts : Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['microwave', 'food_egg', 'bathroom_counter', 'ceiling', 'computer', 'button', 'food_bacon', 'plate', 'stereo', 'shower', 'window', 'picture', 'food_kiwi', 'wall', 'wall_clock', 'toy', 'shelf', 'bed', 'toilet_paper', 'oven_mitts', 'tray', 'after_shave', 'doorjamb', 'mouse', 'pencil', 'clothes_dress', 'maindoor', 'sink', 'food_steak', 'bathroom_cabinet'] Task:Listen to music response: | { I go into the living room and turn on the radio. Then, I select the station I want, which is usually a preset. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['juice', 'bathroom', 'ceilingfan', 'drawing', 'bills', 'knife', 'orchid', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'keys', 'television', 'coffee_filter', 'curtain', 'centerpiece', 'cupboard', 'bathroom_cabinet', 'table'] Task:Change TV channel response: { thoughts : change the tv channel, actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } 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: | { move to living room, locate sofa, move to sofa, sit on sofa, lie on 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', 'juice', 'toilet', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'phone', 'desk', 'stovefan', 'plate', 'faucet', 'window', 'mousepad', 'form', 'pillow', 'wall', 'wall_clock', 'oven', 'clothes_gloves', 'tray', 'diary', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'sink'] Task:Wash dishes by hand response: { thoughts : Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[TURNTO] <plate>', '[LOOKAT] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WASH] <plate>', '[PUTBACK] <plate> <kitchen_counter>'] } Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'wallshelf', 'hanger', 'phone', 'character', 'desk', 'table_cloth', 'mat', 'tvstand', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall_clock', 'powersocket', 'cutting_board', 'television', 'food_donut', 'food_rice', 'towel_rack', 'controller', 'maindoor'] Task:Pet cat response: | { find a cat, touch 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:['sponge', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'toaster', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'love_seat', 'clothes_gloves', 'television', 'tray', 'curtain', 'food_onion', 'dresser', 'cupboard', 'instrument_guitar', 'table', 'light'] Task:Watch TV response: { thoughts : I'll watch TV, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'blender', 'milk', 'orchid', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'thread', 'stovefan', 'mat', 'toaster', 'faucet', 'plate', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'wall_clock', 'oven', 'tray', 'curtain', 'mouse', 'sink', 'napkin', 'bathroom_cabinet', 'soap'] Task:Wash hands response: | { walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse 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', 'food_bread', 'dog', 'ground_coffee', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'bedroom', 'alcohol', 'mop_bucket', 'stovefan', 'laptop', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'window', 'mat', 'mousepad', 'food_orange', 'pillow', 'powersocket', 'coffe_maker', 'fly', 'coffee_pot', 'kitchen_counter', 'cupboard', 'dishwasher', 'soap'] Task:Watch fly response: { thoughts : Look around for a fly, often on a wall or ceiling. Follow it's movements., actions : ['[WALK] <bedroom>', '[WALK] <fly>', '[FIND] <fly>', '[TURNTO] <fly>', '[LOOKAT] <fly>'] } Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'orchid', 'hanger', 'phone', 'computer', 'piano_bench', 'nightstand', 'pasta', 'wall_clock', 'powersocket', 'toy', 'food_cheese', 'clothes_gloves', 'check', 'toilet_paper', 'television', 'after_shave', 'doorjamb', 'door', 'hairdryer', 'sink', 'home_office', 'light', 'table', 'clothes_scarf', 'soap'] Task:Read book response: | { go to bedroom, sit down, pick up book, read } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'stovefan', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'towel', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'coin', 'tray', 'food_onion', 'doorjamb', 'towel_rack', 'dishrack', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Go to the bathroom. Turn on the sink. Rinse hands. Apply soap and scrub your hands together. Rinse hands again. Turn off faucet. Dry hands on a towel., actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['food_salt', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'thread', 'computer', 'piano_bench', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table'] Task:Work response: | { Walk to the home office and turn to the desk. Switch on the computer. Grab the mouse and keyboard to start 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:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'laptop', 'faucet', 'tvstand', 'window', 'couch', 'microphone', 'towel', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'food_food', 'television', 'tray', 'mouse', 'dresser', 'sink', 'clothes_scarf', 'home_office', 'table', 'clothes_skirt'] Task:Relax on sofa response: { thoughts : I walk to the living room. I see the couch. I sit down on the couch, then lie down and put my feet up., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['toilet', 'chair', 'dog', 'walllamp', 'ground_coffee', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'shower', 'faucet', 'clothes_socks', 'towel', 'wall', 'cutting_board', 'shelf', 'basket_for_clothes', 'coffe_maker', 'food_rice', 'water', 'tray', 'doorjamb', 'food_steak', 'home_office', 'vase', 'soap', 'teeth'] Task:Take shower response: | { Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'dog', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'longboard', 'floor', 'phone', 'character', 'purse', 'computer', 'toaster', 'plate', 'balanceball', 'stereo', 'dish_soap', 'food_kiwi', 'wall', 'oven', 'tape', 'coffe_maker', 'mouthwash', 'tray', 'door', 'sink', 'napkin', 'dishwasher', 'vase'] Task:Wash dishes with dishwasher response: { thoughts : Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'oil', 'pillow', 'dining_room', 'wall', 'wall_clock', 'bench', 'standingmirror', 'television', 'curtain', 'doorjamb', 'mouse', 'headset', 'napkin', 'table'] Task:Watch TV response: | { Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_ice_cream', 'microwave', 'freezer', 'trashcan', 'toothbrush', 'orchid', 'hanger', 'desk', 'keyboard', 'bookmark', 'shoe-shine_kit', 'iron', 'tvstand', 'plate', 'mousepad', 'microphone', 'wall', 'bench', 'toilet_paper', 'television', 'toothbrush_holder', 'ice', 'shoes', 'chessboard', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'tooth_paste', 'teeth', 'creditcard'] Task:Wash teeth response: { thoughts : walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the teeth, actions : ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>'] } Scene_Objects:['toilet', 'freezer', 'dough', 'cpuscreen', 'hanger', 'computer', 'piano_bench', 'bookmark', 'mat', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'wall', 'nightstand', 'box', 'photoframe', 'toilet_paper', 'video_game_controller', 'food_food', 'doorjamb', 'towel_rack', 'hairbrush', 'hair', 'instrument_violin', 'sink', 'home_office', 'light', 'vase', 'tooth_paste'] Task:Pick up phone response: | { walk into room, grab phone } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'floor', 'ceiling', 'bedroom', 'window', 'clothes_socks', 'couch', 'dustpan', 'clothes_pants', 'food_orange', 'food_kiwi', 'wall', 'toy', 'bed', 'photoframe', 'food_food', 'coffe_maker', 'wine', 'doorjamb', 'diary', 'console', 'mouse', 'door', 'bathroom_cabinet', 'light', 'vase', 'soap'] Task:Turn off light response: { thoughts : Grasp light switch, flip light switch., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[SWITCHOFF] <light>'] } Scene_Objects:['microwave', 'toilet', 'freezer', 'ground_coffee', 'walllamp', 'dough', 'food_carrot', 'floor', 'ceiling', 'stovefan', 'toaster', 'stereo', 'clothes_hat', 'wall', 'oven', 'bench', 'cutting_board', 'food_cheese', 'coffe_maker', 'food_food', 'check', 'toothbrush_holder', 'food_donut', 'tray', 'kitchen_counter', 'dishrack', 'hairbrush', 'bag', 'bathroom_cabinet', 'creditcard'] Task:Put groceries in Fridge response: | { Open the fridge, put the groceries in the fridge and close 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:['walllamp', 'nail_polish', 'bathroom', 'detergent', 'knife', 'cpuscreen', 'dvd_player', 'bedroom', 'computer', 'table_cloth', 'mop_bucket', 'brush', 'toaster', 'shower', 'window', 'couch', 'dining_room', 'wall', 'pasta', 'cup', 'photoframe', 'after_shave', 'pencil', 'kitchen_counter', 'dresser', 'clothes_dress', 'sink', 'instrument_guitar', 'light', 'creditcard'] Task:Sit response: { thoughts : We sit at the dining room table, actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>'] } Scene_Objects:['glue', 'dog', 'bathroom', 'toothbrush', 'orchid', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'dining_room', 'wall', 'wall_clock', 'oven', 'razor', 'toothbrush_holder', 'tray', 'centerpiece', 'doorjamb', 'instrument_violin', 'sink', 'bathroom_cabinet', 'vase', 'tooth_paste'] Task:Brush teeth response: | { go to bathroom. grab toothbrush. put toothpaste on toothbrush. brush teeth. turn on faucet. rinse toothbrush and mouth. put toothbrush away. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'mat', 'faucet', 'window', 'wall', 'wall_clock', 'powersocket', 'box', 'cup', 'bed', 'video_game_controller', 'television', 'doorjamb', 'console', 'kitchen_counter', 'door', 'light', 'teeth'] Task:Pick up phone response: { thoughts : I walk over to the phone and pick it up., actions : ['[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['spectacles', 'blender', 'crayon', 'microwave', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'envelope', 'stovefan', 'window', 'oil', 'wall', 'powersocket', 'bench', 'toy', 'keys', 'food_donut', 'wooden_spoon', 'curtain', 'doorjamb', 'maindoor', 'bathtub', 'bathroom_cabinet', 'light', 'dirt', 'teeth'] Task:Turn on light response: | { walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on 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_carrot', 'milk', 'dough', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'stereo', 'towel', 'pillow', 'wall', 'bench', 'cup', 'bed', 'photoframe', 'coffe_maker', 'wooden_spoon', 'after_shave', 'rag', 'mouse', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Turn on the water faucet. Wet my hands and turn off the faucet. Put soap on my hands. Rub hands together, making sure the soap covers all areas of the hands. Scrub hands for about 20 seconds. Turn on the water water faucet. Rinse hands under the running water. Turn off the water faucet. Dry hands with a towel., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['dry_pasta', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'table_cloth', 'stovefan', 'mat', 'faucet', 'foundation', 'mousepad', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'toy', 'hands_both', 'tray', 'doorjamb', 'towel_rack', 'shaving_cream', 'door', 'sink', 'spoon', 'bathroom_cabinet', 'light', 'teeth'] Task:Wash teeth response: | { I need to rinse my dentures off and put them back in my mouth. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'pot', 'fork', 'tablelamp', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'toaster', 'plate', 'tvstand', 'dish_soap', 'food_noodles', 'bowl', 'wall', 'pasta', 'oven', 'box', 'coffe_maker', 'television', 'ice', 'tray', 'curtain', 'console', 'towel_rack', 'pencil', 'maindoor', 'sink', 'instrument_guitar', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : Wash a plate using the dishwasher in the kitchen., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'walllamp', 'nail_polish', 'cpuscreen', 'bathroom_counter', 'character', 'desk', 'folder', 'keyboard', 'food_cake', 'bedroom', 'alcohol', 'stovefan', 'toaster', 'shower', 'window', 'candle', 'pillow', 'wall', 'wall_clock', 'oven', 'nightstand', 'cutting_board', 'video_game_controller', 'curtain', 'doorjamb', 'towel_rack', 'shoes', 'board_game'] Task:Read book response: | { pick up your book and read it } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'toaster', 'shower', 'wall', 'novel', 'food_food', 'television', 'oven_mitts', 'tray', 'kitchen_counter', 'headset', 'dresser', 'cupboard', 'hair', 'bathtub'] Task:Put groceries in Fridge response: { thoughts : Go to kitchen, open fridge, get groceries, put groceries in fridge, close fridge, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'food_pizza', 'toilet', 'detergent', 'toothbrush', 'orchid', 'wallshelf', 'hanger', 'bedroom', 'bookshelf', 'computer', 'shower', 'window', 'cutting_board', 'food_cheese', 'novel', 'check', 'mouthwash', 'toothbrush_holder', 'wine', 'doorjamb', 'pajamas', 'hairdryer', 'maindoor', 'bathtub', 'home_office', 'door', 'clothes_skirt', 'tooth_paste', 'teeth'] Task:Wash teeth response: | { walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the 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:['bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'faucet', 'shower', 'tooth_paste', 'towel', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'clothes_gloves', 'light_bulb', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'vase', 'soap', 'home_office', 'hands_both'] Task:Wash hands response: { thoughts : I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel., actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>'] } Scene_Objects:['freezer', 'bathroom', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stovefan', 'mat', 'faucet', 'dining_room', 'wall', 'wall_clock', 'oven', 'newspaper', 'light_bulb', 'tray', 'curtain', 'towel_rack', 'laundry_detergent', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'bathtub', 'home_office', 'soap', 'laser_pointer', 'hands_both'] Task:Wash hands response: | { go to the bathroom and wash your 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:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'nightstand', 'feet_both', 'photoframe', 'bed', 'television', 'coin', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'shoes', 'hairbrush', 'door'] Task:Put on your shoes response: { thoughts : Sit on a chair with your shoes in front of you. Put them on one at a time., actions : ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <feet_both>', '[PUTBACK] <shoes> <feet_both>'] } Scene_Objects:['scissors', 'blender', 'tablelamp', 'ground_coffee', 'bathroom', 'toothbrush', 'drawing', 'knife', 'orchid', 'desk', 'keyboard', 'brush', 'shower', 'homework', 'food_jam', 'pillow', 'dining_room', 'bowl', 'wall_clock', 'check', 'television', 'toothbrush_holder', 'tray', 'kettle', 'kitchen_counter', 'maindoor', 'sink', 'clothes_skirt', 'tooth_paste', 'dirt'] Task:Wash teeth response: | { WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR 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:['sheets', 'glue', 'tablelamp', 'mop', 'microwave', 'freezer', 'walllamp', 'needle', 'food_egg', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'stovefan', 'stereo', 'form', 'dining_room', 'wall', 'oven', 'powersocket', 'cutting_board', 'toy', 'keys', 'food_food', 'coffe_maker', 'wine', 'tray', 'kitchen_counter', 'clothes_scarf', 'creditcard'] Task:Put groceries in Fridge response: { thoughts : Open the fridge, and put groceries in the fridge. Close the fridge., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['dry_pasta', 'food_bread', 'microwave', 'freezer', 'ground_coffee', 'dough', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'toaster', 'faucet', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'kitchen_counter', 'cupboard', 'sink'] Task:Make coffee response: | { I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'microphone', 'form', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'television', 'curtain', 'vacuum_cleaner', 'dishrack', 'dresser', 'hairbrush', 'door', 'table', 'soap'] Task:Watch TV response: { thoughts : I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['scissors', 'crayon', 'chair', 'nail_polish', 'cat', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'computer', 'food_bacon', 'clothes_jacket', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'toy', 'doorjamb', 'kettle', 'mouse', 'dresser', 'hairdryer', 'sink', 'bathroom_cabinet', 'light'] Task:Turn on light response: | { Coming home 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:['water_glass', 'microwave', 'freezer', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'button', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'couch', 'wall', 'wall_clock', 'oven', 'keys', 'coffe_maker', 'water', 'tray', 'curtain', 'coffee_pot', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'tooth_paste'] Task:Drink response: { thoughts : I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['dry_pasta', 'pot', 'sponge', 'microwave', 'freezer', 'walllamp', 'food_carrot', 'hanger', 'bathroom_counter', 'floor', 'envelope', 'stovefan', 'mat', 'faucet', 'clothes_hat', 'wall', 'wall_clock', 'oven', 'cutting_board', 'cup', 'food_vegetable', 'food_food', 'coin', 'water', 'tray', 'kitchen_counter', 'shoes', 'door', 'sink', 'bathroom_cabinet'] Task:Cook some food response: | { walk to kicthen , find stove , find cooking pot , find vegetables , find water ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_ice_cream', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'shower', 'mousepad', 'food_peanut_butter', 'food_jam', 'wall', 'bench', 'powersocket', 'toy', 'box', 'standingmirror', 'coffe_maker', 'water', 'doorjamb', 'cards', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'soap', 'board_game'] Task:Take shower response: { thoughts : go to a bathroom, open the shower, let water wash your body, actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>'] } Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'knife', 'cpuscreen', 'hanger', 'floor', 'phone', 'desk', 'keyboard', 'thread', 'computer', 'piano_bench', 'toaster', 'laptop', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'box', 'console', 'mouse', 'dresser', 'maindoor', 'hairdryer', 'board_game'] Task:Write an email response: | { I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'detergent', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'napkin'] Task:Watch TV response: { thoughts : Find the remote, turn on the TV, watch., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['food_pizza', 'microwave', 'dog', 'drawing', 'hanger', 'bedroom', 'desk', 'computer', 'table_cloth', 'stovefan', 'brush', 'faucet', 'mousepad', 'dining_room', 'bowl', 'wall_clock', 'powersocket', 'novel', 'food_food', 'check', 'coffee_filter', 'kitchen_counter', 'cd', 'food_steak', 'napkin', 'home_office', 'light', 'clothes_skirt', 'vase', 'board_game'] Task:Listen to music response: | { Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio. } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.