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:['dry_pasta', 'food_pizza', 'filing_cabinet', 'scissors', 'chair', 'ceilingfan', 'dough', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'coffee_table', 'television', 'coin', 'wooden_spoon', 'curtain', 'maindoor', 'table'] Task:Watch TV response: { thoughts : I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'folder', 'bookshelf', 'remote_control', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'door', 'bathroom_cabinet', 'light', 'table', 'tooth_paste'] Task:Watch TV response: | { I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : I need to rinse my dentures off and put them back in my mouth., actions : ['[WALK] <bathroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <teeth>', '[GRAB] <teeth>', '[WASH] <teeth>', '[PUTOBJBACK] <teeth>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <towel>', '[SWITCHOFF] <light>'] } Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'tvstand', 'faucet', 'stereo', 'window', 'couch', 'form', 'wall', 'powersocket', 'light_bulb', 'razor', 'vacuum_cleaner', 'controller', 'door', 'home_office', 'light', 'dishwasher', 'bathroom_cabinet', 'colander'] Task:Go to toilet response: | { I walk into the bath room and go 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:['blender', 'chair', 'blow_dryer', 'bathroom', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'stamp', 'keyboard', 'computer', 'food_bacon', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'coffe_maker', 'wooden_spoon', 'towel_rack', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'controller', 'light', 'soap'] Task:Vacuum response: { thoughts : Plug in vacuum. Walk around with vacuum, covering all of the floor. Unplug vacuum., actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['fork', 'spectacles', 'chair', 'freezer', 'walllamp', 'knife', 'wallshelf', 'floor', 'alcohol', 'bookmark', 'toaster', 'plate', 'candle', 'wall', 'nightstand', 'novel', 'coffe_maker', 'food_food', 'television', 'water', 'curtain', 'after_shave', 'diary', 'kitchen_counter', 'dresser', 'cupboard', 'bathtub', 'spoon', 'table', 'dishwasher'] Task:Wash dishes with dishwasher response: | { first i will take all the dishes to the dish washer and with the help of dishwasher and water i will clean all the dishes } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', '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: { thoughts : Clean the welcome mat, actions : ['[WALK] <home_office>', '[WALK] <vacuum_cleaner>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>'] } Scene_Objects:['fork', 'crayon', 'microwave', 'chair', 'cloth_napkin', 'freezer', 'walllamp', 'drawing', 'knife', 'floor', 'phone', 'character', 'food_cake', 'mat', 'ceilinglamp', 'plate', 'window', 'mousepad', 'microphone', 'pillow', 'wall', 'nightstand', 'bench', 'cup', 'video_game_controller', 'doorjamb', 'controller', 'door', 'table', 'teeth'] Task:Set up table response: | { Walk to dining room, walk to dining table, arrange chairs, set napkin, set plate, set knife, set fork and glass on 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:['glue', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'microwave', 'chair', 'dog', 'toothbrush', 'knifeblock', 'hanger', 'ceiling', 'bedroom', 'man', 'keyboard', 'ceilinglamp', 'stereo', 'shower', 'couch', 'food_jam', 'pillow', 'pasta', 'powersocket', 'coffe_maker', 'kettle', 'pencil', 'napkin', 'table', 'scrabble', 'creditcard'] Task:Greet guests response: { thoughts : When someone knocks I n the door walk through the hallway and greet them., actions : ['[RUN] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>'] } Scene_Objects:['fork', 'microwave', 'nail_polish', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'bedroom', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'dining_room', 'wall', 'tape', 'cup', 'bed', 'mouthwash', 'after_shave', 'dishrack', 'cupboard', 'door', 'sink', 'table', 'light', 'tooth_paste', 'clothes_shirt'] Task:Turn on light response: | { Turning on lights } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'desk', 'brush', 'mat', 'ceilinglamp', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'cup', 'photoframe', 'coffee_filter', 'food_rice', 'doorjamb', 'towel_rack', 'dresser', 'clothes_dress', 'door', 'light', 'table'] Task:Change clothes response: { thoughts : Switch your clothes., actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[CLOSE] <dresser>'] } Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine'] Task:Wash clothes response: | { Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'toaster', 'closetdrawer', 'couch', 'food_jam', 'pillow', 'wall', 'cup', 'photoframe', 'coffee_table', 'novel', 'television', 'doorjamb', 'shoes', 'comb', 'dresser', 'instrument_violin'] Task:Watch TV response: { thoughts : I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['blender', 'mop', 'walllamp', 'trashcan', 'wallshelf', 'floor', 'ceiling', 'folder', 'bedroom', 'tvstand', 'shower', 'foundation', 'window', 'mousepad', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'television', 'food_donut', 'curtain', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher'] Task:Take shower response: | { Walk to the bathroom and wash with the shower. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'toothbrush', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'food_noodles', 'form', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'keys', 'toothbrush_holder', 'rag', 'doorjamb', 'sink', 'bathroom_cabinet', 'instrument_guitar', 'dishwasher', 'tooth_paste', 'teeth'] Task:Wash teeth response: { thoughts : I walk in to the bathroom. I turn on the faucet. I find the toothbrush and toothpaste. I grab the toothbrush and toothpaste. I rinse off the toothbrush. I add toothpaste to the toothbrush. I put back the toothpaste. I wash my teeth with the toothbrush. I rinse off the toothbrush. I put the toothbrush back. I rinse my mouth out. I turn the faucet off., actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[RINSE] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>', '[PUTOBJBACK] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>', '[RINSE] <toothbrush>', '[PUTOBJBACK] <toothbrush>', '[RINSE] <teeth>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['toilet', 'detergent', 'knifeblock', 'knife', 'bills', 'clothes_underwear', 'shampoo', 'desk', 'piano_bench', 'toaster', 'ceilinglamp', 'window', 'food_peanut_butter', 'clothes_pants', 'clothes_hat', 'basket_for_clothes', 'bed', 'coffe_maker', 'tray', 'doorjamb', 'cards', 'mouse', 'dresser', 'clothes_dress', 'bathtub', 'table', 'dishwasher', 'soap', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: | { I need to get the dirty clothes basket. Walk to bathroom. Put all the clothes in washing machine. Add soap. Turn on machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light'] Task:Greet guests response: { thoughts : Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek., actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>'] } Scene_Objects:['spectacles', 'tablelamp', 'food_salt', 'microwave', 'toilet', 'freezer', 'walllamp', 'blow_dryer', 'bathroom', 'orchid', 'knifeblock', 'drawing', 'desk', 'bedroom', 'bookshelf', 'mat', 'foundation', 'oil', 'pillow', 'dining_room', 'bench', 'oven', 'novel', 'mouthwash', 'television', 'kitchen_counter', 'shoes', 'controller', 'bathtub', 'home_office'] Task:Write an email response: | { Find the computer. Turn on the computer. Open the e-mail program. Create a new message. Write the message. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'food_pizza', 'filing_cabinet', 'toilet', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'folder', 'keyboard', 'faucet', 'iron', 'mousepad', 'pillow', 'dining_room', 'tape', 'cutting_board', 'cup', 'food_food', 'video_game_controller', 'food_rice', 'food_donut', 'rag', 'kettle', 'mouse', 'kitchen_counter', 'controller', 'food_steak', 'sink', 'dishwasher'] Task:Listen to music response: { thoughts : I walk to the living room. I find a radio there and switch it on to listen to music., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['microwave', 'chair', 'detergent', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'alcohol', 'table_cloth', 'toaster', 'tvstand', 'shower', 'faucet', 'mousepad', 'clothes_hat', 'powersocket', 'oven', 'bench', 'box', 'photoframe', 'novel', 'coffe_maker', 'toilet_paper', 'doorjamb', 'mouse', 'cupboard', 'napkin', 'bathroom_cabinet'] Task:Pet cat response: | { I go looking for the cat in the living room where he usually sleeps. Once I find the cat I just pet him for a few minutes. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door', 'teeth', 'printing_paper'] Task:Print out papers response: { thoughts : Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print., actions : ['[WALK] <home_office>', '[WALK] <fax_machine>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[PUTBACK] <printing_paper> <fax_machine>', '[FIND] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <printing_paper>'] } Scene_Objects:['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: | { Take a dish and put it in the dishwasher to be washed } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'sheets', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'orchid', 'needle', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'toaster', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'check', 'food_food', 'television', 'food_onion', 'doorjamb', 'pencil', 'door', 'home_office', 'table', 'light', 'coffee'] Task:Relax on sofa response: { thoughts : Walk to the living room. Walk to the sofa and sit on the sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'door', 'table', 'light'] Task:Watch TV response: | { I walk into my living room, find the remote and sit on my sofa. I look at the remote and switch on the television. I look at the Television. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'jelly', 'drawing', 'floor', 'bedroom', 'table_cloth', 'stovefan', 'mat', 'plate', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'cutting_board', 'bed', 'novel', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'pencil', 'cd', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'vase', 'laser_pointer'] Task:Read book response: { thoughts : I would go lie down in my bed and open the book and start reading., actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['pot', 'filing_cabinet', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'pencil', 'door', 'light', 'table'] Task:Change TV channel response: | { I push my body to be near to the table in front of me, without stand up. I move my right hand to near the TV remote control on the table. I take the TV remote control. I look the number on the remote control. I touch number 3 button. I put back the remote control to the table. I put my body back to the sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'food_butter', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'button', 'table_cloth', 'stovefan', 'mat', 'brush', 'stereo', 'picture', 'mousepad', 'couch', 'clothes_pants', 'food_jam', 'powersocket', 'oven', 'newspaper', 'cards', 'shoes', 'controller', 'clothes_skirt', 'board_game'] Task:Listen to music response: { thoughts : I go into the living room and turn on the radio. Then, I select the station I want, which is usually a preset., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['filing_cabinet', 'bathroom', 'detergent', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'tvstand', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'food_food', 'coffe_maker', 'doorjamb', 'dresser', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'light', 'home_office'] Task:Relax on sofa 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:['pot', 'beer', 'mop', 'chair', 'freezer', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'shower', 'window', 'food_orange', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'spoon', 'table', 'light', 'coffee'] Task:Put groceries in Fridge response: { thoughts : I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['microwave', 'freezer', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'character', 'bookshelf', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'couch', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'lighter', 'dresser', 'sink', 'light'] Task:Change TV channel response: | { Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'microwave', 'dog', 'chair', 'bathroom', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'mat', 'ceilinglamp', 'shower', 'candle', 'wall', 'bed', 'clothes_gloves', 'food_food', 'water', 'food_rice', 'wooden_spoon', 'curtain', 'console', 'dishrack', 'pajamas', 'light', 'clothes_skirt', 'soap', 'dirt'] Task:Take shower response: { thoughts : go to a bathroom, open the shower, let water wash your body, actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>'] } Scene_Objects:['pot', 'tea', 'microwave', 'chair', 'freezer', 'band-aids', 'orchid', 'drawing', 'floor', 'ceiling', 'shampoo', 'alcohol', 'toaster', 'shower', 'mousepad', 'oil', 'couch', 'wall', 'nightstand', 'bench', 'cutting_board', 'tape', 'cup', 'food_donut', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard'] Task:Put groceries in Fridge response: | { Find groceries. Grab groceries. Walk to refrigerator. Open refrigerator door. Place groceries into refrigerator. Close 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:['microwave', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'phone', 'bookshelf', 'table_cloth', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'cup', 'photoframe', 'check', 'television', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'sink', 'light', 'tooth_paste'] Task:Pet dog response: { thoughts : Pet my dog in hall, actions : ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>'] } Scene_Objects:['sheets', 'microwave', 'dog', 'chair', 'walllamp', 'detergent', 'knifeblock', 'needle', 'character', 'bookmark', 'mat', 'ceilinglamp', 'faucet', 'pillow', 'powersocket', 'oven', 'tape', 'cutting_board', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt', 'dirt'] Task:Change TV channel response: | { I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'desk', 'envelope', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'oven_mitts', 'curtain', 'controller', 'home_office', 'table'] Task:Relax on sofa response: { thoughts : I walk into the living room. I cross the room to the couch. I sit down and relax., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['pot', 'filing_cabinet', 'ground_coffee', 'walllamp', 'nail_polish', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'toaster', 'stovefan', 'iron', 'couch', 'form', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'hairdryer', 'bathtub', 'dishwasher', 'dirt'] Task:Make coffee response: | { I walk into the kitchen. I find the coffee maker and open it. I find the coffee filter, grab it and put it into the coffee maker. I find ground coffee, grab it and put it into the coffee maker. I find some water, then I pour it into the coffee maker. I close the coffee maker, I plug it in and I switch 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:['sponge', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'foundation', 'couch', 'microphone', 'wall', 'powersocket', 'oven', 'bed', 'television', 'wooden_spoon', 'doorjamb', 'lighter', 'dresser', 'door', 'table'] Task:Change TV channel response: { thoughts : I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['spectacles', 'scissors', 'food_ice_cream', 'chair', 'orchid', 'drawing', 'bills', 'knifeblock', 'floor', 'character', 'alcohol', 'mat', 'window', 'couch', 'microphone', 'pillow', 'dining_room', 'wall', 'pasta', 'clothes_gloves', 'check', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'table', 'dishwasher', 'colander', 'coffee'] Task:Set up table response: | { walk to entrance hall. find a table. pull table. walk to living rook. push 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:['food_pizza', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mop_bucket', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'mouse', 'pencil', 'controller', 'door', 'table', 'teeth'] Task:Work response: { thoughts : walk to home office ,find computer ,switch on computer and work, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['filing_cabinet', 'crayon', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'floor', 'ceiling', 'stamp', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'shower', 'dish_soap', 'wall', 'nightstand', 'basket_for_clothes', 'keys', 'light_bulb', 'coffe_maker', 'novel', 'television', 'curtain', 'kitchen_counter', 'dishrack', 'cupboard', 'home_office', 'dishwasher', 'scrabble'] Task:Wash dishes with dishwasher response: | { Walk to the kitchen. Open the dishwasher. Put plates into the dishwasher. Put dish soap into the dishwasher. Close the dishwasher. Turn on the dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'walllamp', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'laptop', 'plate', 'stovefan', 'shower', 'dish_soap', 'wall', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher', 'coffee'] Task:Wash dishes with dishwasher response: { thoughts : Put the dishes on dinner table in the dishwasher and wash them, actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[WALK] <table>', '[FIND] <pot>', '[GRAB] <pot>', '[WALK] <dishwasher>', '[PUTBACK] <pot> <dishwasher>', '[CLOSE] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'chair', 'freezer', 'drawing', 'floor', 'ceiling', 'character', 'toaster', 'plate', 'shower', 'floor_lamp', 'window', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'oven', 'toilet_paper', 'curtain', 'doorjamb', 'towel_rack', 'shoes', 'cd', 'laundry_detergent', 'door', 'light', 'table'] Task:Turn on light response: | { walk to wall, find light switch, turn 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:['pot', 'food_bread', 'microwave', 'detergent', 'knifeblock', 'floor', 'ceiling', 'character', 'computer', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'wall', 'cup', 'check', 'mouthwash', 'water', 'wine', 'after_shave', 'curtain', 'food_onion', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'conditioner', 'sink', 'napkin', 'bathroom_cabinet'] Task:Drink response: { thoughts : I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>'] } Scene_Objects:['sponge', 'dry_pasta', 'tablelamp', 'walllamp', 'detergent', 'milk', 'orchid', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'wall', 'box', 'basket_for_clothes', 'keys', 'coffe_maker', 'food_food', 'curtain', 'food_sugar', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'bathtub', 'sink', 'home_office', 'coffee_cup', 'dishwasher', 'clothes_skirt'] Task:Make coffee response: | { 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 } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'stovefan', 'wall_clock', 'powersocket', 'bed', 'food_food', 'television', 'wooden_spoon', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'hairdryer', 'home_office', 'light', 'clothes_skirt', 'bathtub', 'bathroom_cabinet'] Task:Read book response: { thoughts : pick up your book and read it, actions : ['[WALK] <bedroom>', '[WALK] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['food_pizza', 'dog', 'bathroom', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'shower', 'electric_shaver', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'newspaper', 'bed', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light'] Task:Relax on sofa response: | { I walk to the living room and find the sofa. I sit on the sofa and get comfortable. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'tablelamp', 'chair', 'walllamp', 'detergent', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'check', 'television', 'tray', 'wooden_spoon', 'kettle', 'controller', 'food_steak', 'sink'] Task:Relax on sofa response: { thoughts : go to the living room and sit on the couch, ease into the sofa and relax., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['sheets', 'tablelamp', 'bathroom', 'cat', 'knifeblock', 'drawing', 'wallshelf', 'phone', 'ceiling', 'character', 'keyboard', 'toaster', 'mat', 'tvstand', 'electric_shaver', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'photoframe', 'novel', 'food_food', 'curtain', 'doorjamb', 'dishrack', 'pajamas', 'door', 'bathtub', 'spoon', 'table'] Task:Pick up phone response: | { walk to phone, grab phone, pick up phone, put to ear } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'jelly', 'ceilingfan', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'bookshelf', 'computer', 'clothes_jacket', 'piano_bench', 'stovefan', 'toaster', 'tvstand', 'ceilinglamp', 'balanceball', 'stereo', 'brush', 'food_jam', 'clothes_hat', 'nightstand', 'pasta', 'powersocket', 'bench', 'bed', 'oven_mitts', 'tray', 'towel_rack', 'home_office'] Task:Listen to music response: { thoughts : I walk to the radio. I switch on the radio and listen, actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'floor', 'phone', 'ceiling', 'keyboard', 'computer', 'toaster', 'mat', 'tvstand', 'couch', 'dustpan', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'newspaper', 'novel', 'doorjamb', 'mouse', 'pencil', 'cupboard', 'bathtub', 'bathroom_cabinet', 'light'] Task:Turn on light response: | { I walk into the kitchen, I find the light switch, and then i switch on the lights in the kitchen. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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', 'food_salt', 'chair', 'bathroom', 'knifeblock', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'desk', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'homework', 'mousepad', 'form', 'powersocket', 'bench', 'light_bulb', 'check', 'television', 'tray', 'curtain', 'chessboard', 'cupboard', 'home_office'] Task:Pick up phone response: | { I walk to the home office, find where the phone is and lift the reciever. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'wallshelf', 'floor', 'phone', 'character', 'bedroom', 'alcohol', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'foundation', 'food_noodles', 'wall', 'nightstand', 'bench', 'oven', 'food_food', 'television', 'curtain', 'rag', 'pencil', 'door', 'clothes_scarf', 'home_office', 'table'] Task:Play games response: { thoughts : I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours., actions : ['[WALK] <home_office>', '[WALK] <board_game>', '[FIND] <board_game>', '[GRAB] <board_game>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <board_game> <table>'] } Scene_Objects:['food_pizza', 'chair', 'walllamp', 'orchid', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'powersocket', 'oven', 'bench', 'photoframe', 'television', 'curtain', 'food_onion', 'doorjamb', 'towel_rack', 'bathroom_cabinet', 'light', 'home_office'] Task:Watch TV response: | { Walk to living room. Find remote control. Find television. Point remote at television. Press \ on\ button. Watch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', '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: { thoughts : 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., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>'] } Scene_Objects:['tablelamp', 'crayon', 'detergent', 'trashcan', 'orchid', 'wallshelf', 'bathroom_counter', 'ceiling', 'keyboard', 'stovefan', 'tvstand', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'basket_for_clothes', 'television', 'centerpiece', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'clothes_dress', 'laundry_detergent', 'door', 'sink', 'table', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: | { Walk to the kitchen. Find the washing machine. Open the washing machine. Find the basket for clothes. Find the clothes_dress. Grab the clothes_dress. Put the clothes_dress into the washing machine. Find the clothes_shirt. Grab the clothes_shirt. Put the clothes_shirt into the washing machine. Close the washing machine. Switch on the washing machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table', 'clothes_skirt'] Task:Write an email response: { thoughts : enter office, find computer, turn it on,, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TOUCH] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['sheets', 'freezer', 'detergent', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'bookshelf', 'mail', 'toaster', 'ceilinglamp', 'faucet', 'window', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'pencil', 'vacuum_cleaner', 'light'] Task:Turn on light response: | { switching on light in an area } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['jelly', 'trashcan', 'food_carrot', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'keyboard', 'bookshelf', 'mop_bucket', 'tvstand', 'iron', 'oil', 'food_noodles', 'mousepad', 'dustpan', 'towel', 'nightstand', 'cup', 'light_bulb', 'razor', 'food_donut', 'rag', 'shaving_cream', 'towel_rack', 'pencil', 'kitchen_counter', 'bag', 'bathroom_cabinet', 'dishwasher'] Task:Listen to music response: { thoughts : I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'knife', 'knifeblock', 'wallshelf', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'bedroom', 'desk', 'bookshelf', 'toaster', 'stovefan', 'faucet', 'dustpan', 'wall', 'oven', 'food_food', 'food_donut', 'tray', 'after_shave', 'pencil', 'kitchen_counter', 'cupboard', 'food_steak', 'sink'] Task:Cook some food response: | { Walk into kitchen. Open fridge. Take food from fridge. Close fridge. Put food on kitchen counter. Prepare food. Turn on stove. Open kitchen cabinet. Take pot. Close cabinet. Put food in pot. Put pot on stove. Cook food. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_pants', 'form', 'pillow', 'towel', 'wall', 'powersocket', 'bench', 'newspaper', 'television', 'curtain', 'doorjamb', 'mouse', 'hair', 'door', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Watch TV response: { thoughts : SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['food_pizza', 'freezer', 'band-aids', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stamp', 'desk', 'stovefan', 'shoe-shine_kit', 'couch', 'pillow', 'wall', 'bench', 'coffe_maker', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'cupboard', 'door', 'sink', 'bathtub', 'instrument_guitar', 'light', 'home_office', 'clothes_skirt'] Task:Turn on light response: | { I walk to room. I enter room. I find where the lightswitch is. I turn on the lights with the lightswitch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'freezer', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'picture', 'tooth_paste', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'check', 'television', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'bathroom_cabinet', 'board_game'] Task:Put groceries in Fridge response: { thoughts : Walk to the kitchen. Open the fridge, take the groceries and put in it. Closed the fridge,, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'food_salt', 'measuring_cup', 'microwave', 'freezer', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'phone', 'bedroom', 'desk', 'button', 'stereo', 'faucet', 'picture', 'pillow', 'dining_room', 'nightstand', 'wall', 'bed', 'check', 'toothbrush_holder', 'tray', 'dresser', 'sink', 'home_office', 'table', 'dishwasher'] Task:Listen to music response: | { Find the radio; switch on the radio and listen to music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'crayon', 'detergent', 'ceilingfan', 'food_carrot', 'milk', 'drawing', 'knifeblock', 'food_egg', 'floor', 'phone', 'desk', 'bookshelf', 'envelope', 'ceilinglamp', 'window', 'mousepad', 'couch', 'wall', 'food_cheese', 'novel', 'television', 'food_rice', 'after_shave', 'towel_rack', 'kitchen_counter', 'comb', 'table', 'dishwasher', 'creditcard'] Task:Relax on sofa response: { thoughts : I walk to the living room and find the sofa. I sit on the sofa and get comfortable., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['pot', 'tablelamp', 'blender', 'freezer', 'detergent', 'food_carrot', 'food_egg', 'wallshelf', 'floor', 'ceiling', 'food_cake', 'computer', 'ceilinglamp', 'stereo', 'shower', 'foundation', 'faucet', 'oil', 'broom', 'nightstand', 'oven', 'powersocket', 'newspaper', 'coffe_maker', 'television', 'cupboard', 'bathtub', 'napkin', 'bathroom_cabinet', 'light'] Task:Listen to music response: | { Go to the living room. Find the radio. Turn on the radio. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_salt', 'chair', 'band-aids', 'bathroom_counter', 'character', 'desk', 'keyboard', 'purse', 'mat', 'tvstand', 'faucet', 'stereo', 'shower', 'oven', 'cup', 'clothes_gloves', 'novel', 'television', 'oven_mitts', 'wooden_spoon', 'curtain', 'pencil', 'kitchen_counter', 'paper_towel', 'coffee', 'cupboard', 'laundry_detergent', 'dishwasher', 'hands_both'] Task:Go to toilet response: { thoughts : Walking towards Toilet room, And dispose of human waste. Cleaning your hands with tissue paper or water., actions : ['[WALK] <bathroom>', '[WALK] <paper_towel>', '[FIND] <paper_towel>', '[TURNTO] <paper_towel>', '[LOOKAT] <paper_towel>', '[GRAB] <paper_towel>', '[FIND] <hands_both>', '[WIPE] <hands_both>'] } Scene_Objects:['food_pizza', 'tablelamp', 'food_oatmeal', 'chair', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'toaster', 'window', 'clothes_hat', 'dining_room', 'food_cereal', 'wall', 'food_vegetable', 'food_food', 'television', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'pajamas'] Task:Put groceries in Fridge response: | { Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'jelly', 'walllamp', 'bathroom', 'knife', 'wallshelf', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'television', 'toothbrush_holder', 'wooden_spoon', 'kettle', 'shoes', 'cupboard', 'conditioner', 'clothes_dress', 'door', 'napkin', 'light'] Task:Read book response: { thoughts : Pick up a book and open to the last page you were on. Read the book., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <bookmark>', '[READ] <novel>'] } Scene_Objects:['chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'stereo', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light'] Task:Watch TV response: | { go to living room, sit on couch, get remote, switch on tv, watch tv } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'freezer', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'mat', 'shower', 'mousepad', 'wall', 'powersocket', 'oven', 'bench', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'table', 'light', 'coffee'] Task:Browse internet response: { thoughts : I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['spectacles', 'filing_cabinet', 'tablelamp', 'juice', 'food_salt', 'microwave', 'chair', 'freezer', 'detergent', 'trashcan', 'toothbrush', 'floor', 'ceiling', 'bookshelf', 'toaster', 'shower', 'stereo', 'mousepad', 'clothes_pants', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'food_food', 'check', 'food_donut', 'kitchen_counter', 'cupboard', 'door', 'home_office'] Task:Cook some food response: | { Go kitchen and make something for eat } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dog', 'food_egg', 'bathroom_counter', 'folder', 'bedroom', 'computer', 'table_cloth', 'piano_bench', 'stovefan', 'tvstand', 'faucet', 'foundation', 'homework', 'couch', 'nightstand', 'powersocket', 'oven', 'basket_for_clothes', 'cup', 'keys', 'food_food', 'mouthwash', 'after_shave', 'doorjamb', 'shoes', 'controller', 'maindoor', 'bag', 'dirt', 'coffee'] Task:Get ready to leave response: { thoughts : Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave, actions : ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <keys>', '[GRAB] <keys>'] } Scene_Objects:['sheets', 'pot', 'food_bread', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'shower', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'console', 'dresser', 'hair', 'door', 'bathroom_cabinet', 'table', 'light', 'soap'] Task:Relax on sofa response: | { I go to the living room and sit in the sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'sheets', 'filing_cabinet', 'food_salt', 'toilet', 'band-aids', 'walllamp', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'phone', 'computer', 'mop_bucket', 'stovefan', 'tvstand', 'deck_of_cards', 'closetdrawer', 'newspaper', 'coffe_maker', 'doorjamb', 'dresser', 'cupboard', 'door', 'food_steak', 'bag', 'sink', 'table', 'dishwasher', 'bathroom_cabinet'] Task:Put umbrella away response: { thoughts : Place the umbrella in the umbrella bucket point first., actions : ['[WALK] <home_office>', '[WALK] <mop_bucket>'] } Scene_Objects:['pot', 'filing_cabinet', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'faucet', 'couch', 'food_jam', 'pillow', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'table', 'light'] Task:Watch TV response: | { you go into the living room, sit on a chair/sofa, grab remote control, turn on tv, change channels, then watch somethign fun. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'filing_cabinet', 'food_salt', 'walllamp', 'bathroom', 'trashcan', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'tvstand', 'shower', 'faucet', 'towel', 'wall', 'cup', 'keys', 'food_food', 'television', 'water', 'curtain', 'lighter', 'kitchen_counter', 'shoes', 'door', 'table', 'light', 'soap', 'teeth'] 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:['filing_cabinet', 'microwave', 'toilet', 'jelly', 'freezer', 'bathroom', 'drawing', 'orchid', 'character', 'folder', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'food_noodles', 'couch', 'clothes_hat', 'towel', 'nightstand', 'powersocket', 'rag', 'towel_rack', 'pencil', 'kitchen_counter', 'cupboard', 'pajamas', 'bathroom_cabinet', 'table', 'dishwasher', 'soap'] Task:Wash hands response: | { I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['scissors', 'microwave', 'toilet', 'walllamp', 'drawing', 'bills', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'television', 'tray', 'curtain', 'towel_rack', 'pencil', 'kitchen_counter', 'bathtub', 'spoon', 'table'] Task:Watch TV response: { thoughts : Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'food_cake', 'mat', 'faucet', 'mousepad', 'couch', 'wall', 'oven', 'bench', 'toilet_paper', 'television', 'water', 'drinking_glass', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'table'] Task:Drink response: | { I go to the kitchen to get a glass from the cabinet. I turn on the faucet and fill up the glass. I take a drink. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'chair', 'walllamp', '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: { thoughts : I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>'] } Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'foundation', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'door', 'table', 'light', 'coffee'] Task:Watch TV response: | { I walk into the living room and sit on the sofa to watch tv } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'pot', 'tablelamp', 'blender', 'microwave', 'toilet', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'shampoo', 'character', 'desk', 'keyboard', 'computer', 'mousepad', 'wall', 'bench', 'powersocket', 'photoframe', 'television', 'tray', 'mouse', 'dresser', 'controller', 'maindoor', 'home_office', 'clothes_skirt'] Task:Go to toilet response: { thoughts : Walk to bathroom, find toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>'] } Scene_Objects:['sponge', 'filing_cabinet', 'microwave', 'freezer', 'trashcan', 'bathroom_counter', 'ceiling', 'desk', 'stovefan', 'stereo', 'shower', 'mousepad', 'dustpan', 'clothes_pants', 'dining_room', 'powersocket', 'bench', 'bed', 'toilet_paper', 'food_food', 'wine', 'mouse', 'pencil', 'kitchen_counter', 'cd', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Listen to music response: | { walk to living room ,find radio ,switch on radio ,listen to music 4 } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'tvstand', 'faucet', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'food_orange', 'wall', 'powersocket', 'shelf', 'food_food', 'oven_mitts', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'vacuum_cleaner', 'dresser', 'light', 'table'] Task:Turn on light response: { thoughts : approach the light switch, raise hand to the switch, flip the switch, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['tablelamp', 'freezer', 'bathroom', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'bookshelf', 'shower', 'homework', 'wall', 'powersocket', 'box', 'bed', 'coffe_maker', 'television', 'after_shave', 'doorjamb', 'towel_rack', 'mouse', 'cards', 'cupboard', 'home_office', 'light', 'dishwasher'] Task:Turn on light response: | { Walk into living room. Find wall. Find light button. Switch on light button. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : 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., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <novel>'] } Scene_Objects:['freezer', 'drawing', 'orchid', 'knifeblock', 'hanger', 'floor', 'ceiling', 'dvd_player', 'stamp', 'bedroom', 'desk', 'keyboard', 'toaster', 'faucet', 'shower', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'bed', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'home_office', 'table', 'light', 'dishwasher'] Task:Listen to music response: | { walk to living room, look at the DVD player, switch on the dvd player, look at the sofa, sit on the sofa and listen the music } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'television', 'oven_mitts', 'tray', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Watch TV response: { thoughts : Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <chair>', '[SIT] <chair>', '[TURNTO] <television>', '[WATCH] <television>', '[SWITCHOFF] <television>'] } Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'character', 'bookshelf', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'bed', 'novel', 'television', 'tray', 'doorjamb', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'light', 'table', 'laser_pointer'] Task:Pick up phone response: | { My friend is calling and I want to pick up the phone and chat with him for a little while on the couch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'plate', 'faucet', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'powersocket', 'box', 'photoframe', 'novel', 'food_food', 'television', 'food_donut', 'curtain', 'doorjamb', 'bathroom_cabinet'] Task:Read book response: { thoughts : Sit on couch. Grab book. Open book. Read book., actions : ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['water_glass', 'food_bread', 'food_ice_cream', 'crayon', 'microwave', 'chair', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'tvstand', 'window', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'water', 'tray', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'light', 'instrument_violin'] Task:Drink response: | { walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'freezer', 'walllamp', 'bathroom', 'dough', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookmark', 'stovefan', 'brush', 'deck_of_cards', 'faucet', 'window', 'closetdrawer', 'dining_room', 'wall', 'oven', 'cutting_board', 'cup', 'bed', 'coffe_maker', 'food_food', 'tray', 'shaving_cream', 'kitchen_counter', 'chessboard', 'clothes_dress', 'conditioner'] Task:Drink response: { thoughts : Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup, actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[TURNTO] <cup>', '[LOOKAT] <cup>', '[WALK] <cup>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[WALK] <freezer>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>'] } Scene_Objects:['pot', 'blender', 'tea', 'microwave', 'walllamp', 'bathroom', 'knifeblock', 'floor', 'desk', 'tea_bag', 'bookshelf', 'computer', 'bookmark', 'toaster', 'faucet', 'stereo', 'dish_soap', 'dining_room', 'wall', 'nightstand', 'bench', 'coffe_maker', 'razor', 'tray', 'kitchen_counter', 'cupboard', 'controller', 'sink', 'bathtub', 'dishwasher'] Task:Wash dishes with dishwasher response: | { Walk to Kitchen. Look at sink. Grab dish soap. Open dishwasher. Put dish soap in dishwasher. Close dishwasher. Switch on dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink'] Task:Use computer response: { thoughts : Browse the internet, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['toilet', 'freezer', 'food_butter', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'mop_bucket', 'ceilinglamp', 'tvstand', 'iron', 'window', 'mousepad', 'microphone', 'towel', 'dining_room', 'bowl', 'wall', 'powersocket', 'bench', 'cup', 'novel', 'television', 'coin', 'rag', 'doorjamb', 'headset', 'light'] Task:Turn on light response: | { I walk in to the living room. I find the light switch. I turn on the lights. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'chair', 'walllamp', 'cat', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'box', 'photoframe', 'television', 'doorjamb', 'dresser', 'conditioner', 'door', 'coffee'] Task:Watch TV response: { thoughts : We sit all around the television and watch a program., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[WATCH] <television>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'faucet', 'stereo', 'shower', 'candle', 'wall', 'oven', 'cup', 'photoframe', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'light'] Task:Drink response: | { Walk to kitchen, walk to cupboard, open cupboard, grab cup, walk to sink, pour water in cup, drink water. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'freezer', 'walllamp', 'blow_dryer', 'milk', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'food_cake', 'alcohol', 'stovefan', 'homework', 'closetdrawer', 'pillow', 'broom', 'wall', 'oven', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'kitchen_counter', 'shoes', 'sink', 'light', 'table'] Task:Drink response: { thoughts : Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>'] } Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'phone', 'ceiling', 'bookshelf', 'computer', 'table_cloth', 'toaster', 'mat', 'picture', 'wall', 'powersocket', 'bench', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'sink', 'bathroom_cabinet', 'light'] Task:Turn on light response: | { I walk into the dining room and turn on the lights } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'toilet', 'trashcan', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'thread', 'computer', 'piano_bench', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'oven', 'bed', 'novel', 'check', 'television', 'curtain', 'towel_rack', 'dresser', 'vase'] Task:Read book response: { thoughts : Put child in bed, sit down,read book., actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[READ] <novel>'] } Scene_Objects:['glue', 'tablelamp', 'microwave', 'drawing', 'knife', 'bedroom', 'tea_bag', 'computer', 'brush', 'ceilinglamp', 'plate', 'faucet', 'mousepad', 'oil', 'pillow', 'wall', 'powersocket', 'tape', 'photoframe', 'light_bulb', 'novel', 'check', 'television', 'wooden_spoon', 'curtain', 'tray', 'shaving_cream', 'clothes_scarf', 'sink', 'dishwasher'] Task:Browse internet response: | { Go to home office, turn on the computer, open the internet and browse around the internet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light', 'table'] Task:Straighten paintings on wall response: { thoughts : Go up to the painting and tilt it which ever way it is uneven until it looks straight., actions : ['[WALK] <home_office>', '[WALK] <wall>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>'] } Scene_Objects:['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: | { Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'console', 'dresser', 'cupboard', 'home_office', 'table', 'clothes_skirt', 'vase'] Task:Watch TV response: { thoughts : Watch the television, actions : ['[WALK] <home_office>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[SWITCHON] <television>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['tablelamp', 'beer', 'toilet', 'freezer', 'cpuscreen', 'clothes_underwear', 'wallshelf', 'shampoo', 'character', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'clothes_pants', 'dining_room', 'bench', 'powersocket', 'photoframe', 'coffe_maker', 'mouse', 'paper_towel', 'dresser', 'door', 'bathtub', 'bathroom_cabinet', 'light', 'hands_both'] Task:Go to toilet response: | { Walking towards Toilet room, And dispose of human waste. Cleaning your hands with tissue paper or water. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['beer', 'microwave', 'toilet', 'chair', 'freezer', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'window', 'pillow', 'wall', 'powersocket', 'oven', 'bench', 'food_cheese', 'bed', 'photoframe', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'lighter', 'kitchen_counter', 'cupboard', 'home_office'] Task:Eat cheese response: { thoughts : Open fridge. Get cheese. Eat it., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[EAT] <food_cheese>'] } Scene_Objects:['filing_cabinet', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'computer', 'mat', 'shower', 'mousepad', 'couch', 'form', 'pillow', 'wall', 'wall_clock', 'powersocket', 'bench', 'oven', 'tape', 'bed', 'check', 'doorjamb', 'cd', 'hair', 'door', 'table', 'light'] Task:Relax on sofa response: | { I sit on the sofa. I put my legs on the sofa and recline. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'scissors', 'toilet', 'jelly', 'ground_coffee', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'clothes_jacket', 'faucet', 'mousepad', 'wall', 'oven', 'cup', 'photoframe', 'video_game_controller', 'television', 'tray', 'doorjamb', 'mouse', 'conditioner', 'sink', 'bathroom_cabinet', 'home_office', 'vase', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Go to the bathroom and wash hands., actions : ['[RUN] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <sink>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[GRAB] <soap>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'mat', 'tvstand', 'shower', 'shoe-shine_kit', 'window', 'mousepad', 'clothes_socks', 'couch', 'food_noodles', 'pillow', 'wall', 'bed', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'home_office', 'light', 'table'] Task:Turn on light response: | { Walk into the bedroom and walk to the light switch. Flip the switch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'cat', 'trashcan', 'milk', 'hanger', 'bathroom_counter', 'desk', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'tray', 'curtain', 'chessboard', 'shoes', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'table'] Task:Pet cat response: { thoughts : Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <milk>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[TURNTO] <cat>', '[POINTAT] <cat>'] } Scene_Objects:['walllamp', 'trashcan', 'phone', 'ceiling', 'character', 'desk', 'bookmark', 'toaster', 'stovefan', 'shoe-shine_kit', 'shower', 'window', 'wall', 'pasta', 'oven', 'powersocket', 'clothes_gloves', 'novel', 'coffe_maker', 'check', 'coin', 'curtain', 'doorjamb', 'cards', 'towel_rack', 'kitchen_counter', 'chessboard', 'napkin', 'bathroom_cabinet', 'light'] Task:Turn on light response: | { walk to living room ,find electrical outlet , switch on eletrical outlet } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'freezer', 'detergent', 'food_butter', 'trashcan', 'hanger', 'floor', 'phone', 'ceiling', 'bedroom', 'computer', 'button', 'mat', 'laptop', 'plate', 'window', 'wall', 'nightstand', 'bed', 'check', 'curtain', 'doorjamb', 'dresser', 'cupboard', 'controller', 'door', 'light', 'dishwasher', 'laser_pointer', 'shoe_rack'] Task:Pick up phone response: { thoughts : first i will go to home office and switch on the lights and answer the call after then i will put back it and switch off the lights and close the door, actions : ['[RUN] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <phone>', '[GRAB] <phone>', '[PUTOBJBACK] <phone>', '[SWITCHOFF] <light>'] } Scene_Objects:['pot', 'beer', 'mop', 'chair', 'freezer', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'shower', 'window', 'food_orange', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'spoon', 'table', 'light', 'coffee'] Task:Put groceries in Fridge response: | { I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'food_salt', 'microwave', 'walllamp', 'dough', 'hanger', 'ceiling', 'phone', 'character', 'keyboard', 'bookmark', 'toaster', 'mat', 'tvstand', 'stereo', 'window', 'oil', 'food_peanut_butter', 'tape', 'check', 'video_game_controller', 'razor', 'oven_mitts', 'food_rice', 'curtain', 'kitchen_counter', 'hairbrush', 'food_steak', 'bathroom_cabinet', 'home_office'] Task:Listen to music response: { thoughts : I walk into the bedroom. I walk to stereo. I turn on stereo., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['filing_cabinet', 'bathroom', 'detergent', 'food_carrot', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'thread', 'stereo', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'cup', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'hair', 'door', 'sink', 'spoon', 'table', 'light'] Task:Relax on sofa response: | { Walk to the living room, turn to the sofa. Sit on the sofa and relax. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'ground_coffee', 'walllamp', 'knife', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bedroom', 'button', 'stovefan', 'mat', 'shower', 'clothes_socks', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'bed', 'light_bulb', 'check', 'video_game_controller', 'mouthwash', 'food_onion', 'vacuum_cleaner', 'pajamas', 'cupboard', 'hair', 'instrument_guitar'] Task:Go to sleep response: { thoughts : go to bedroom, put pajamas on, lie in bed, sleep, actions : ['[WALK] <bedroom>', '[WALK] <pajamas>', '[FIND] <pajamas>', '[GRAB] <pajamas>', '[PUTON] <pajamas>', '[FIND] <bed>', '[LIE] <bed>'] } Scene_Objects:['pot', 'blender', 'toilet', 'bathroom', 'detergent', 'trashcan', 'drawing', 'knife', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'button', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'bench', 'food_cheese', 'bed', 'television', 'doorjamb', 'mouse', 'pencil', 'door', 'bathtub', 'napkin', 'light', 'table'] Task:Turn on light response: | { Walk to the bedroom and use the button on the wall, next to the door to turn on the lights. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'crayon', 'microwave', 'toilet', 'detergent', 'milk', 'folder', 'bedroom', 'toaster', 'stovefan', 'balanceball', 'stereo', 'window', 'mousepad', 'food_noodles', 'dining_room', 'nightstand', 'box', 'newspaper', 'tray', 'lighter', 'headset', 'controller', 'door', 'maindoor', 'instrument_guitar', 'table', 'soap'] Task:Walk through response: { thoughts : Walk through the entrance hall, actions : ['[WALK] <home_office>', '[WALK] <home_office>'] } Scene_Objects:['chair', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'button', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'faucet', 'mousepad', 'dining_room', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'rag', 'doorjamb', 'kitchen_counter', 'light', 'table'] Task:Change TV channel response: | { walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door'] Task:Watch youtube response: { thoughts : Go to youtube.Com watch videos, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['microwave', 'toilet', 'walllamp', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'food_egg', 'floor', 'ceiling', 'character', 'stovefan', 'tvstand', 'couch', 'candle', 'pillow', 'dining_room', 'wall', 'novel', 'check', 'video_game_controller', 'coffe_maker', 'doorjamb', 'towel_rack', 'cupboard', 'controller', 'door', 'table', 'light'] Task:Read book response: | { Sit on couch. Grab book. Open book. Read book. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'floor', 'character', 'bookshelf', 'computer', 'toaster', 'mat', 'plate', 'window', 'food_noodles', 'food_orange', 'wall', 'oven', 'photoframe', 'keys', 'bed', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'clothes_dress', 'napkin', 'home_office', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['freezer', 'floor', 'ceiling', 'character', 'computer', 'brush', 'mat', 'tvstand', 'iron', 'foundation', 'mousepad', 'couch', 'food_kiwi', 'oven', 'powersocket', 'bench', 'toilet_paper', 'coin', 'food_rice', 'after_shave', 'doorjamb', 'kitchen_counter', 'dresser', 'conditioner', 'bathtub', 'home_office', 'dishwasher', 'soap', 'dirt', 'hands_both'] Task:Wash hands response: | { Wash hands with soap } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'pot', 'food_pizza', 'juice', 'board_game', 'dog', 'food_butter', 'orchid', 'drawing', 'bathroom_counter', 'bookshelf', 'stovefan', 'mat', 'laptop', 'tvstand', 'picture', 'window', 'couch', 'nightstand', 'wall_clock', 'toy', 'clothes_gloves', 'toilet_paper', 'television', 'ice', 'bathroom_cabinet', 'table', 'light', 'vase', 'instrument_violin'] Task:Set up table response: { thoughts : Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room, actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <home_office>', '[DROP] <plate>', '[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <home_office>', '[DROP] <cup>', '[WALK] <dining_room>', '[WALK] <fork>', '[FIND] <fork>', '[GRAB] <fork>', '[WALK] <home_office>', '[DROP] <fork>'] } Scene_Objects:['tablelamp', 'beer', 'microwave', 'chair', 'freezer', 'ground_coffee', 'detergent', 'bills', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'alcohol', 'table_cloth', 'toaster', 'stovefan', 'wall', 'oven', 'bench', 'food_food', 'wooden_spoon', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'home_office', 'light', 'soap', 'scrabble'] Task:Put groceries in Fridge response: | { Walk to kitchen counter, grab a grocery, walk to fridge, open fridge, put the grocery into fridge, and close fridge } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'plate', 'mousepad', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'wine', 'curtain', 'doorjamb', 'light'] Task:Watch TV response: | { Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'cd_player', 'blow_dryer', 'bathroom', 'detergent', 'orchid', 'bills', 'bathroom_counter', 'phone', 'bedroom', 'remote_control', 'thread', 'button', 'mat', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'broom', 'wall_clock', 'powersocket', 'bench', 'box', 'coffe_maker', 'razor', 'towel_rack', 'vacuum_cleaner', 'bathtub', 'dishwasher', 'soap'] Task:Listen to music response: { thoughts : I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton, actions : ['[WALK] <home_office>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[PLUGIN] <cd_player>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['chair', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'shower', 'window', 'homework', 'mousepad', 'pillow', 'powersocket', 'photoframe', 'coffe_maker', 'doorjamb', 'kettle', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'clothes_dress', 'door', 'bag', 'light', 'washing_machine'] Task:Wash clothes response: | { Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'freezer', 'walllamp', 'detergent', 'cat', 'knife', 'drawing', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'phone', 'ceiling', 'character', 'faucet', 'window', 'foundation', 'closetdrawer', 'food_orange', 'dining_room', 'coffe_maker', 'check', 'television', 'food_food', 'tray', 'curtain', 'mouse', 'pajamas', 'door', 'bathroom_cabinet'] 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:['filing_cabinet', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'food_cake', 'button', 'toaster', 'tvstand', 'faucet', 'foundation', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'food_cheese', 'bed', 'toilet_paper', 'coffe_maker', 'doorjamb', 'kettle', 'dresser', 'clothes_dress', 'door', 'table', 'light'] Task:Relax on sofa response: | { I'm tired and want to relax on the sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'novel', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Browse internet response: { thoughts : I walk to the home office. I sit on the chair. I switch on the computer. I look at my monitor. I open the browsing application by click the application using mouse. I type the book that I need to searching for (using keyboard). I found the book that I need. I read the book. I switch on the printer. I print the information that I get. I read carefully the book information that I got. I switch off the printer. I switch of the computer., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[SWITCHOFF] <fax_machine>', '[SWITCHOFF] <computer>'] } Scene_Objects:['tablelamp', 'toilet', 'freezer', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'table_cloth', 'ceilinglamp', 'faucet', 'couch', 'clothes_hat', 'pillow', 'wall', 'oven', 'bed', 'photoframe', 'television', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'bathtub', 'bathroom_cabinet', 'table', 'light'] Task:Pet cat response: | { I would walk into the living room. Then sit on the couch and pet the cat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tea', 'microwave', 'cd_player', 'freezer', 'band-aids', 'bathroom', 'food_carrot', 'orchid', 'music_stand', 'phone', 'bookshelf', 'thread', 'mail', 'stereo', 'homework', 'mousepad', 'closetdrawer', 'clothes_hat', 'form', 'broom', 'newspaper', 'photoframe', 'check', 'food_rice', 'food_donut', 'dresser', 'sink', 'napkin', 'light'] Task:Listen to music response: { thoughts : Walk to the living and turn to the music stand. Switch on the CD player to listen to music., actions : ['[WALK] <home_office>', '[WALK] <music_stand>', '[FIND] <music_stand>', '[TURNTO] <music_stand>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>'] } Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'piano_bench', 'ceilinglamp', 'tvstand', 'stereo', 'couch', 'pillow', 'dining_room', 'wall', 'bed', 'food_donut', 'tray', 'curtain', 'doorjamb', 'coffee_pot', 'dresser', 'pajamas', 'door', 'home_office', 'table', 'light', 'instrument_violin'] Task:Relax on sofa response: | { walk to living room, walk to sofa, sit in sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'freezer', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'envelope', 'computer', 'stereo', 'mousepad', 'closetdrawer', 'oil', 'clothes_pants', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coin', 'rag', 'kettle', 'mouse', 'chessboard', 'dresser', 'light', 'clothes_shirt'] Task:Get dressed response: { thoughts : Find dresser, grab pants, grab shirt, put on pants, put on shirt, actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>'] } Scene_Objects:['filing_cabinet', 'mop', 'cd_player', 'chair', 'knifeblock', 'music_stand', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'envelope', 'food_bacon', 'mop_bucket', 'stovefan', 'ceilinglamp', 'shower', 'nightstand', 'bed', 'photoframe', 'coffe_maker', 'tray', 'curtain', 'lighter', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'bathroom_cabinet', 'light'] Task:Listen to music response: | { Walk to the living and turn to the music stand. Switch on the CD player to listen to music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'walllamp', 'trashcan', 'dough', 'toothbrush', 'floor', 'dvd_player', 'bedroom', 'stovefan', 'mat', 'tvstand', 'window', 'food_noodles', 'dining_room', 'nightstand', 'powersocket', 'oven', 'cutting_board', 'cup', 'light_bulb', 'coffe_maker', 'mouthwash', 'oven_mitts', 'doorjamb', 'diary', 'bag', 'home_office', 'scrabble'] 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:['mop', 'microwave', 'freezer', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'piano_bench', 'shoe-shine_kit', 'shower', 'mousepad', 'couch', 'pillow', 'wall', 'tape', 'food_food', 'doorjamb', 'headset', 'cupboard', 'door', 'home_office', 'table', 'light', 'bathroom_cabinet', 'board_game'] Task:Relax on sofa response: | { I get home from work and walk into the living room. I see the couch and go to sit on it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'toothbrush', 'knife', 'drawing', 'desk', 'bookshelf', 'purse', 'computer', 'table_cloth', 'brush', 'tvstand', 'shoe-shine_kit', 'picture', 'faucet', 'wall', 'bench', 'cutting_board', 'shelf', 'light_bulb', 'razor', 'after_shave', 'doorjamb', 'diary', 'kitchen_counter', 'dishrack', 'dresser', 'home_office', 'table', 'vase', 'dirt'] 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:['pot', 'tablelamp', 'freezer', 'trashcan', 'orchid', 'drawing', 'bills', 'wallshelf', 'cpuscreen', 'knife', 'ceiling', 'character', 'stamp', 'keyboard', 'computer', 'ceilinglamp', 'couch', 'pillow', 'pasta', 'bench', 'oven', 'keys', 'novel', 'mouthwash', 'ice', 'tray', 'towel_rack', 'mouse', 'cupboard', 'bathtub'] Task:Change TV channel response: | { I walk to the living room. I find the TV remote. I change the channel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'pot', 'fork', 'tablelamp', 'food_salt', 'microwave', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'nightstand', 'bed', 'novel', 'television', 'curtain', 'lighter', 'mouse', 'door', 'table', 'dishwasher'] Task:Admire art response: { thoughts : Looking at painting, art, actions : ['[WALK] <home_office>', '[WALK] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>'] } Scene_Objects:['spectacles', 'filing_cabinet', 'microwave', 'chair', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'desk', 'keyboard', 'window', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'bed', 'newspaper', 'photoframe', 'food_rice', 'doorjamb', 'mouse', 'cupboard', 'door', 'hairdryer', 'sink', 'table', 'light', 'soap'] Task:Relax on sofa response: | { go to the living room and sit on the couch, ease into the sofa and relax. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'freezer', 'bathroom', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'light_bulb', 'check', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'clothes_dress', 'door', 'table', 'clothes_shirt'] Task:Pick up phone response: { thoughts : Walk to living room. Go near telephone. take the receiver and then talk to other person on that side., actions : ['[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['sheets', 'sponge', 'food_salt', 'tea', 'bathroom', 'detergent', 'knifeblock', 'wallshelf', 'clothes_underwear', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'toaster', 'faucet', 'window', 'clothes_socks', 'clothes_pants', 'pillow', 'bench', 'basket_for_clothes', 'coffe_maker', 'towel_rack', 'clothes_dress', 'laundry_detergent', 'table', 'clothes_skirt', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: | { I go to the bathroom, take the dirt clothes and put into the washing machine, then put the soap, set the cleaning program and switch on the machine } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'detergent', 'orchid', 'bathroom_counter', 'character', 'keyboard', 'remote_control', 'bookshelf', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'dustpan', 'nightstand', 'bench', 'tape', 'cup', 'bed', 'coffee_table', 'wooden_spoon', 'doorjamb', 'towel_rack', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'hair'] Task:Change TV channel response: { thoughts : walk next to the coffee table. pick up the remote control from the top of the coffee table. Point the remote to the TV. Press the blue arrow on the remote., actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['dog', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'bathtub', 'sink', 'table', 'light', 'dishwasher'] Task:Relax on sofa response: | { walk into living room and go to sofa and turn on tv } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'walllamp', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'bed', 'television', 'curtain', 'pencil', 'dresser', 'clothes_dress', 'conditioner', 'table', 'board_game', 'coffee'] Task:Change TV channel response: { thoughts : Change the channel on the TV in the living room, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>'] } Scene_Objects:['sheets', 'tablelamp', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'stereo', 'faucet', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_food', 'food_donut', 'towel_rack', 'mouse', 'shoes', 'dishrack', 'sink', 'spoon', 'light', 'coffee'] Task:Go to toilet response: | { Walk to bathroom, find toilet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'pencil', 'door', 'light', 'table'] Task:Change TV channel response: { thoughts : I push my body to be near to the table in front of me, without stand up. I move my right hand to near the TV remote control on the table. I take the TV remote control. I look the number on the remote control. I touch number 3 button. I put back the remote control to the table. I put my body back to the sofa, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[GRAB] <remote_control>', '[TOUCH] <remote_control>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['pot', 'mop', 'chair', 'freezer', 'walllamp', 'knifeblock', 'clothes_underwear', 'floor', 'ceiling', 'character', 'stovefan', 'toaster', 'plate', 'ceilinglamp', 'faucet', 'pillow', 'wall', 'pasta', 'oven', 'cup', 'food_cheese', 'food_food', 'tray', 'curtain', 'kitchen_counter', 'sauce_pan', 'cupboard', 'sink', 'spoon', 'coffee'] Task:Cook some food response: | { I pull a sauce pan from the cupboard. I turn the stove on. I take my ingredients from the pantry and fridge. I put the ingredients in the pan and I mix them with a spoon. I cook until the food is finished and transfer my food to a plate. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'mop', 'microwave', 'trashcan', 'food_egg', 'keyboard', 'mop_bucket', 'bookmark', 'mat', 'tvstand', 'mousepad', 'tooth_paste', 'food_noodles', 'food_jam', 'form', 'pillow', 'dining_room', 'food_kiwi', 'toy', 'keys', 'check', 'mouthwash', 'coffee_filter', 'shaving_cream', 'comb', 'maindoor', 'light', 'board_game', 'teeth', 'creditcard'] Task:Pick up phone response: { thoughts : walk to living room, walk to the phone reach for the phone and pick up the phone., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TOUCH] <phone>', '[GRAB] <phone>'] } Scene_Objects:['dog', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'coin', 'curtain', 'doorjamb', 'coffee_pot', 'door', 'table', 'light'] Task:Watch TV response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'pot', 'jelly', 'freezer', 'bathroom', 'trashcan', 'milk', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'alcohol', 'table_cloth', 'faucet', 'shower', 'form', 'powersocket', 'bench', 'bed', 'food_food', 'kitchen_counter', 'headset', 'vacuum_cleaner', 'cupboard', 'door', 'clothes_scarf', 'food_steak', 'soap'] Task:Grab things response: { thoughts : The robot will need some kind of hands or grabbing device to transport objects., actions : ['[WALK] <novel>', '[TURNTO] <novel>', '[GRAB] <novel>'] } Scene_Objects:['beer', 'mop', 'walllamp', 'knife', 'wallshelf', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'stamp', 'keyboard', 'toaster', 'plate', 'shower', 'faucet', 'dish_soap', 'wall', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'check', 'towel_rack', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'conditioner', 'bathtub', 'dishwasher'] Task:Wash dishes with dishwasher response: | { I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet.. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'chair', 'freezer', 'detergent', 'hanger', 'bathroom_counter', 'shampoo', 'ceiling', 'desk', 'bedroom', 'computer', 'stovefan', 'toaster', 'tvstand', 'shower', 'homework', 'closetdrawer', 'bench', 'oven', 'toy', 'cup', 'bed', 'photoframe', 'toilet_paper', 'coffe_maker', 'oven_mitts', 'pencil', 'dresser', 'bag', 'bathroom_cabinet'] Task:Pet cat response: { thoughts : I enter the room where the cat is. I look for the cat. I find the cat. I walk over to the cat. I use my hand to pet the cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['water_glass', 'pot', 'bathroom', 'detergent', 'trashcan', 'keyboard', 'button', 'tvstand', 'stereo', 'food_jam', 'dining_room', 'wall', 'nightstand', 'oven', 'powersocket', 'tape', 'newspaper', 'bed', 'coffe_maker', 'water', 'ice', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'table', 'dishwasher', 'tooth_paste', 'laser_pointer'] Task:Drink response: | { walk to kitchen, look at the water glass, grab that glass, find the water cane, open the water cane tap, drink water } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'milk', 'floor', 'ceiling', 'shampoo', 'purse', 'ceilinglamp', 'mat', 'faucet', 'oil', 'wall', 'pasta', 'tape', 'novel', 'food_food', 'food_donut', 'wooden_spoon', 'mouse', 'kitchen_counter', 'door', 'home_office', 'bathroom_cabinet', 'vase', 'soap', 'instrument_violin', 'creditcard'] Task:Put groceries in Fridge response: { thoughts : I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['spectacles', 'pot', 'chair', 'freezer', 'ground_coffee', 'bathroom', 'food_carrot', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'mail', 'button', 'computer', 'toaster', 'tvstand', 'window', 'wall', 'nightstand', 'cup', 'check', 'television', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'dishwasher'] Task:Put groceries in Fridge response: | { In the kitchen where I left the bags of groceries, I grab cheese from the grocery bag, I walk over to the refrigerator, open it up, neatly put cheese in the fridge, Close the fridge } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'pot', 'food_bread', 'dry_pasta', 'tablelamp', 'filing_cabinet', 'measuring_cup', 'microwave', 'toilet', 'chair', 'walllamp', 'floor', 'bookshelf', 'toaster', 'mat', 'faucet', 'shower', 'closetdrawer', 'bowl', 'dining_room', 'wall', 'newspaper', 'coffe_maker', 'oven_mitts', 'diary', 'kitchen_counter', 'cupboard', 'clothes_dress', 'sink', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : Walk to Kitchen. Take the dishes from the sink. Apply dish washer, scrub and then wash with water., actions : ['[WALK] <sink>', '[FIND] <bowl>', '[GRAB] <bowl>', '[FIND] <dishwasher>', '[SCRUB] <dishwasher>', '[RINSE] <bowl>', '[OPEN] <dishwasher>', '[WASH] <bowl>'] } Scene_Objects:['tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'home_office', 'table', 'light'] Task:Read book response: | { Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'food_cake', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'dishwasher'] Task:Relax on sofa response: { thoughts : Walk to living room. Sit on sofa. Lie down on sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['water_glass', 'tablelamp', 'chair', 'freezer', 'detergent', 'food_carrot', 'knife', 'cpuscreen', 'kitchen_cabinet', 'character', 'bedroom', 'mail', 'stovefan', 'laptop', 'form', 'pillow', 'nightstand', 'bench', 'oven', 'cup', 'keys', 'toothbrush_holder', 'water', 'food_rice', 'curtain', 'controller', 'sink', 'bathtub', 'dishwasher', 'dirt'] Task:Drink response: | { Get a glass of water to drink } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'filing_cabinet', 'food_salt', 'toilet', 'bills', 'hanger', 'bathroom_counter', 'floor', 'character', 'stovefan', 'tvstand', 'faucet', 'mousepad', 'towel', 'dining_room', 'wall', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'water', 'tray', 'curtain', 'doorjamb', 'sink', 'bathroom_cabinet', 'table', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Walk to bathroom. Walk to sink and turn on the water. Grab the soap and wash the hands., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <water>', '[TURNTO] <water>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>'] } Scene_Objects:['sheets', 'tablelamp', 'scissors', 'chair', 'freezer', 'knifeblock', 'clothes_underwear', 'bookshelf', 'mop_bucket', 'stovefan', 'shower', 'window', 'couch', 'dining_room', 'nightstand', 'wall_clock', 'powersocket', 'photoframe', 'keys', 'bed', 'towel_rack', 'cd', 'dresser', 'cupboard', 'sink', 'napkin', 'bathroom_cabinet', 'home_office', 'dishwasher', 'board_game'] Task:Pet cat response: | { Find the cat. Pet the cat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'filing_cabinet', 'tea', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'trashcan', 'toothbrush', 'orchid', 'needle', 'shampoo', 'tea_bag', 'alcohol', 'mat', 'shower', 'mousepad', 'towel', 'wall', 'cup', 'bed', 'light_bulb', 'coffe_maker', 'wooden_spoon', 'shoes', 'home_office', 'vase', 'soap'] Task:Pick up phone response: { thoughts : Walk into the living room, walk over to phone, grab the phone, put it to your ear ., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['pot', 'food_ice_cream', 'microwave', 'freezer', 'walllamp', 'nail_polish', 'bathroom', 'knifeblock', 'floor', 'character', 'desk', 'computer', 'toaster', 'stovefan', 'plate', 'mat', 'dish_soap', 'clothes_hat', 'wall', 'photoframe', 'coffe_maker', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'home_office', 'dishwasher', 'dirt'] Task:Wash dishes with dishwasher response: | { walk into kitchen, find dishwasher, put plates in dishwasher, put soap in dishwasher, turn on dishwasher } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['juice', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'thread', 'computer', 'stovefan', 'mat', 'tvstand', 'toaster', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'television', 'doorjamb', 'laundry_detergent', 'conditioner', 'sink', 'door', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Do homework response: { thoughts : Sit on the couch in the Living room and pick u some papers, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <check>', '[GRAB] <check>', '[DROP] <check>'] } Scene_Objects:['spectacles', 'chair', 'bills', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'bookshelf', 'brush', 'ceilinglamp', 'tvstand', 'stereo', 'stovefan', 'mat', 'mousepad', 'wall', 'powersocket', 'bed', 'television', 'doorjamb', 'dresser', 'clothes_scarf', 'light', 'dishwasher', 'table', 'colander', 'clothes_shirt'] Task:Turn on light response: | { Walk to the Living Room. Switch on 1 light. Walk to dining room. Switch on 1 light. Walk to Entrance hall. Switch on 1 light. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'crayon', 'freezer', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'orchid', 'floor', 'ceiling', 'clothes_jacket', 'brush', 'ceilinglamp', 'mat', 'balanceball', 'clothes_socks', 'couch', 'microphone', 'form', 'wall', 'food_food', 'check', 'oven_mitts', 'wine', 'mouse', 'cupboard', 'food_steak', 'spoon', 'table', 'tooth_paste'] Task:Cook some food response: { thoughts : Go kitchen and make something for eat, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>'] } Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'thread', 'computer', 'alcohol', 'stovefan', 'ceilinglamp', 'couch', 'pillow', 'food_kiwi', 'nightstand', 'powersocket', 'check', 'food_food', 'pencil', 'dishrack', 'home_office', 'dishwasher'] Task:Browse internet response: | { Go find a computer, turn it on, click google, and browse the internet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'sheets', 'pot', 'blender', 'microwave', 'chair', 'nail_polish', 'detergent', 'milk', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'clothes_socks', 'broom', 'wall', 'food_kiwi', 'powersocket', 'cup', 'photoframe', 'keys', 'newspaper', 'curtain', 'lighter', 'pencil', 'pajamas', 'clothes_dress', 'sink', 'table', 'light'] Task:Sit in chair response: { thoughts : I sit in a chair to rest and eat., actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>'] } Scene_Objects:['tablelamp', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'bookshelf', 'remote_control', 'button', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'sink', 'table', 'light'] Task:Change TV channel response: | { I go the living room, look for my tv remote control, take the control and then sit down on the couch and turn on the TV and push the buttons on the remote control to change the channel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'measuring_cup', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'bench', 'cup', 'photoframe', 'novel', 'check', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light', 'table'] Task:Read book response: { thoughts : I go to the book case, I select a book, I go back and sit down, then I read., actions : ['[WALK] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[READ] <novel>'] } Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'door', 'table', 'light', 'dishwasher'] Task:Change TV channel response: | { I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'crayon', 'freezer', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'orchid', 'floor', 'ceiling', 'clothes_jacket', 'brush', 'ceilinglamp', 'mat', 'balanceball', 'clothes_socks', 'couch', 'microphone', 'form', 'wall', 'food_food', 'check', 'oven_mitts', 'wine', 'mouse', 'cupboard', 'food_steak', 'spoon', 'table', 'tooth_paste'] Task:Cook some food response: { thoughts : Go kitchen and make something for eat, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>'] } Scene_Objects:['fork', 'filing_cabinet', 'juice', 'food_ice_cream', 'bathroom', 'orchid', 'floor', 'ceiling', 'phone', 'shampoo', 'bookshelf', 'tvstand', 'stereo', 'shower', 'couch', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'food_food', 'television', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'controller', 'home_office', 'light', 'coffee'] Task:Pick up phone response: | { first i will go to home office and switch on the lights and answer the call after then i will put back it and switch off the lights and close 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:['food_pizza', 'tea', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'phone', 'keyboard', 'food_cake', 'toaster', 'stovefan', 'plate', 'mat', 'dish_soap', 'oil', 'pillow', 'wall', 'cup', 'photoframe', 'coffe_maker', 'curtain', 'centerpiece', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'bathroom_cabinet', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['sheets', 'sponge', 'tablelamp', 'measuring_cup', 'toilet', 'chair', 'jelly', 'freezer', 'ground_coffee', 'trashcan', 'toothbrush', 'drawing', 'clothes_underwear', 'phone', 'desk', 'keyboard', 'computer', 'mousepad', 'television', 'towel_rack', 'cd', 'hairbrush', 'pajamas', 'dresser', 'controller', 'door', 'bathtub', 'sink', 'bathroom_cabinet', 'tooth_paste'] Task:Wash teeth response: | { before going to bed or when wake up earily morning brush teeth } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'milk', 'floor', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'toy', 'basket_for_clothes', 'coffe_maker', 'video_game_controller', 'tray', 'doorjamb', 'kettle', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'table'] Task:Pick up toys response: { thoughts : Bend down and pick up the toys off of the floor., actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['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: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office'] Task:Check email response: { thoughts : Turn on the computer. Wait for it to load. Get online. Go to the email service. Open the email. Read the email., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>'] } Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'dog', 'cpuscreen', 'keyboard', 'ceilinglamp', 'plate', 'laptop', 'faucet', 'window', 'stereo', 'oil', 'food_noodles', 'mousepad', 'dining_room', 'nightstand', 'food_food', 'check', 'wine', 'curtain', 'after_shave', 'comb', 'dresser', 'napkin', 'home_office', 'table', 'bathroom_cabinet', 'light'] Task:Listen to music response: | { I reach out arm. I put hand on radio. I turn on radio. I pick a station. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', '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: { thoughts : Put child in bed, sit down,read book., actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[READ] <novel>'] } Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'trashcan', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'homework', 'pillow', 'wall', 'pasta', 'powersocket', 'photoframe', 'oven_mitts', 'doorjamb', 'kitchen_counter', 'comb', 'door', 'bathtub', 'light', 'dishwasher'] Task:Go to toilet response: | { I walk to bathroom, I open the door of the bathroom, and sit on 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:['measuring_cup', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'phone', 'character', 'stamp', 'tea_bag', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'brush', 'window', 'couch', 'food_orange', 'pillow', 'wall', 'bench', 'tray', 'curtain', 'after_shave', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'soap'] Task:Relax on sofa response: { thoughts : Sitting down and relaxing on the sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'keyboard', 'brush', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'stovefan', 'shoe-shine_kit', 'pillow', 'wall', 'powersocket', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light'] Task:Watch TV response: | { Walk into the living room. Sit on the couch. Turn on TV. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_ice_cream', 'mop', 'nail_polish', 'detergent', 'trashcan', 'food_carrot', 'drawing', 'hanger', 'longboard', 'floor', 'keyboard', 'ceilinglamp', 'plate', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'powersocket', 'bench', 'novel', 'food_food', 'television', 'wine', 'doorjamb', 'conditioner', 'bathroom_cabinet', 'table', 'clothes_skirt'] Task:Relax on sofa response: { thoughts : Walk into the living room. Walk up to the sofa. Sit down on the sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['sheets', 'pot', 'food_pizza', 'tablelamp', 'mop', 'chair', 'freezer', 'walllamp', 'dough', 'drawing', 'knifeblock', 'wallshelf', 'orchid', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'bowl', 'wall', 'oven', 'bench', 'toy', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink'] Task:Cook some food response: | { go to the kitchen and cook some thing 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:['pot', 'food_bread', 'beer', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'toaster', 'mat', 'stovefan', 'shower', 'faucet', 'food_orange', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light'] Task:Make toast response: { thoughts : Place slices of bread in a toaster ,wait for the bread to pop up .Set aside., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[CLOSE] <freezer>', '[FIND] <toaster>', '[PLUGIN] <toaster>', '[PUTBACK] <food_bread> <toaster>', '[SWITCHON] <toaster>'] } Scene_Objects:['walllamp', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'home_office', 'table', 'light'] Task:Watch TV response: | { I walk to the Living Room. I find the remote. I grab the remote and take a seat on the couch. I switch on the TV with the remote and watch the television. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'blender', 'bathroom', 'detergent', 'food_carrot', 'cpuscreen', 'wallshelf', 'phone', 'bedroom', 'desk', 'remote_control', 'envelope', 'computer', 'mail', 'tvstand', 'shower', 'iron', 'mousepad', 'closetdrawer', 'oven', 'powersocket', 'newspaper', 'novel', 'food_food', 'curtain', 'dresser', 'food_steak', 'sink', 'table', 'shoe_rack'] Task:Watch TV response: { thoughts : I walk to the living room and sit on the couch. I grab the TV remote. I press the power button on the TV remote and the TV turns on. I grab the surround sound remote. I press the power button on the surround sound remote and the system turns on., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[PUSH] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>'] } Scene_Objects:['pot', 'microwave', 'jelly', 'bathroom', 'detergent', 'food_butter', 'drawing', 'needle', 'cpuscreen', 'bathroom_counter', 'character', 'stovefan', 'plate', 'window', 'bowl', 'wall', 'bench', 'cup', 'bed', 'coffe_maker', 'check', 'tray', 'towel_rack', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'sink', 'light', 'dishwasher', 'teeth'] Task:Listen to music response: | { Walk into living room. Turn on radio. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'juice', 'chair', 'blow_dryer', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'toaster', 'laptop', 'deck_of_cards', 'faucet', 'food_noodles', 'closetdrawer', 'food_orange', 'wall', 'nightstand', 'clothes_gloves', 'coffe_maker', 'toilet_paper', 'food_food', 'curtain', 'towel_rack', 'console', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'spoon', 'dishwasher'] Task:Make coffee response: { thoughts : Making coffee, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'bookshelf', 'mat', 'mousepad', 'dining_room', 'wall', 'nightstand', 'bench', 'basket_for_clothes', 'bed', 'photoframe', 'coffe_maker', 'food_food', 'wooden_spoon', 'mouse', 'dresser', 'sink', 'dishwasher'] Task:Go to sleep response: | { go t the bedroom and go to sleep } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'beer', 'crayon', 'freezer', 'walllamp', 'bathroom', 'detergent', 'wallshelf', 'floor', 'ceiling', 'purse', 'computer', 'mat', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'dining_room', 'wall', 'photoframe', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Wipe down baseboards please response: { thoughts : Use a rag to get all the dust off the baseboards please., actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <wall>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'table', 'light'] Task:Watch TV response: | { Go to the living room. Find the remote. Pick up the remote. Find the sofa. Sit on the sofa. Look at the television. Aim the remote at the television. Press the power button. Flip the channels. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'walllamp', 'knife', 'knifeblock', 'cpuscreen', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'tea_bag', 'toaster', 'stovefan', 'plate', 'faucet', 'deck_of_cards', 'tvstand', 'bowl', 'wall', 'oven', 'cup', 'coffe_maker', 'drinking_glass', 'food_donut', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'dishwasher'] Task:Unload dishwasher response: { thoughts : Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[PUTBACK] <drinking_glass> <cupboard>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <fork> <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTIN] <knife> <kitchen_cabinet>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTIN] <spoon> <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>'] } Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'shaving_cream', 'towel_rack', 'door', 'table', 'light'] Task:Watch TV response: | { I enter the living room and sit on the couch. I grab the remote and turn on the TV. } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.