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:['microwave', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'toaster', 'tvstand', 'window', 'oil', 'couch', 'wall', 'nightstand', 'newspaper', 'coffe_maker', 'television', 'coffee_filter', 'water', 'food_donut', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'dirt'] Task:Make coffee response: { thoughts : Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['pot', 'filing_cabinet', 'freezer', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'man', 'bookshelf', 'clothes_jacket', 'piano_bench', 'toaster', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'coffe_maker', 'doorjamb', 'cupboard', 'door', 'sink', 'home_office', 'table', 'light'] Task:Have conversation with boyfriend response: | { Sit on sofa, talk } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'pot', 'tablelamp', 'microwave', 'hanger', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'mousepad', 'couch', 'candle', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'drinking_glass', 'wooden_spoon', 'curtain', 'tray', 'doorjamb', 'kitchen_counter', 'paper_towel', 'cupboard', 'sink', 'table', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : wipe loose dirt, place in the dishwasher, turn on the dishwasher, actions : ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[WIPE] <drinking_glass>', '[RINSE] <drinking_glass>', '[PUTBACK] <drinking_glass> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['pot', 'mop', 'microwave', 'walllamp', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'iron', 'window', 'laptop', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'check', 'tray', 'rag', 'towel_rack', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet'] Task:Wash dishes response: | { Run hot water into tub of dirty dishes in the sink. Add liquid soap. Scrub dishes with wash rag. Rinse and place on drying rack. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['scissors', 'chair', 'bathroom', 'drawing', 'wallshelf', 'cpuscreen', 'character', 'desk', 'envelope', 'computer', 'shower', 'faucet', 'electric_shaver', 'dustpan', 'dining_room', 'wall', 'bench', 'tape', 'photoframe', 'check', 'doorjamb', 'centerpiece', 'mouse', 'hairbrush', 'bathroom_cabinet', 'table', 'home_office', 'light', 'instrument_guitar', 'creditcard'] Task:Receive credit card response: { thoughts : hear the dooble, go to door, take de envelope, open it with a scissor, take the creditcard, actions : ['[WALK] <home_office>', '[WALK] <envelope>', '[FIND] <envelope>', '[GRAB] <envelope>', '[WALK] <home_office>', '[WALK] <scissors>', '[FIND] <scissors>', '[OPEN] <envelope>', '[FIND] <creditcard>', '[GRAB] <creditcard>'] } Scene_Objects:['microwave', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'mousepad', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'curtain', 'mouse', 'door', 'hairdryer', 'sink', 'food_steak', 'light', 'dishwasher', 'spoon', 'table', 'board_game'] Task:Write school paper response: | { Writing and drafting a paper for class work } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'tablelamp', 'microwave', 'freezer', 'drawing', 'phone', 'bookshelf', 'toaster', 'stovefan', 'tvstand', 'mousepad', 'couch', 'clothes_hat', 'food_orange', 'wall', 'photoframe', 'clothes_gloves', 'bed', 'check', 'television', 'food_rice', 'tray', 'doorjamb', 'dresser', 'hairdryer', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'door'] Task:Listen to music response: { thoughts : I go to my bedroom, and then I switch on the radio, actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['scissors', 'ground_coffee', 'trashcan', 'woman', 'knife', 'cpuscreen', 'phone', 'man', 'bookshelf', 'computer', 'stovefan', 'mat', 'brush', 'shower', 'deck_of_cards', 'pillow', 'powersocket', 'bench', 'bed', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'mouse', 'kitchen_counter', 'chessboard', 'door', 'bathtub', 'bathroom_cabinet', 'coffee'] Task:Greet people response: | { Say HI to those that come in. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'powersocket', 'clothes_gloves', 'television', 'razor', 'curtain', 'doorjamb', 'console', 'mouse', 'door', 'bag', 'table', 'dishwasher'] Task:Change TV channel response: { thoughts : I walk in living room. I find TV remote. I grab TV remote. I sit on sofa. I switch on TV. I switch channel., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[PUSH] <remote_control>'] } Scene_Objects:['toilet', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'dresser', 'door', 'home_office', 'table', 'light'] Task:Watch TV response: | { Sit on the couch nd watch t.V } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine'] Task:Wash clothes response: { thoughts : Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine., actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['toilet', 'chair', 'bathroom', 'detergent', 'cat', 'trashcan', 'woman', 'drawing', 'character', 'bedroom', 'man', 'keyboard', 'bookshelf', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'clothes_hat', 'dining_room', 'wall', 'child', 'toy', 'tray', 'curtain', 'mouse', 'cupboard', 'door', 'spoon', 'home_office', 'table'] Task:Greet guests response: | { Greet guests when they knock on the door and invite them to enter my home } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'food_salt', 'microwave', 'ceilingfan', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'keyboard', 'toaster', 'mat', 'balanceball', 'stereo', 'window', 'microphone', 'bench', 'basket_for_clothes', 'clothes_gloves', 'check', 'oven_mitts', 'kettle', 'dresser', 'cupboard', 'maindoor', 'napkin', 'light', 'clothes_skirt', 'washing_machine', 'shoe_rack'] Task:Wash clothes response: { thoughts : Wash the clothes in the washing machine, actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'table_cloth', 'faucet', 'homework', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'bed', 'doorjamb', 'cards', 'cupboard', 'door', 'sink', 'spoon', 'table', 'light'] Task:Arrange furniture response: | { Move furniture where you want it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cutting_board', 'cup', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'controller', 'door', 'light', 'table'] Task:Work response: { thoughts : Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[SWITCHOFF] <computer>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'jelly', 'chair', 'walllamp', 'detergent', 'trashcan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'keyboard', 'stovefan', 'mat', 'ceilinglamp', 'food_orange', 'wall', 'bench', 'oven', 'food_food', 'oven_mitts', 'doorjamb', 'dresser', 'cupboard', 'home_office', 'table', 'bathroom_cabinet'] Task:Play games response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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_bread', 'microwave', 'chair', 'band-aids', 'woman', 'needle', 'longboard', 'man', 'keyboard', 'envelope', 'toaster', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'nightstand', 'box', 'light_bulb', 'coffe_maker', 'curtain', 'towel_rack', 'shoes', 'dresser', 'hairbrush', 'door', 'vase', 'instrument_violin', 'creditcard'] 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:['pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'food_butter', 'knifeblock', 'floor', 'ceiling', 'character', 'desk', 'food_cake', 'computer', 'bookmark', 'toaster', 'stovefan', 'mat', 'faucet', 'food_kiwi', 'wall', 'oven', 'powersocket', 'food_vegetable', 'bed', 'food_food', 'oven_mitts', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard'] Task:Cook some food response: | { I prepare meals and cook them on the stove. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'chair', 'walllamp', 'blow_dryer', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'ceiling', 'thread', 'ceilinglamp', 'laptop', 'faucet', 'mousepad', 'couch', 'candle', 'food_jam', 'pillow', 'wall', 'nightstand', 'tape', 'television', 'tray', 'after_shave', 'food_onion', 'shoes', 'cupboard'] Task:Relax on sofa response: { thoughts : I walk to the living room. I sit in the sofa and I relax., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['blender', 'juice', 'cd_player', 'chair', 'freezer', 'detergent', 'trashcan', 'knife', 'knifeblock', 'drawing', 'floor', 'ceiling', 'bedroom', 'keyboard', 'remote_control', 'computer', 'button', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'nightstand', 'after_shave', 'door', 'bathtub', 'home_office', 'table', 'clothes_skirt', 'instrument_guitar', 'light'] Task:Listen to music response: | { Walk to CD player and turn it on then go and sit in a chair and turn the remote control on and then listen to some 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', 'filing_cabinet', 'tablelamp', 'mop', 'walllamp', 'detergent', 'food_carrot', 'toothbrush', 'knifeblock', 'orchid', 'clothes_underwear', 'hanger', 'phone', 'stovefan', 'shower', 'homework', 'couch', 'food_jam', 'microphone', 'bowl', 'photoframe', 'check', 'curtain', 'console', 'mouse', 'pencil', 'dresser', 'sink', 'soap', 'creditcard'] Task:Pet dog response: { thoughts : Pet my dog in hall, actions : ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>'] } Scene_Objects:['sheets', 'tablelamp', 'toilet', 'detergent', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'bedroom', 'folder', 'mat', 'shower', 'food_noodles', 'couch', 'pillow', 'wall', 'oven', 'food_food', 'coffe_maker', 'doorjamb', 'door', 'bathtub', 'home_office', 'table', 'light', 'clothes_skirt', 'shoe_rack'] Task:Relax on sofa response: | { I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_ice_cream', 'toilet', 'bathroom', 'detergent', 'ceilingfan', 'food_butter', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'pillow', 'wall', 'food_food', 'television', 'tray', 'curtain', 'after_shave', 'cupboard', 'table', 'laser_pointer'] Task:Watch TV response: { thoughts : TURN ON TV, SIT ON COUCH ACROSS THE ROOM, USE REMOTE TO LOOK FOR SHOW TO WATCH, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'knifeblock', 'food_egg', 'kitchen_cabinet', 'floor', 'phone', 'ceiling', 'food_chicken', 'stovefan', 'toaster', 'faucet', 'form', 'wall', 'powersocket', 'oven', 'bench', 'coffe_maker', 'tray', 'doorjamb', 'lighter', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'food_steak', 'sink', 'light'] Task:Cook some food response: | { I walk into the kitchen and walk over the cabinent. I pull out a pan and walk to the stove. I put the pan on the stove and walk over to the fridge. I pull out out meat from the fridge and walk back over the stove. Then I put the meat in the pan. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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:['sheets', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'dvd_player', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light'] Task:Watch TV response: | { I go in my living room, find the remote, sit on my couch, turn on the TV and watch TV. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_ice_cream', 'chair', 'nail_polish', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'ceilinglamp', 'balanceball', 'shower', 'mousepad', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'toothbrush_holder', 'doorjamb', 'mouse', 'light', 'vase'] Task:Browse internet response: { thoughts : Walk to the Home Office. Find the computer. Turn on the computer., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['chair', 'bathroom', 'orchid', 'wallshelf', 'ceiling', 'phone', 'stamp', 'bookshelf', 'mail', 'computer', 'tvstand', 'shower', 'couch', 'pillow', 'oven', 'powersocket', 'box', 'bed', 'clothes_gloves', 'photoframe', 'check', 'curtain', 'pencil', 'dresser', 'cupboard', 'door', 'sink', 'bathtub', 'home_office', 'dishwasher'] Task:Pet cat response: | { find a cat, touch it gently } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'beer', 'measuring_cup', 'toilet', 'freezer', 'food_carrot', 'drawing', 'food_egg', 'hanger', 'floor', 'ceiling', 'bedroom', 'mat', 'laptop', 'shower', 'tvstand', 'closetdrawer', 'food_orange', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'drinking_glass', 'wine', 'doorjamb', 'door', 'light'] Task:Drink response: { thoughts : Robot Drinks the water, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>', '[PUTOBJBACK] <drinking_glass>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'towel', 'dining_room', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'food_food', 'curtain', 'kitchen_counter', 'cupboard', 'food_steak', 'sink'] Task:Wash dishes by hand response: | { Walk to Kitchen, find sink, find dishes and dish soap. Put soap on plate. open faucet, rinse dishes close faucet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'freezer', 'knifeblock', 'drawing', 'wallshelf', 'ceiling', 'phone', 'desk', 'keyboard', 'face', 'toaster', 'laptop', 'tvstand', 'shower', 'stereo', 'homework', 'oil', 'towel', 'oven', 'basket_for_clothes', 'tray', 'towel_rack', 'hair', 'cupboard', 'door', 'bathtub', 'clothes_shirt'] Task:Rain welcome response: { thoughts : The robot would greet me and then hand me a towel. It would make an appropriate quip about the weather while I dried off. It would receive the wet towel when I was done., actions : ['[WALK] <bedroom>', '[WALK] <towel>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <hair>', '[WIPE] <hair>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'picture', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'light'] Task:Watch TV response: | { Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'blender', 'chair', 'bathroom', 'detergent', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'mat', 'tvstand', 'clothes_pants', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'novel', 'check', 'keys', 'tray', 'after_shave', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'tooth_paste'] Task:Read response: { thoughts : I like to read books in my bedroom., actions : ['[WALK] <bedroom>', '[WALK] <desk>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <bed>', '[LIE] <bed>', '[READ] <novel>'] } Scene_Objects:['blow_dryer', 'walllamp', 'bathroom_counter', 'phone', 'desk', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'button', 'clothes_jacket', 'stovefan', 'toaster', 'window', 'couch', 'bench', 'oven', 'cup', 'coffe_maker', 'television', 'ice', 'towel_rack', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'bathtub', 'napkin', 'bathroom_cabinet', 'colander'] Task:Change TV channel response: | { Take the Tv Remote Control in the Living Room table And Press the Channel Change Button 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:['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: { thoughts : Walk to the bathroom and wash with the shower., actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[WASH] <shower>'] } Scene_Objects:['pot', 'microwave', 'jelly', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'toaster', 'mat', 'faucet', 'window', 'couch', 'bowl', 'wall', 'oven', 'cup', 'food_food', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'instrument_violin', 'hands_both'] Task:Wash hands response: | { Washing hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'ground_coffee', 'walllamp', 'detergent', 'knifeblock', 'longboard', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'faucet', 'candle', 'wall', 'box', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'hair', 'maindoor', 'sink', 'napkin', 'dishwasher', 'tooth_paste'] Task:Make coffee response: { thoughts : I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['filing_cabinet', 'trashcan', 'desk', 'keyboard', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'stereo', 'window', 'couch', 'dining_room', 'nightstand', 'wall', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'hairdryer', 'bathtub', 'bathroom_cabinet', 'home_office', 'dishwasher', 'table'] Task:Pick up phone response: | { walk into room, grab phone } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'food_pizza', 'microwave', 'dog', 'band-aids', 'orchid', 'wallshelf', 'floor', 'desk', 'mat', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'tape', 'cutting_board', 'bed', 'standingmirror', 'television', 'curtain', 'doorjamb', 'conditioner', 'sink', 'home_office', 'table', 'light', 'bathroom_cabinet', 'soap'] Task:Relax on sofa response: { thoughts : I walk to the living room. I see the couch. I sit down on the couch, then lie down and put my feet up., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['sheets', 'filing_cabinet', 'freezer', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'orchid', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'tvstand', 'faucet', 'wall', 'nightstand', 'curtain', 'doorjamb', 'chessboard', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet', 'home_office', 'dishwasher', 'light', 'soap', 'hands_both'] Task:Wash hands response: | { Wash Hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'table'] Task:Browse internet response: { thoughts : I go to my desk. I turn on the computer. I open a web page and look at it., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['toilet', 'band-aids', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'bathroom_counter', 'phone', 'bookshelf', 'computer', 'stovefan', 'mat', 'plate', 'ceilinglamp', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'bench', 'powersocket', 'oven', 'cutting_board', 'curtain', 'mouse', 'table', 'dishwasher', 'light'] Task:Set up table response: | { Walk to the kitchen. Open the kitchen cabinet. Grab the plate and put it on the 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:['chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'picture', 'window', 'mousepad', 'oil', 'clothes_hat', 'wall', 'keys', 'food_food', 'coin', 'food_onion', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'table'] Task:Write an email response: { thoughts : I walk into the home office and walk to the desk. I pull out the chair and sit down. I turn on the computer. After the computer is turned on I click on my email program. When the program is loaded I write an email., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['sponge', 'microwave', 'toilet', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'plate', 'faucet', 'drying_rack', 'dish_soap', 'couch', 'dining_room', 'wall', 'oven', 'newspaper', 'photoframe', 'check', 'toilet_paper', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'table'] Task:Wash dishes by hand response: | { I walk in to the Kitchen. I find a plate, a sponge, and the dish soap. I find the faucet. I turn the faucet on. I pour water on the sponge and plate. I add dish soap to the sponge. I put the dish soap back. I scrub the plate. I rinse the plate. I place the plate on the drying rack. I rinse the sponge. I turn the faucet off. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'glue', 'microwave', 'bathroom', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'purse', 'food_bacon', 'ceilinglamp', 'plate', 'laptop', 'deck_of_cards', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'spoon', 'home_office', 'table', 'teeth'] Task:Relax on sofa response: { thoughts : I walk to the sofa, and lie down on the sofa., actions : ['[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['fork', 'pot', 'tablelamp', 'microwave', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'phone', 'bookshelf', 'computer', 'stovefan', 'mat', 'plate', 'ceilinglamp', 'deck_of_cards', 'faucet', 'couch', 'wall', 'nightstand', 'bench', 'oven', 'box', 'cup', 'check', 'razor', 'food_onion', 'dresser', 'door', 'table'] Task:Set up table response: | { Walk into kitchen. Grab plates and forks. Walk into dining room. Put plates and forks 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:['ceilingfan', 'toothbrush', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'longboard', 'mop_bucket', 'mat', 'tvstand', 'faucet', 'couch', 'clothes_pants', 'towel', 'wall', 'basket_for_clothes', 'photoframe', 'light_bulb', 'wooden_spoon', 'after_shave', 'coffee', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'laser_pointer', 'hands_both', 'shoe_rack'] Task:Wash hands response: { thoughts : Turn faucet clockwise to turn on water. Place hands under stream of water, pick up soap, rub hands with soap. Put soap back down. Rub hands together with soap on them. Rinse hands under water from faucet. Turn faucet counterclockwise to turn water off. Dry hands by rubbing them on a towel., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[WASH] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'door', 'light', 'table'] Task:Watch TV response: | { Turn on the TV, sit on the couch, find a show, and watch 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:['sponge', 'microwave', 'chair', 'jelly', 'knifeblock', 'floor', 'ceiling', 'character', 'alcohol', 'toaster', 'plate', 'faucet', 'drying_rack', 'window', 'tvstand', 'dish_soap', 'closetdrawer', 'couch', 'towel', 'pillow', 'food_kiwi', 'wall', 'toy', 'novel', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'shoe_rack'] Task:Do dishes response: { thoughts : Wash dirty dishes, dry them and then put them away, actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <drying_rack>', '[PUTBACK] <plate> <drying_rack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <drying_rack>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['food_pizza', 'tablelamp', 'chair', 'freezer', 'detergent', 'bathroom_counter', 'desk', 'bedroom', 'keyboard', 'button', 'stovefan', 'ceilinglamp', 'stereo', 'shower', 'window', 'clothes_socks', 'dining_room', 'nightstand', 'wall', 'bench', 'oven', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'dresser', 'napkin', 'bathroom_cabinet', 'soap'] Task:Listen to music response: | { Walk into living room, look for radio, grab on 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:['dog', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'bathtub', 'sink', 'table', 'light', 'dishwasher'] Task:Relax on sofa response: { thoughts : walk into living room and go to sofa and turn on tv, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[DROP] <remote_control>'] } Scene_Objects:['pot', 'microwave', 'ground_coffee', 'walllamp', 'bathroom', 'knifeblock', 'drawing', 'floor', 'ceiling', 'character', 'bookshelf', 'toaster', 'stovefan', 'faucet', 'wall', 'oven', 'tape', 'cup', 'coffe_maker', 'food_food', 'toilet_paper', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'table', 'dishwasher', 'shoe_rack'] Task:Make coffee response: | { I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'chair', 'food_butter', 'food_carrot', 'drawing', 'orchid', 'knifeblock', 'knife', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'toaster', 'mat', 'food_noodles', 'couch', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light', 'dirt'] Task:Relax on sofa response: { thoughts : Relax on the sofa in the living room., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['sheets', 'filing_cabinet', 'food_pizza', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'bathroom_counter', 'shampoo', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'faucet', 'couch', 'dining_room', 'cup', 'bed', 'tray', 'curtain', 'wooden_spoon', 'pencil', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'table'] Task:Pick up phone response: | { I walk to the home office. I find the telephone. I pick up the telephone handset. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'scissors', 'jelly', 'walllamp', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'food_jam', 'wall', 'novel', 'television', 'curtain', 'doorjamb', 'comb', 'clothes_dress', 'sink', 'home_office', 'table'] Task:Change TV channel response: { thoughts : first i will go to living room and then take the remote and swtitch on television after that il change the channel, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'faucet', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'cupboard', 'door', 'home_office', 'light', 'table', 'bathroom_cabinet'] Task:Watch TV response: | { Walk to living room. Find remote control. Look at remote control. Push power on button. Find sofa. Sit down on sofa. Watch Television. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'button', 'food_bacon', 'stovefan', 'mat', 'shower', 'faucet', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'keys', 'tray', 'doorjamb', 'lighter', 'sink', 'bathtub', 'bathroom_cabinet', 'soap'] Task:Take shower response: { thoughts : I want to take a shower so I go to the bathroom, turn on the shower, get the soap, lather and wash, then I rinse, turn off shower, get a towel and dry off., actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[RINSE] <shower>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>'] } Scene_Objects:['walllamp', 'cat', 'trashcan', 'drawing', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'mail', 'toaster', 'mat', 'tvstand', 'couch', 'pillow', 'broom', 'wall', 'nightstand', 'powersocket', 'television', 'food_donut', 'doorjamb', 'door', 'bathroom_cabinet', 'light', 'table', 'dirt'] Task:Pet cat response: | { My cat looks like it wants attention, so I will go pet it on the couch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_bread', 'juice', 'toilet', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'food_peanut_butter', 'food_jam', 'bowl', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'light', 'dishwasher', 'table'] Task:Grab some juice response: { thoughts : I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <juice>', '[GRAB] <juice>', '[POUR] <juice> <cup>', '[PUTOBJBACK] <juice>', '[CLOSE] <freezer>', '[FIND] <table>', '[PUTBACK] <cup> <table>'] } Scene_Objects:['fork', 'food_bread', 'tablelamp', 'crayon', 'tea', 'toilet', 'walllamp', 'knife', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'couch', 'wall', 'oven', 'novel', 'coffe_maker', 'drinking_glass', 'tray', 'doorjamb', 'kettle', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'dishwasher', 'clothes_shirt'] Task:Wash dishes with dishwasher response: | { Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into 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', 'tablelamp', 'walllamp', 'woman', 'drawing', 'phone', 'desk', 'man', 'toaster', 'laptop', 'mat', 'shower', 'electric_shaver', 'oil', 'form', 'pillow', 'dining_room', 'oven', 'shelf', 'bed', 'standingmirror', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'tooth_paste', 'scrabble'] Task:Greet guests response: { 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:['microwave', 'toilet', 'chair', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'drawing', 'bathroom_counter', 'bedroom', 'keyboard', 'button', 'toaster', 'tvstand', 'food_noodles', 'pillow', 'check', 'television', 'oven_mitts', 'wine', 'curtain', 'rag', 'doorjamb', 'kettle', 'mouse', 'pencil', 'hairbrush', 'food_steak', 'home_office', 'dishwasher'] Task:Pet cat response: | { Find the cat; pet the cat by touching 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:['food_bread', 'chair', 'bathroom', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'character', 'computer', 'mail', 'table_cloth', 'toaster', 'foundation', 'window', 'mousepad', 'bench', 'shelf', 'photoframe', 'bed', 'coffe_maker', 'cards', 'chessboard', 'controller', 'door', 'maindoor', 'bathtub', 'light', 'vase', 'laser_pointer'] Task:Pick up phone response: { thoughts : walk into living room, look at the phone when it ringing, grab the phone or pickup the phone, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>'] } Scene_Objects:['food_pizza', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'plate', 'faucet', 'shower', 'couch', 'pillow', 'dining_room', 'wall', 'pasta', 'newspaper', 'novel', 'check', 'toilet_paper', 'food_food', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'controller', 'door', 'table', 'light', 'dishwasher'] Task:Relax on sofa response: | { I walk into the living room. I cross the room to the couch. I sit down 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:['pot', 'filing_cabinet', 'chair', 'freezer', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'button', 'mat', 'shoe-shine_kit', 'pillow', 'wall', 'oven', 'tape', 'bed', 'photoframe', 'novel', 'food_food', 'curtain', 'coffee_pot', 'mouse', 'pencil', 'conditioner', 'sink', 'coffee'] Task:Read to child response: { thoughts : Read a book out loud to a child, actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>'] } Scene_Objects:['tablelamp', 'juice', 'toilet', 'chair', 'freezer', 'dough', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'mat', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'curtain', 'centerpiece', 'doorjamb', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bag', 'dishwasher'] Task:Put groceries in Fridge response: | { walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'phone', 'button', 'mat', 'stereo', 'window', 'homework', 'foundation', 'couch', 'pillow', 'wall', 'toy', 'cup', 'light_bulb', 'television', 'razor', 'curtain', 'after_shave', 'doorjamb', 'rag', 'coffee_pot', 'laundry_detergent', 'bathtub', 'table'] Task:Arrange furniture response: { thoughts : Move furniture where you want it., actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[PUSH] <coffee_table>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <filing_cabinet>', '[PUSH] <filing_cabinet>'] } Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'tvstand', 'faucet', 'plate', 'mousepad', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'tape', 'cup', 'doorjamb', 'sink', 'light', 'table'] Task:Pick up phone response: | { walk over and pick up the phone } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'detergent', 'drawing', 'orchid', 'floor', 'character', 'keyboard', 'toaster', 'mat', 'faucet', 'stereo', 'couch', 'towel', 'wall', 'wall_clock', 'nightstand', 'cup', 'coffe_maker', 'kitchen_counter', 'shoes', 'cd', 'hairbrush', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'scrabble', 'hands_both'] Task:Wash hands response: { thoughts : I have had my lunch and walked towards the sink and applied soap to my hands and washed cleanly., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>'] } Scene_Objects:['pot', 'microwave', 'walllamp', 'ground_coffee', 'orchid', 'drawing', 'cpuscreen', 'floor', 'phone', 'ceiling', 'toaster', 'ceilinglamp', 'plate', 'tvstand', 'window', 'dish_soap', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'razor', 'tray', 'mouse', 'kitchen_counter', 'cupboard', 'bathtub', 'dishwasher', 'instrument_violin'] Task:Wash dishes with dishwasher response: | { Go to the kitchen. Find the dishwasher. Open the dishwasher. Find the plates. Load the plates into the dishwasher. Find the soap. Load the soap into the dishwasher. Close the dishwasher. Turn on the dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'food_salt', 'cd_player', 'chair', 'freezer', 'bathroom', 'food_carrot', 'orchid', 'knifeblock', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'remote_control', 'computer', 'window', 'mousepad', 'wall', 'nightstand', 'light_bulb', 'check', 'food_onion', 'curtain', 'mouse', 'door', 'light', 'tooth_paste'] Task:Listen to music response: { thoughts : Walk to CD player and turn it on then go and sit in a chair and turn the remote control on and then listen to some music., actions : ['[WALK] <cd_player>', '[SWITCHON] <cd_player>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <remote_control>', '[TOUCH] <remote_control>'] } Scene_Objects:['food_salt', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'tea_bag', 'bookshelf', 'food_bacon', 'toaster', 'plate', 'tvstand', 'dish_soap', 'mousepad', 'couch', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'toothbrush_holder', 'ice', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'clothes_dress', 'dishwasher'] Task:Wash dishes with dishwasher response: | { Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty 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:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'envelope', 'mop_bucket', 'toaster', 'mat', 'faucet', 'dish_soap', 'couch', 'wall', 'cup', 'photoframe', 'toilet_paper', 'video_game_controller', 'wooden_spoon', 'tray', 'console', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'light'] Task:Wash dishes response: { thoughts : Place all of the dirty dishes in a sink full of clean, soapy water. Wash them. Rinse them in fresh, running water. Place them in the strainer to dry., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[PUTBACK] <sponge> <sink>', '[SWITCHON] <faucet>', '[RINSE] <cup>', '[GRAB] <cup>', '[FIND] <dishrack>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[GRAB] <sponge>', '[PUTOBJBACK] <sponge>'] } Scene_Objects:['dry_pasta', 'tablelamp', 'toilet', 'freezer', 'walllamp', 'drawing', 'character', 'bedroom', 'toaster', 'deck_of_cards', 'faucet', 'shower', 'plate', 'window', 'mousepad', 'couch', 'candle', 'clothes_hat', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'tray', 'mouse', 'pencil', 'bathtub', 'bathroom_cabinet', 'table', 'dishwasher', 'board_game'] Task:Listen to music response: | { I walk into the bedroom. I walk to stereo. I turn on stereo. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tea', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'piano_bench', 'mat', 'shoe-shine_kit', 'balanceball', 'oil', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouthwash', 'doorjamb', 'towel_rack', 'vacuum_cleaner', 'door', 'home_office', 'light', 'soap'] Task:Turn on light response: { thoughts : switching on the light, actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['fork', 'pot', 'microwave', 'toilet', 'cat', 'wallshelf', 'bathroom_counter', 'floor', 'dvd_player', 'bookshelf', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'shower', 'faucet', 'tvstand', 'couch', 'towel', 'wall', 'bench', 'cutting_board', 'bed', 'razor', 'television', 'curtain', 'kitchen_counter', 'dresser', 'home_office', 'light'] Task:Pet cat response: | { Pet 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:['blender', 'tea', 'microwave', 'jelly', 'band-aids', 'freezer', 'bathroom', 'needle', 'ceiling', 'character', 'keyboard', 'mop_bucket', 'ceilinglamp', 'mat', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'oven', 'photoframe', 'coffe_maker', 'check', 'television', 'cards', 'laundry_detergent', 'clothes_dress', 'home_office', 'table'] Task:Put umbrella away response: { thoughts : Place the umbrella in the umbrella bucket point first., actions : ['[WALK] <home_office>', '[WALK] <mop_bucket>'] } Scene_Objects:['food_salt', 'walllamp', 'toothbrush', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'dvd_player', 'keyboard', 'toaster', 'plate', 'foundation', 'dish_soap', 'form', 'wall', 'bench', 'novel', 'coffe_maker', 'check', 'food_donut', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'instrument_guitar', 'dishwasher', 'soap', 'scrabble'] Task:Wash dishes with dishwasher response: | { Wash a plate using the dishwasher 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:['tea', 'walllamp', 'drawing', 'orchid', 'food_egg', 'floor', 'ceiling', 'phone', 'character', 'remote_control', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'shower', 'couch', 'clothes_hat', 'wall', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'television', 'food_onion', 'doorjamb', 'controller', 'door', 'table'] Task:Change TV channel response: { thoughts : Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control, actions : ['[WALK] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[PUTOBJBACK] <remote_control>'] } Scene_Objects:['tablelamp', 'freezer', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'keyboard', 'bookshelf', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'toy', 'bed', 'doorjamb', 'diary', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'table', 'light'] Task:Relax on sofa response: | { I walk to the sofa, and lie down 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:['band-aids', 'trashcan', 'wallshelf', 'clothes_underwear', 'desk', 'keyboard', 'mail', 'computer', 'tvstand', 'shower', 'window', 'clothes_socks', 'couch', 'food_peanut_butter', 'pillow', 'basket_for_clothes', 'keys', 'coffe_maker', 'television', 'food_donut', 'tray', 'rag', 'headset', 'clothes_scarf', 'bathtub', 'sink', 'light', 'dishwasher', 'soap', 'washing_machine'] Task:Wash clothes response: { thoughts : Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine, actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'detergent', 'knifeblock', 'phone', 'bookshelf', 'computer', 'mop_bucket', 'brush', 'clothes_socks', 'mousepad', 'dining_room', 'nightstand', 'basket_for_clothes', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'sink', 'home_office', 'napkin', 'dishwasher', 'bathroom_cabinet', 'washing_machine'] Task:Wash clothes response: | { \ I walk to entrance hall\ \ I walk to bedroom\ \ I find basket of clothes\ \ I lift basket of clothes\ \ I walk to kitchen\ \ I find washing machine\ \ I open washing machine \ \ I put laundry in washing machine\ \ I add laundry detergent\ \ \ I close washing machine lid\ \ I switch washing machine on\ } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'juice', 'microwave', 'chair', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'computer', 'table_cloth', 'tvstand', 'shower', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'television', 'tray', 'doorjamb', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'board_game'] Task:Turn on light response: { thoughts : walk into living room, walk to light, turn on light switch., actions : ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>'] } Scene_Objects:['walllamp', 'detergent', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'shower', 'stereo', 'couch', 'pillow', 'wall', 'oven', 'mouthwash', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'instrument_guitar', 'table', 'light', 'dishwasher', 'colander'] Task:Relax on sofa response: | { lie in the sofa, 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:['food_bread', 'microwave', 'freezer', 'walllamp', 'bathroom', 'toothbrush', 'orchid', 'hanger', 'longboard', 'phone', 'desk', 'computer', 'food_bacon', 'table_cloth', 'clothes_jacket', 'brush', 'ceilinglamp', 'faucet', 'foundation', 'mousepad', 'clothes_pants', 'pasta', 'light_bulb', 'toothbrush_holder', 'coin', 'coffee_filter', 'towel_rack', 'hair', 'vase', 'tooth_paste'] Task:Wash teeth response: { thoughts : WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR TEETH, actions : ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>'] } 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: | { Walk to living room. Sit on sofa. Lie down on sofa. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'food_ice_cream', 'microwave', 'freezer', 'ground_coffee', 'nail_polish', 'milk', 'hanger', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'faucet', 'clothes_hat', 'wall', 'wall_clock', 'oven', 'cutting_board', 'shelf', 'coffe_maker', 'check', 'television', 'coffee_filter', 'water', 'curtain', 'kitchen_counter', 'maindoor', 'sink', 'vase', 'soap'] Task:Make coffee response: { thoughts : Walk to kitchen. Find coffee maker. Find coffee filter. Put it in the coffee maker. Find ground coffee. Put it in the coffee maker. Find Water. Put it in the coffe maker. Switch on the coffee maker., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[FIND] <water>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['water_glass', 'tablelamp', 'crayon', 'freezer', 'knifeblock', 'bathroom_counter', 'shampoo', 'ceiling', 'thread', 'faucet', 'shower', 'mousepad', 'food_kiwi', 'nightstand', 'wall', 'bench', 'powersocket', 'cup', 'clothes_gloves', 'novel', 'food_food', 'coffe_maker', 'toothbrush_holder', 'water', 'doorjamb', 'mouse', 'shoes', 'dresser', 'cupboard', 'table'] Task:Drink response: | { Drinking a glass of 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:['sheets', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'bathroom', 'ceilingfan', 'clothes_underwear', 'bathroom_counter', 'character', 'thread', 'piano_bench', 'toaster', 'deck_of_cards', 'homework', 'couch', 'dustpan', 'powersocket', 'newspaper', 'clothes_gloves', 'novel', 'coffe_maker', 'doorjamb', 'chessboard', 'cd', 'napkin', 'home_office', 'instrument_guitar', 'clothes_skirt', 'light'] Task:Close door response: { thoughts : Push the door shut until it latches., actions : ['[RUN] <home_office>'] } Scene_Objects:['microwave', 'walllamp', 'bathroom', 'detergent', 'cpuscreen', 'ceiling', 'computer', 'toaster', 'brush', 'laptop', 'faucet', 'mousepad', 'clothes_pants', 'dirt', 'powersocket', 'oven', 'cup', 'bed', 'food_food', 'television', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'chessboard', 'laundry_detergent', 'sink', 'dishwasher', 'washing_machine'] Task:Wash clothes response: | { Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in 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:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'bookmark', 'toaster', 'mat', 'tvstand', 'faucet', 'shower', 'laptop', 'mousepad', 'wall', 'oven', 'powersocket', 'towel_rack', 'kitchen_counter', 'headset', 'door', 'sink', 'bathtub', 'home_office', 'bathroom_cabinet', 'light'] Task:Go to toilet response: { thoughts : I go to the bathroom. I locate the toilet. I walk to the toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[WALK] <toilet>'] } Scene_Objects:['sheets', 'tablelamp', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'wallshelf', 'clothes_underwear', 'floor', 'desk', 'mail', 'button', 'stovefan', 'toaster', 'mousepad', 'soap', 'pillow', 'dining_room', 'photoframe', 'television', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'controller', 'bathtub', 'bathroom_cabinet', 'colander', 'clothes_shirt', 'coffee'] Task:Pet cat response: | { Find a cat in the kitchen and touch 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:['dry_pasta', 'pot', 'measuring_cup', 'microwave', 'chair', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'cleaning_solution', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'couch', 'clothes_pants', 'coffe_maker', 'mirror', 'curtain', 'rag', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'dishwasher'] Task:Clean mirror response: { thoughts : Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean., actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['sheets', 'jelly', 'freezer', 'ground_coffee', 'walllamp', 'trashcan', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'stovefan', 'mat', 'mousepad', 'couch', 'clothes_hat', 'dining_room', 'wall', 'nightstand', 'cup', 'light_bulb', 'coffe_maker', 'coffee_filter', 'water', 'coffee_pot', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher'] Task:Make coffee response: | { Making 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:['fork', 'chair', 'walllamp', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'candle', 'pillow', 'wall', 'cup', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'bathroom_cabinet', 'teeth'] Task:Watch TV response: { thoughts : SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } 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: | { Walk to the living room. Walk to the sofa and sit on the sofa. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'ground_coffee', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'shampoo', 'character', 'computer', 'ceilinglamp', 'mat', 'iron', 'plate', 'window', 'couch', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'photoframe', 'newspaper', 'video_game_controller', 'television', 'centerpiece', 'doorjamb', 'towel_rack', 'door', 'bathroom_cabinet', 'table'] Task:Read book response: { thoughts : Sit on a couch, grab a book, open it, and scan the pages, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>'] } Scene_Objects:['pot', 'filing_cabinet', 'crayon', 'microwave', 'walllamp', 'dough', 'knifeblock', 'wallshelf', 'floor', 'phone', 'shampoo', 'desk', 'keyboard', 'bookmark', 'mat', 'shoe-shine_kit', 'floor_lamp', 'mousepad', 'pillow', 'powersocket', 'novel', 'curtain', 'centerpiece', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'table', 'clothes_skirt', 'colander'] Task:Read book response: | { Turn a light on and read a book in the bedroom. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'detergent', 'knifeblock', 'phone', 'bookshelf', 'computer', 'mop_bucket', 'brush', 'clothes_socks', 'mousepad', 'dining_room', 'nightstand', 'basket_for_clothes', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'sink', 'home_office', 'napkin', 'dishwasher', 'bathroom_cabinet', 'washing_machine'] Task:Wash clothes response: { thoughts : I walk to entrance hall I walk to bedroom I find basket of clothes I lift basket of clothes I walk to kitchen I find washing machine I open washing machine I put laundry in washing machine I add laundry detergent I close washing machine lid I switch washing machine on , actions : ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>'] } Scene_Objects:['walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'alcohol', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'bench', 'photoframe', 'food_food', 'television', 'curtain', 'doorjamb', 'door', 'sink', 'light', 'table'] Task:Watch TV response: | { walk to living room, find the television, switch on the television, find the sofa, walk to sofa, sit in sofa, 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:['filing_cabinet', 'tablelamp', 'dog', 'freezer', 'orchid', 'drawing', 'wallshelf', 'ceiling', 'character', 'mail', 'clothes_jacket', 'computer', 'mat', 'faucet', 'window', 'closetdrawer', 'nightstand', 'wall_clock', 'oven', 'basket_for_clothes', 'coffe_maker', 'mouse', 'dresser', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'light', 'scrabble', 'washing_machine'] Task:Wash clothes response: { thoughts : Pick up my dirty clothes, load the washer, add detergent, turn on washer, actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>'] } Scene_Objects:['sponge', 'toilet', 'orchid', 'drawing', 'ceiling', 'bedroom', 'computer', 'mat', 'shoe-shine_kit', 'stereo', 'ceilinglamp', 'window', 'tvstand', 'food_orange', 'nightstand', 'bench', 'bed', 'coffe_maker', 'food_food', 'television', 'doorjamb', 'mouse', 'pencil', 'dresser', 'pajamas', 'cupboard', 'bathtub', 'table', 'clothes_shirt', 'coffee'] Task:Listen to music 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:['microwave', 'walllamp', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'longboard', 'character', 'bedroom', 'computer', 'faucet', 'homework', 'clothes_socks', 'food_noodles', 'dining_room', 'photoframe', 'check', 'television', 'after_shave', 'rag', 'lighter', 'towel_rack', 'kitchen_counter', 'dresser', 'clothes_dress', 'home_office', 'light', 'laser_pointer', 'scrabble'] Task:Pick up phone response: { thoughts : I walk to the home office. I find the telephone. I pick up the telephone handset., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['pot', 'toilet', 'chair', 'walllamp', 'knifeblock', 'drawing', 'floor', 'phone', 'keyboard', 'toaster', 'stovefan', 'plate', 'shower', 'tvstand', 'dish_soap', 'couch', 'wall', 'coffe_maker', 'video_game_controller', 'food_onion', 'rag', 'towel_rack', 'mouse', 'kettle', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', 'dishwasher'] Task:Wash dishes with dishwasher response: | { Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'measuring_cup', 'jelly', 'chair', 'freezer', 'hanger', 'ceiling', 'thread', 'computer', 'mail', 'bookmark', 'deck_of_cards', 'faucet', 'mousepad', 'dining_room', 'broom', 'wall', 'wall_clock', 'box', 'razor', 'doorjamb', 'mouse', 'pencil', 'hairbrush', 'door', 'napkin', 'table', 'light', 'dirt'] Task:Pick up phone response: { thoughts : Enter the Home office, then walk to the phone, pickup the phone., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'mop', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'toaster', 'stereo', 'window', 'wall', 'bed', 'novel', 'coffe_maker', 'coffee_filter', 'water', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'spoon', 'light', 'dishwasher', 'table', 'coffee'] Task:Make coffee response: | { Go to the kitchen and make 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:['filing_cabinet', 'food_ice_cream', 'chair', 'nail_polish', 'bathroom', 'cat', 'dough', 'toothbrush', 'desk', 'button', 'stovefan', 'shower', 'faucet', 'window', 'pillow', 'nightstand', 'wall_clock', 'oven', 'cutting_board', 'novel', 'check', 'television', 'toothbrush_holder', 'lighter', 'kettle', 'chessboard', 'dresser', 'sink', 'home_office', 'clothes_skirt'] Task:Keep cats out of room response: { thoughts : Stand in the doorway and create a loud noise so the cats will stay out., actions : ['[WALK] <bedroom>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>'] } Scene_Objects:['spectacles', 'juice', 'food_salt', 'chair', 'freezer', 'ground_coffee', 'blow_dryer', 'nail_polish', 'food_egg', 'wallshelf', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'mop_bucket', 'toaster', 'ceilinglamp', 'clothes_hat', 'wall', 'food_food', 'food_donut', 'tray', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'laser_pointer'] Task:Put groceries in Fridge response: | { Walk to kitchen. Grab groceries and walk to the fridge. Open fridge and put groceries in the fridge. Close the fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'centerpiece', 'mouse', 'cupboard', 'sink', 'bathroom_cabinet', 'table'] Task:Browse internet response: { thoughts : Go find a computer, turn it on, click google, and browse the internet., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'food_bacon', 'mat', 'plate', 'faucet', 'shower', 'wall', 'nightstand', 'oven', 'toy', 'wooden_spoon', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'bathtub'] Task:Wash dishes by hand response: | { Walk into the kitchen. Walk up to the sink. Turn on the faucet. Pick up the plate. Wash the plate. Rinse the 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:['sheets', 'microwave', 'chair', 'bathroom', 'orchid', 'food_egg', 'cpuscreen', 'floor', 'phone', 'bedroom', 'desk', 'stovefan', 'toaster', 'ceilinglamp', 'shower', 'mat', 'food_peanut_butter', 'wall', 'pasta', 'powersocket', 'oven', 'cup', 'bed', 'after_shave', 'food_onion', 'chessboard', 'dresser', 'cupboard', 'clothes_scarf', 'home_office'] Task:Pet cat response: { thoughts : I walk to my living room, find my cat, scrub it using my hand., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>'] } Scene_Objects:['pot', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'stovefan', 'faucet', 'food_jam', 'wall', 'nightstand', 'oven', 'cup', 'photoframe', 'light_bulb', 'bed', 'clothes_gloves', 'television', 'water', 'tray', 'lighter', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'colander'] Task:Drink response: | { Walk to kitchen, grab a cup, fill with water and then drink it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', '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:['tablelamp', 'scissors', 'microwave', 'toilet', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'food_cake', 'food_bacon', 'table_cloth', 'bookmark', 'ceilinglamp', 'tvstand', 'faucet', 'couch', 'pillow', 'bowl', 'dining_room', 'wall', 'coffe_maker', 'doorjamb', 'door', 'home_office', 'table', 'light', 'dishwasher'] Task:Relax on sofa response: | { go to the living room,find the sofa,sat down in the sofa,take some relaxation. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'purse', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'wall', 'powersocket', 'bench', 'cup', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'door', 'sink', 'bathroom_cabinet', 'light', 'home_office'] Task:Turn off light response: { thoughts : Grasp light switch, flip light switch., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[SWITCHOFF] <light>'] } Scene_Objects:['sheets', 'filing_cabinet', 'measuring_cup', 'chair', 'walllamp', 'bathroom', 'drawing', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'food_cake', 'toaster', 'shower', 'picture', 'electric_shaver', 'window', 'nightstand', 'basket_for_clothes', 'bed', 'food_food', 'curtain', 'doorjamb', 'cupboard', 'napkin', 'instrument_guitar', 'bathroom_cabinet', 'light'] Task:Pet cat response: | { Walk into the living room, sit down by the cat, put out hand, stroke the cat from head to tail } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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_bread', 'scissors', 'measuring_cup', 'toilet', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'remote_control', 'purse', 'brush', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'form', 'dining_room', 'wall', 'powersocket', 'television', 'curtain', 'food_onion', 'table'] Task:Watch TV response: { thoughts : Walk to living room. Find remote control. Look at remote control. Push power on button. Find sofa. Sit down on sofa. Watch Television., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'band-aids', 'walllamp', 'blow_dryer', 'detergent', 'bathroom', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'stereo', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'clothes_gloves', 'water', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'napkin'] Task:Drink response: | { Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from 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:['sheets', 'walllamp', 'drawing', 'cpuscreen', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'alcohol', 'laptop', 'plate', 'faucet', 'homework', 'mousepad', 'dining_room', 'check', 'food_food', 'television', 'tray', 'wooden_spoon', 'mouse', 'shoes', 'conditioner', 'maindoor', 'napkin', 'home_office', 'soap', 'instrument_violin'] Task:Browse internet response: { thoughts : I turn on computer. I use keyboard to type. I open browser. I search., actions : ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'coffee_table', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'centerpiece', 'door', 'bathroom_cabinet', 'table', 'light', 'board_game'] Task:Watch TV response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_ice_cream', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'knife', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'character', 'ceilinglamp', 'mat', 'shower', 'food_jam', 'dining_room', 'wall', 'bench', 'cutting_board', 'food_vegetable', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'table', 'light'] Task:Chop vegetables response: { thoughts : Cut up veggies with knife, actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <cutting_board>', '[GRAB] <cutting_board>', '[CLOSE] <kitchen_cabinet>', '[WALK] <table>', '[PUTBACK] <knife> <table>', '[PUTBACK] <cutting_board> <table>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <food_vegetable> <cutting_board>', '[GRAB] <knife>', '[CUT] <food_vegetable>', '[PUTOBJBACK] <knife>'] } Scene_Objects:['scissors', 'tablelamp', 'chair', 'walllamp', 'trashcan', 'drawing', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'computer', 'faucet', 'foundation', 'couch', 'wall', 'cup', 'coffe_maker', 'razor', 'tray', 'wooden_spoon', 'towel_rack', 'cupboard', 'laundry_detergent', 'sink', 'bathtub', 'bathroom_cabinet', 'dishwasher', 'hands_both'] Task:Wash hands response: | { Going to the sink and scrubbing hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'door', 'table', 'light'] Task:Watch TV response: { thoughts : walk to living room, find couch, sit on couch, find remote control , turn on tv by pressing button, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>'] } Scene_Objects:['water_glass', 'pot', 'microwave', 'toilet', 'band-aids', 'walllamp', 'trashcan', 'knifeblock', 'drawing', 'ceiling', 'desk', 'stovefan', 'faucet', 'mousepad', 'wall', 'nightstand', 'oven', 'check', 'food_food', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cd', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'soap', 'laser_pointer'] Task:Drink response: | { I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and 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', 'chair', 'hanger', 'bathroom_counter', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'plate', 'tvstand', 'faucet', 'shower', 'dish_soap', 'mousepad', 'wall', 'wall_clock', 'oven', 'photoframe', 'bed', 'television', 'tray', 'towel_rack', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'dirt'] Task:Wash dishes with dishwasher response: { thoughts : walk into kitchen, find dishwasher, put plates in dishwasher, put soap in dishwasher, turn on dishwasher, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'foundation', 'couch', 'food_orange', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'console', 'door', 'home_office', 'table', 'light'] Task:Relax on sofa response: | { Go into the living room. Walk over to the sofa. Lie down on the sofa. Turn on and watch TV. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'sheets', 'drawing', 'cpuscreen', 'ceiling', 'desk', 'bookmark', 'mat', 'plate', 'stereo', 'deck_of_cards', 'mousepad', 'couch', 'clothes_hat', 'clothes_pants', 'bench', 'clothes_gloves', 'video_game_controller', 'curtain', 'towel_rack', 'cd', 'dishrack', 'chessboard', 'pajamas', 'laundry_detergent', 'maindoor', 'door', 'sink', 'bathroom_cabinet', 'clothes_shirt'] Task:Listen to music response: { thoughts : Find the radio; switch on the radio and listen to music., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['pot', 'walllamp', 'cat', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'character', 'bedroom', 'alcohol', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'couch', 'food_orange', 'wall', 'photoframe', 'coffe_maker', 'check', 'curtain', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'cupboard', 'sink', 'coffee_cup', 'dishwasher', 'table', 'coffee'] Task:Make coffee response: | { Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'cat', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'character', 'keyboard', 'remote_control', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'oil', 'couch', 'pillow', 'wall', 'check', 'television', 'curtain', 'door', 'home_office', 'table', 'bathroom_cabinet'] Task:Change TV channel response: { thoughts : Pickup remote control for the living room TV and push the change channel button, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['toilet', 'chair', 'ground_coffee', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'table_cloth', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'couch', 'candle', 'dustpan', 'pillow', 'dining_room', 'wall', 'powersocket', 'cup', 'photoframe', 'tray', 'curtain', 'door', 'bathtub', 'sink', 'light', 'table', 'dishwasher', 'shoe_rack'] Task:Listen to music response: | { I walk into my room and turn the radio on so that I can 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:['walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'laundry_detergent', 'door', 'table', 'light', 'soap'] Task:Watch TV response: { thoughts : turn tv on, watch TV, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['microwave', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'faucet', 'shower', 'window', 'towel', 'wall', 'newspaper', 'curtain', 'towel_rack', 'pencil', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap', 'hands_both'] Task:Wash hands response: | { I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'toaster', 'mat', 'plate', 'shower', 'iron', 'dish_soap', 'closetdrawer', 'pillow', 'wall', 'oven', 'basket_for_clothes', 'coffe_maker', 'check', 'tray', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'dishwasher', 'board_game', 'dirt'] Task:Wash dishes with dishwasher response: { thoughts : I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet.., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>', '[GRAB] <plate>', '[WIPE] <plate>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[PUTOBJBACK] <dishrack>'] } Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'laundry_detergent', 'door', 'table', 'light', 'soap'] Task:Watch TV response: | { turn tv on, 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:['pot', 'food_bread', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'desk', 'food_cake', 'stovefan', 'ceilinglamp', 'toaster', 'food_orange', 'wall', 'pasta', 'oven', 'tape', 'tray', 'wooden_spoon', 'centerpiece', 'kitchen_counter', 'cupboard', 'napkin', 'dishwasher', 'clothes_shirt'] Task:Cook some food response: { thoughts : Walk into the kitchen. Open the fridge. Take out the chicken. Open the kitchen cabinet. Take out the frying pan. Put the chicken in the frying pan. Put the frying pan on the stove. Turn on the stove. Cook the chicken., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[CLOSE] <freezer>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[CLOSE] <kitchen_cabinet>', '[WALK] <oven>', '[PUTBACK] <pot> <oven>', '[PUTBACK] <food_chicken> <oven>', '[SWITCHON] <oven>'] } Scene_Objects:['glue', 'tablelamp', 'drawing', 'knife', 'wallshelf', 'orchid', 'floor', 'bookshelf', 'mail', 'mat', 'tvstand', 'shower', 'window', 'mousepad', 'candle', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'food_food', 'coffe_maker', 'food_rice', 'tray', 'shoes', 'door', 'clothes_scarf', 'bathtub', 'bathroom_cabinet', 'light'] Task:Read book response: | { I would go lie down in my bed and 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:['filing_cabinet', 'trashcan', 'desk', 'keyboard', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'stereo', 'window', 'couch', 'dining_room', 'nightstand', 'wall', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'hairdryer', 'bathtub', 'bathroom_cabinet', 'home_office', 'dishwasher', 'table'] Task:Pick up phone response: { thoughts : walk into room, grab phone, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['pot', 'food_bread', 'microwave', 'chair', 'knifeblock', 'drawing', 'keyboard', 'button', 'stovefan', 'toaster', 'shower', 'window', 'dustpan', 'pillow', 'dining_room', 'nightstand', 'tape', 'novel', 'television', 'tray', 'curtain', 'after_shave', 'doorjamb', 'kitchen_counter', 'cupboard', 'clothes_dress', 'sink', 'bathroom_cabinet', 'light', 'dishwasher'] Task:Browse internet response: | { I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'nail_polish', 'food_carrot', 'drawing', 'knife', 'floor', 'ceiling', 'desk', 'mat', 'stereo', 'shower', 'clothes_socks', 'candle', 'pillow', 'dining_room', 'nightstand', 'bench', 'newspaper', 'check', 'video_game_controller', 'doorjamb', 'cards', 'chessboard', 'pajamas', 'clothes_dress', 'table', 'light', 'board_game', 'laser_pointer', 'coffee'] 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:['filing_cabinet', 'microwave', 'chair', 'bathroom', 'cat', 'milk', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'bookshelf', 'computer', 'plate', 'stereo', 'clothes_pants', 'pillow', 'oven', 'food_food', 'razor', 'towel_rack', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'shoes', 'dresser', 'cupboard', 'bathtub', 'light', 'dishwasher', 'laser_pointer'] Task:Give milk to cat response: | { Grab milk and pour it into the plate so that the cat can 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:['pot', 'filing_cabinet', 'microwave', 'chair', 'freezer', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'tvstand', 'shoe-shine_kit', 'faucet', 'window', 'mousepad', 'couch', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'curtain', 'coffee_pot', 'towel_rack', 'sink', 'light', 'laser_pointer'] Task:Gaze out window response: { thoughts : Look at the yard from the window, actions : ['[WALK] <home_office>', '[WALK] <window>', '[FIND] <window>', '[TURNTO] <window>', '[LOOKAT] <window>'] } Scene_Objects:['glue', 'food_ice_cream', 'tea', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'drawing', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'dining_room', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'cupboard', 'light', 'dishwasher'] Task:Change TV channel response: | { Walk to the living room. Find the television. Switch on the television. Find the remote control. Grab the remote control. Point at television. Find the button. Push button. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'tea', 'band-aids', 'walllamp', 'nail_polish', 'knifeblock', 'bills', 'cpuscreen', 'hanger', 'shampoo', 'phone', 'floor', 'bedroom', 'desk', 'toaster', 'stereo', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bowl', 'dining_room', 'bench', 'newspaper', 'clothes_gloves', 'coffe_maker', 'curtain', 'diary', 'hairbrush', 'bathroom_cabinet'] Task:Listen to music response: { thoughts : I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'nail_polish', 'food_carrot', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'keyboard', 'stovefan', 'mat', 'tvstand', 'homework', 'window', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'oven', 'bench', 'bed', 'novel', 'coffe_maker', 'toothbrush_holder', 'towel_rack', 'home_office', 'instrument_violin'] Task:Read book response: | { Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. Read the book. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'pot', 'tablelamp', 'crayon', 'tea', 'mop', 'ground_coffee', 'detergent', 'drawing', 'floor', 'phone', 'ceilinglamp', 'laptop', 'shower', 'iron', 'window', 'oil', 'couch', 'pillow', 'wall', 'oven', 'cup', 'coffe_maker', 'toilet_paper', 'television', 'door', 'sink', 'table', 'scrabble', 'dirt'] Task:Read book response: { thoughts : Bring book, lie on the sofa, read book, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[LIE] <couch>', '[READ] <novel>'] } 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: | { go to a bathroom, open the shower, let water wash your body } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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:['sponge', 'filing_cabinet', 'toilet', 'chair', 'knife', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'bookmark', 'plate', 'towel', 'pillow', 'photoframe', 'novel', 'coffe_maker', 'check', 'coffee_filter', 'curtain', 'doorjamb', 'towel_rack', 'sink', 'home_office', 'table', 'soap', 'teeth'] Task:Wash hands response: | { BEFORE EATING } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'window', 'toaster', 'clothes_pants', 'broom', 'powersocket', 'bench', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'dresser', 'hair', 'door', 'sink', 'clothes_shirt'] Task:Get dressed response: { thoughts : Get some clothes together that make an appropriate outfit. Put them on, actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <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:['tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'bathroom_counter', 'shampoo', 'floor', 'bookshelf', 'food_cake', 'mail', 'stovefan', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'wall', 'photoframe', 'toothbrush_holder', 'towel_rack', 'pencil', 'door', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'tooth_paste', 'coffee'] Task:Brush teeth response: | { getting ready for bed } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['ground_coffee', 'nail_polish', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'button', 'mail', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'tape', 'television', 'curtain', 'food_onion', 'cupboard', 'table', 'shoe_rack'] Task:Watch TV response: { thoughts : Go to the living room, sit on the couch, find the remote, switch on the TV and watch, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['spectacles', 'tablelamp', 'toilet', 'chair', 'bathroom', 'orchid', 'knifeblock', 'floor', 'phone', 'desk', 'keyboard', 'food_cake', 'foundation', 'floor_lamp', 'pillow', 'nightstand', 'powersocket', 'box', 'basket_for_clothes', 'razor', 'tray', 'doorjamb', 'cupboard', 'bathtub', 'spoon', 'home_office', 'table', 'bathroom_cabinet', 'light', 'dishwasher'] Task:Turn on light response: | { walk to living room, find lamp, switch 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:['food_bread', 'walllamp', 'toothbrush', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'toaster', 'ceilinglamp', 'window', 'homework', 'food_noodles', 'couch', 'candle', 'pillow', 'dining_room', 'wall', 'powersocket', 'toy', 'food_food', 'toilet_paper', 'tray', 'curtain', 'food_onion', 'shoes', 'door', 'table'] Task:Relax on sofa response: { thoughts : Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['fork', 'measuring_cup', 'walllamp', 'knifeblock', 'knife', 'drawing', 'floor', 'ceiling', 'character', 'toaster', 'mat', 'plate', 'shower', 'dish_soap', 'clothes_socks', 'wall', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dishrack', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'instrument_guitar', 'dishwasher', 'bathtub'] Task:Wash dishes with dishwasher response: | { put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser 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:['scissors', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'window', 'toaster', 'clothes_pants', 'broom', 'powersocket', 'bench', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'dresser', 'hair', 'door', 'sink', 'clothes_shirt'] Task:Get dressed response: { thoughts : Get some clothes together that make an appropriate outfit. Put them on, actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <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:['pot', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table'] Task:Change TV channel response: | { Walk into living room. Find television remote control. Pick up remote control. Press button. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'food_carrot', 'woman', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'child', 'bed', 'television', 'curtain', 'towel_rack', 'dresser', 'table'] Task:Watch movie response: { thoughts : Sitting and watching a movie with family, actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TURNTO] <child>', '[LOOKAT] <child>', '[GREET] <child>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>'] } Scene_Objects:['water_glass', 'pot', 'juice', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'drawing', 'cpuscreen', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'bookshelf', 'laptop', 'tvstand', 'faucet', 'electric_shaver', 'dining_room', 'wall', 'nightstand', 'oven', 'photoframe', 'novel', 'water', 'kitchen_counter', 'cupboard', 'hairdryer', 'sink', 'door'] Task:Drink response: | { Opening the kitchen cabinet to grab water glass and pour water from the faucet into it 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:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Pay bills response: { thoughts : Check my bills, on the computer, open the appropriate sites, pay my due bills, actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <computer>'] } Scene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'light', 'table'] Task:Watch TV response: | { walk to living room. look at remote control. grab remote control. plug in television. switch on television. lie in sofa. point at remote control. watch television. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table'] Task:Draft home response: { thoughts : Using mathematics and CAD software design a home, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>'] } Scene_Objects:['sheets', 'filing_cabinet', 'freezer', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'pasta', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light'] Task:Watch TV response: | { I come home and go to the sofa for turn off the tv 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:['pot', 'filing_cabinet', 'tablelamp', 'chair', 'freezer', 'bathroom', 'food_butter', 'drawing', 'food_egg', 'floor', 'computer', 'mat', 'tvstand', 'stereo', 'laptop', 'clothes_pants', 'towel', 'wall', 'nightstand', 'tape', 'bed', 'food_food', 'coffe_maker', 'television', 'oven_mitts', 'tray', 'curtain', 'diary', 'cards', 'dishwasher'] Task:Listen to music response: { thoughts : Turn on radio, put on favorite channel, listen to music., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[LIE] <bed>'] } Scene_Objects:['mop', 'microwave', 'cd_player', 'walllamp', 'drawing', 'orchid', 'bills', 'floor', 'ceiling', 'desk', 'tea_bag', 'button', 'piano_bench', 'stovefan', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'ice', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'table', 'light'] Task:Listen to music response: | { Walk to living room, walk to cd player, turn on cd player, press play button, walk to sofa, sit in sofa 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:['scissors', 'freezer', 'walllamp', 'knifeblock', 'wallshelf', 'clothes_underwear', 'ceiling', 'bookshelf', 'keyboard', 'ceilinglamp', 'plate', 'stereo', 'clothes_socks', 'clothes_pants', 'pillow', 'bowl', 'powersocket', 'cutting_board', 'basket_for_clothes', 'razor', 'coin', 'wine', 'curtain', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'laundry_detergent', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: { thoughts : I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on., actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'tvstand', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'cup', 'television', 'doorjamb', 'mouse', 'shoes', 'door', 'sink', 'napkin', 'clothes_scarf', 'table', 'light', 'dishwasher', 'colander'] Task:Relax on sofa response: | { walk to living room ,find sofa ,sit on sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'dough', 'woman', 'knifeblock', 'bathroom_counter', 'floor', 'character', 'desk', 'tea_bag', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'wall', 'child', 'coffe_maker', 'video_game_controller', 'television', 'towel_rack', 'kettle', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'instrument_violin', 'clothes_shirt'] Task:Greet guests response: { thoughts : Go to the kitchen, greet your family members, actions : ['[WALK] <dining_room>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <woman>', '[GREET] <woman>', '[FIND] <chair>', '[SIT] <chair>'] } Scene_Objects:['beer', 'bathroom', 'orchid', 'knifeblock', 'food_egg', 'clothes_underwear', 'shampoo', 'bedroom', 'tvstand', 'shoe-shine_kit', 'pillow', 'dining_room', 'bench', 'powersocket', 'coffe_maker', 'video_game_controller', 'television', 'food_rice', 'tray', 'after_shave', 'food_onion', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'comb', 'cupboard', 'bathroom_cabinet', 'light', 'tooth_paste'] Task:Turn on light response: | { I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'tea', 'walllamp', 'cat', 'trashcan', 'food_butter', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'shower', 'closetdrawer', 'couch', 'dining_room', 'oven', 'bench', 'bed', 'food_food', 'television', 'food_onion', 'doorjamb', 'cupboard', 'sink', 'bathtub', 'soap', 'laser_pointer'] Task:Walk to room response: { thoughts : Leave the living room and enter the hall, actions : ['[WALK] <home_office>', '[WALK] <home_office>'] } Scene_Objects:['toilet', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'floor', 'bedroom', 'keyboard', 'stovefan', 'tvstand', 'homework', 'window', 'microphone', 'food_orange', 'pillow', 'dining_room', 'powersocket', 'bench', 'newspaper', 'bed', 'coffe_maker', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'spoon', 'home_office', 'bathroom_cabinet'] Task:Pick up phone response: | { Enter the Home office, then walk to the phone, pickup the phone. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'scissors', 'walllamp', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'bookmark', 'stovefan', 'shower', 'oil', 'dining_room', 'wall', 'powersocket', 'bench', 'love_seat', 'standingmirror', 'novel', 'coffe_maker', 'check', 'after_shave', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'maindoor', 'bathtub', 'soap'] Task:Read book response: { thoughts : Obtain a book from the book shelf. Sit in the easy chair. Read the book. Mark the stopping point with a bookmark. Put the book back on the book shelf., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>'] } Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'clothes_underwear', 'floor', 'ceiling', 'thread', 'computer', 'bookmark', 'toaster', 'stovefan', 'couch', 'wall', 'powersocket', 'cup', 'food_food', 'razor', 'water', 'tray', 'centerpiece', 'pencil', 'kitchen_counter', 'chessboard', 'cupboard', 'clothes_scarf', 'light', 'table', 'dishwasher'] Task:Drink response: | { Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the 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:['blender', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'stereo', 'picture', 'mat', 'closetdrawer', 'couch', 'dining_room', 'wall_clock', 'bench', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'home_office', 'instrument_guitar'] Task:Turn on light response: { thoughts : I walk into the living room and then I walk to the light switch in there and turn the lights on, actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'folder', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'towel_rack', 'door', 'light', 'table'] Task:Watch TV response: | { Walk to the living room. Find the television. Walk to the television. Switch on the television. Find the sofa. Walk to the sofa. Sit on the sofa. Find the remote control. Grab the remote control. Look at the television. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'tea_bag', 'keyboard', 'food_bacon', 'stovefan', 'tvstand', 'faucet', 'couch', 'microphone', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'oven_mitts', 'doorjamb', 'mouse', 'door', 'bathtub', 'sink', 'table', 'light', 'dishwasher'] Task:Relax on sofa response: { thoughts : Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['pot', 'food_bread', 'tablelamp', 'juice', 'cd_player', 'band-aids', 'walllamp', 'cpuscreen', 'bathroom_counter', 'ceiling', 'desk', 'stovefan', 'stereo', 'homework', 'food_orange', 'nightstand', 'bench', 'bed', 'newspaper', 'photoframe', 'coffe_maker', 'check', 'food_onion', 'curtain', 'doorjamb', 'dresser', 'door', 'sink', 'bathtub', 'light'] Task:Listen to music response: | { I walk in the living room, then I go the the stereo and the cd player and turn them on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'shoe_rack', 'food_salt', 'beer', 'measuring_cup', 'microwave', 'trashcan', 'food_carrot', 'orchid', 'drawing', 'bookshelf', 'envelope', 'alcohol', 'ceilinglamp', 'plate', 'food_jam', 'pillow', 'oven', 'newspaper', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'lighter', 'doorjamb', 'coffee_pot', 'towel_rack', 'cupboard', 'hairdryer', 'creditcard'] Task:Pet cat response: { thoughts : find a cat, touch it gently, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'bookshelf', 'deck_of_cards', 'faucet', 'mousepad', 'pillow', 'wall', 'oven', 'box', 'cup', 'toilet_paper', 'rag', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'bathroom_cabinet', 'bathtub', 'table', 'home_office'] Task:Drink response: | { I walk the kitchen and walk up to the kitchen cabinet. I open the cabinet and take out a cup. I walk to sink and I turn the faucet on using the cold water handle. I put my cup under the running water until it is full. I turn off the cold water handle and bring the cup to my mouth and 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:['food_salt', 'toilet', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'bedroom', 'keyboard', 'tvstand', 'stereo', 'balanceball', 'picture', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'bed', 'toilet_paper', 'coffe_maker', 'cards', 'mouse', 'kitchen_counter', 'cd', 'vase'] Task:Go to toilet response: { thoughts : Walk to the bathroom. Find the toilet. Lift the top of the toilet. Sit on the toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>'] } Scene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'window', 'pillow', 'wall', 'powersocket', 'tray', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bathtub', 'light', 'teeth', 'shoe_rack'] Task:Go to toilet response: | { walk to bathroom , run to 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:['sheets', 'fork', 'filing_cabinet', 'toilet', 'detergent', 'food_butter', 'orchid', 'needle', 'bills', 'stereo', 'window', 'dining_room', 'bench', 'oven', 'bed', 'novel', 'check', 'coffee_filter', 'tray', 'wooden_spoon', 'centerpiece', 'headset', 'conditioner', 'food_steak', 'napkin', 'home_office', 'soap', 'scrabble', 'dirt', 'coffee'] Task:File documents response: { thoughts : I file all of my paperwork (including bills, receipts, documents, device instructions, etc.) in my black paperwork case that has many different files in order to organize. I place each piece of paper in its' corresponding subject (as indicated by printed words on each tab)., actions : ['[WALK] <home_office>', '[WALK] <bills>', '[FIND] <bills>', '[GRAB] <bills>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTIN] <bills> <filing_cabinet>', '[FIND] <check>', '[GRAB] <check>', '[WALK] <filing_cabinet>', '[PUTIN] <check> <filing_cabinet>', '[FIND] <check>', '[GRAB] <check>', '[WALK] <filing_cabinet>', '[PUTIN] <check> <filing_cabinet>'] } Scene_Objects:['water_glass', 'tablelamp', 'juice', 'food_ice_cream', 'measuring_cup', 'chair', 'freezer', 'nail_polish', 'detergent', 'food_carrot', 'toothbrush', 'drawing', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'bookmark', 'toaster', 'couch', 'wall', 'keys', 'toilet_paper', 'television', 'kitchen_counter', 'headset', 'cupboard', 'door', 'home_office', 'light'] Task:Drink response: | { walk to kitchen ,find fridge ,open fridge ,find water glass , drink from water glass } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'microwave', 'freezer', 'knife', 'food_egg', 'wallshelf', 'kitchen_cabinet', 'ceiling', 'character', 'desk', 'tea_bag', 'toaster', 'stovefan', 'plate', 'faucet', 'shower', 'mat', 'wall', 'oven', 'bench', 'coffe_maker', 'drinking_glass', 'tray', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', 'napkin', '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:['tablelamp', 'toilet', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'conditioner', 'door', 'table', 'light'] Task:Relax on sofa response: | { For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'toilet', 'jelly', 'freezer', 'walllamp', 'bathroom', 'hanger', 'folder', 'bedroom', 'desk', 'tvstand', 'window', 'food_jam', 'microphone', 'dining_room', 'wall_clock', 'powersocket', 'bench', 'shelf', 'bed', 'video_game_controller', 'food_donut', 'water', 'doorjamb', 'cards', 'towel_rack', 'mouse', 'sink', 'colander', 'hands_both'] Task:Wash hands response: { thoughts : walk to bathroom, look at the water, wash hands, actions : ['[WALK] <bathroom>', '[WALK] <water>', '[FIND] <water>', '[TURNTO] <water>', '[LOOKAT] <water>', '[FIND] <hands_both>', '[WASH] <hands_both>'] } Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'trashcan', 'orchid', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'bookshelf', 'clothes_jacket', 'faucet', 'couch', 'clothes_pants', 'form', 'wall', 'cutting_board', 'photoframe', 'check', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'washing_machine'] Task:Wash clothes response: | { Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_salt', 'toilet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'bowl', 'wall', 'television', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'light', 'table', 'board_game'] Task:Write an email response: { thoughts : Turn on PC and log onto email account. Type email and send it. Switch off computer., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHOFF] <computer>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'shower', 'window', 'clothes_hat', 'dining_room', 'wall', 'bench', 'powersocket', 'photoframe', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'table', 'light', 'tooth_paste'] Task:Pick up phone response: | { Pick up phone } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'mop', 'microwave', 'toilet', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'computer', 'piano_bench', 'ceilinglamp', 'plate', 'deck_of_cards', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'bed', 'novel', 'television', 'doorjamb', 'door', 'coffee_cup', 'table', 'light'] Task:Relax on sofa response: { thoughts : you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[DRINK] <coffee_cup>'] } Scene_Objects:['food_salt', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'stovefan', 'tvstand', 'food_peanut_butter', 'nightstand', 'wall', 'oven', 'powersocket', 'coffe_maker', 'toothbrush_holder', 'after_shave', 'curtain', 'coffee_pot', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'bathtub', 'sink', 'home_office', 'dishwasher', 'tooth_paste'] Task:Brush teeth response: | { today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'juice', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'stovefan', 'balanceball', 'mat', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'light', 'dishwasher'] Task:Work response: { thoughts : Go to office, sit at desk, turn on computer, enter password, open application and begin work, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['pot', 'tablelamp', 'blender', 'microwave', 'toilet', 'detergent', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'keyboard', 'computer', 'brush', 'mat', 'laptop', 'faucet', 'ceilinglamp', 'window', 'dustpan', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'towel_rack', 'mouse', 'kitchen_counter', 'pajamas', 'dishwasher'] Task:Go to sleep response: | { go to bedroom, put pajamas on, lie in bed, 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:['food_salt', 'walllamp', 'detergent', 'orchid', 'drawing', 'cpuscreen', 'keyboard', 'envelope', 'computer', 'stovefan', 'faucet', 'electric_shaver', 'couch', 'candle', 'microphone', 'broom', 'nightstand', 'oven', 'bench', 'tape', 'cup', 'light_bulb', 'food_rice', 'wine', 'wooden_spoon', 'hair', 'maindoor', 'table', 'dishwasher', 'vase'] Task:Dust response: { thoughts : Get a broom or duster with long handle. Dust blades of ceiling fan., actions : ['[WALK] <bedroom>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[PUTOBJBACK] <duster>'] } 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: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'freezer', 'blow_dryer', 'walllamp', 'nail_polish', 'bathroom', 'toothbrush', 'drawing', 'hanger', 'floor', 'shampoo', 'character', 'desk', 'bookshelf', 'purse', 'envelope', 'mat', 'ceilinglamp', 'window', 'towel', 'wall', 'powersocket', 'toy', 'cup', 'food_food', 'coffe_maker', 'sink', 'duster'] Task:Dust response: { thoughts : Apply duster to shelves and clean them until dust is gone, actions : ['[WALK] <home_office>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[FIND] <filing_cabinet>', '[WIPE] <filing_cabinet>', '[PUTOBJBACK] <duster>'] } Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'knife', 'knifeblock', 'orchid', 'drawing', 'floor', 'phone', 'character', 'bedroom', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'faucet', 'shower', 'oil', 'dining_room', 'powersocket', 'newspaper', 'ice', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'door', 'home_office', 'table'] Task:Change TV channel response: | { I pick up the remote. I press button on 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:['bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'bookshelf', 'piano_bench', 'stovefan', 'ceilinglamp', 'faucet', 'electric_shaver', 'window', 'teeth', 'food_orange', 'pillow', 'wall', 'powersocket', 'food_food', 'tray', 'curtain', 'dresser', 'hair', 'controller', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : I walk in to the bathroom. I find the soap. I find the faucet. I turn on the faucet. I wash my hands. I put the soap back. I rinse my hands. I turn the faucet off., actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['microwave', 'walllamp', 'orchid', 'ceiling', 'desk', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'plate', 'shower', 'faucet', 'window', 'form', 'dining_room', 'oven', 'basket_for_clothes', 'keys', 'novel', 'food_food', 'coffe_maker', 'food_rice', 'tray', 'doorjamb', 'cards', 'mouse', 'pajamas', 'home_office', 'light', 'bathroom_cabinet'] Task:Listen to music response: | { Find the playback device you want to listen to. turn on. press play. enjoyu 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:['food_salt', 'microwave', 'detergent', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'shoe-shine_kit', 'faucet', 'clothes_socks', 'closetdrawer', 'mousepad', 'dining_room', 'broom', 'wall', 'nightstand', 'photoframe', 'television', 'water', 'tray', 'cards', 'paper_towel', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my hands., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <water>', '[TURNTO] <water>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <water>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>'] } Scene_Objects:['walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'button', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'pencil', 'dresser', 'cupboard', 'hair', 'light', 'table'] Task:Change TV channel response: | { Go to the living room, Switch on the television. Find the remote and press the change channel button, change the channel } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.