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:['food_bread', 'filing_cabinet', 'toilet', 'freezer', 'dough', 'drawing', 'hanger', 'floor', 'ceiling', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'powersocket', 'wall_clock', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'razor', 'coffee_filter', 'doorjamb', 'hairbrush', 'door', 'home_office', 'light', 'soap'] Task:Put away groceries response: { thoughts : Place groceries in refrigerator from shopping at the grocery store., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['beer', 'walllamp', 'blow_dryer', 'knifeblock', 'hanger', 'floor', 'ceiling', 'piano_bench', 'ceilinglamp', 'faucet', 'stereo', 'oil', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'toilet_paper', 'coffee_filter', 'water', 'wine', 'tray', 'curtain', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'dishwasher', 'laser_pointer', '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:['sheets', 'pot', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'plate', 'stereo', 'mousepad', 'wall', 'bench', 'television', 'wine', 'rag', 'lighter', 'shaving_cream', 'mouse', 'hairbrush', 'door', 'table'] Task:Write an email response: { thoughts : walk to living room, look at computer, find chair, sit in chair, grab keyboard, grab mouse, type using keyboard and mouse, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TYPE] <keyboard>'] } Scene_Objects:['beer', 'toilet', 'freezer', 'bathroom', 'knifeblock', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'clothes_jacket', 'mat', 'shower', 'candle', 'creditcard', 'food_jam', 'food_orange', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_rice', 'doorjamb', 'door', 'spoon', 'light', 'board_game', 'shoe_rack'] 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:['scissors', 'cat', 'drawing', 'hanger', 'longboard', 'floor', 'phone', 'character', 'desk', 'purse', 'stovefan', 'ceilinglamp', 'iron', 'stereo', 'window', 'oil', 'couch', 'wall', 'bench', 'toy', 'food_food', 'television', 'food_rice', 'towel_rack', 'console', 'hairbrush', 'napkin', 'table', 'vase', 'dirt'] Task:Pet cat response: { thoughts : I would walk into the living room. Then sit on the couch and pet the cat., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['sponge', 'fork', 'microwave', 'toilet', 'walllamp', 'detergent', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bedroom', 'keyboard', 'table_cloth', 'toaster', 'laptop', 'plate', 'faucet', 'stereo', 'shower', 'food_noodles', 'wall', 'nightstand', 'novel', 'check', 'food_food', 'coin', 'kitchen_counter', 'cupboard', 'sink'] 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:['filing_cabinet', 'microwave', 'chair', 'freezer', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'character', 'bedroom', 'keyboard', 'computer', 'stereo', 'shower', 'towel', 'wall', 'wall_clock', 'pasta', 'nightstand', 'bed', 'doorjamb', 'dresser', 'cupboard', 'conditioner', 'door', 'clothes_scarf', 'light', 'clothes_shirt'] Task:Turn on light response: { thoughts : approach the light switch, raise hand to the switch, flip the switch, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['pot', 'food_ice_cream', 'microwave', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'faucet', 'mousepad', 'wall', 'wall_clock', 'oven', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'cards', 'kitchen_counter', 'cupboard', 'sink', 'light', 'dishwasher'] 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', 'crayon', 'tea', 'mop', 'microwave', 'toilet', 'toothbrush', 'drawing', 'knifeblock', 'orchid', 'phone', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'window', 'floor_lamp', 'couch', 'clothes_hat', 'photoframe', 'after_shave', 'food_onion', 'headset', 'chessboard', 'cupboard', 'controller', 'door', 'bathroom_cabinet', 'clothes_skirt'] Task:Switch on lamp response: { thoughts : Press the button so the light comes on., actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['sheets', 'food_salt', 'beer', 'chair', 'bathroom', 'cpuscreen', 'hanger', 'ceiling', 'desk', 'ceilinglamp', 'mat', 'shower', 'stereo', 'window', 'oil', 'dustpan', 'microphone', 'dining_room', 'novel', 'check', 'food_food', 'razor', 'ice', 'curtain', 'rag', 'after_shave', 'coffee_pot', 'shoes', 'instrument_guitar', 'tooth_paste'] Task:Listen to music response: | { I find a radio. I turn on the radio. I 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:['juice', 'toilet', 'chair', 'detergent', 'bathroom_counter', 'ceiling', 'character', 'desk', 'laptop', 'tvstand', 'faucet', 'electric_shaver', 'mousepad', 'couch', 'food_orange', 'bench', 'powersocket', 'cup', 'bed', 'novel', 'razor', 'oven_mitts', 'curtain', 'after_shave', 'cd', 'headset', 'dresser', 'pajamas', 'bathroom_cabinet', 'tooth_paste'] Task:Pick up phone response: { thoughts : I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>'] } Scene_Objects:['sponge', 'tablelamp', 'chair', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'tape', 'photoframe', 'coffee_table', 'television', 'toothbrush_holder', 'razor', 'curtain', 'dresser', 'pajamas', 'table'] 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:['tablelamp', 'chair', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'floor', 'dvd_player', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'electric_shaver', 'floor_lamp', 'mousepad', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'after_shave', 'cupboard', 'sink', 'home_office', 'table', 'tooth_paste'] Task:Turn on light response: { thoughts : Twist the lamp switch until the light goes on., actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'button', 'mat', 'shower', 'mousepad', 'oil', 'closetdrawer', 'microphone', 'oven', 'cutting_board', 'check', 'centerpiece', 'diary', 'clothes_dress', 'clothes_scarf', 'napkin', 'tooth_paste'] Task:Pet cat response: | { Walk into the living room. Walk up to the cat. Pet the cat with your hand. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'door', 'table', 'light', 'dishwasher'] Task:Change TV channel response: { thoughts : I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'walllamp', 'food_carrot', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'button', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'basket_for_clothes', 'food_food', 'television', 'curtain', 'dresser', 'clothes_dress', 'home_office', 'table'] Task:Change TV channel response: | { Take TV remote to change TV Channel. Press channel/program +/- button on TV 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:['chair', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'button', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'faucet', 'mousepad', 'dining_room', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'rag', 'doorjamb', 'kitchen_counter', 'light', 'table'] Task:Change TV channel response: { thoughts : walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[GRAB] <button>'] } Scene_Objects:['sheets', 'food_salt', 'chair', 'ground_coffee', 'bathroom', 'floor', 'ceiling', 'button', 'mop_bucket', 'homework', 'window', 'clothes_hat', 'clothes_pants', 'wall', 'toy', 'novel', 'coffe_maker', 'food_food', 'razor', 'wooden_spoon', 'doorjamb', 'diary', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'coffee_cup', 'dishwasher', 'clothes_skirt', '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:['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:['food_bread', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'stereo', 'faucet', 'oil', 'mousepad', 'couch', 'closetdrawer', 'dining_room', 'wall', 'oven', 'photoframe', 'coffee_table', 'novel', 'check', 'tray', 'food_onion', 'diary', 'mouse', 'cupboard', 'table'] Task:Read book response: | { I walk to the living room and pick up a book from the coffee table. I find my favorite chair. I sit in the armchair and open the book. I read. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'table_cloth', 'toaster', 'stovefan', 'tvstand', 'shower', 'faucet', 'closetdrawer', 'nightstand', 'wall', 'bench', 'coffe_maker', 'check', 'television', 'tray', 'pencil', 'shoes', 'sink', 'bathtub', 'light'] Task:Listen to music response: { thoughts : turn radio on, listen to music, actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['tea', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'desk', 'keyboard', 'computer', 'toaster', 'laptop', 'mat', 'stereo', 'mousepad', 'couch', 'wall', 'oven', 'bed', 'centerpiece', 'doorjamb', 'mouse', 'cd', 'dresser', 'food_steak', 'board_game', 'shoe_rack'] Task:Work response: | { first ill go to my home office adn ill switch on my laptop and with the use of mouse and keyboard il run my computer } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['water_glass', 'pot', 'food_salt', 'mop', 'freezer', 'walllamp', 'detergent', 'knifeblock', 'floor', 'ceiling', 'purse', 'button', 'piano_bench', 'food_bacon', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'form', 'wall', 'bench', 'food_food', 'television', 'water', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'maindoor', 'table'] Task:Drink response: { thoughts : I need to go to Kitchen. Get a cup. Fill cup. Drink, actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['sheets', 'food_ice_cream', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'bathroom_counter', 'phone', 'character', 'desk', 'thread', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'washing_machine', 'window', 'mousepad', 'clothes_pants', 'oven', 'bed', 'keys', 'check', 'dishrack', 'comb', 'laundry_detergent', 'door', 'napkin', 'clothes_shirt', 'dirt', 'coffee'] Task:Wash clothes response: | { Walk into laundry room. Open washing machine door. Put dirty clothes into washing machine. Measure laundry detergent and place into washing machine. Turn dial to appropriate wash setting. Power 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:['pot', 'filing_cabinet', 'toilet', 'walllamp', 'hanger', 'floor', 'ceiling', 'keyboard', 'computer', 'stovefan', 'stereo', 'shower', 'window', 'mousepad', 'wall', 'nightstand', 'wall_clock', 'toy', 'photoframe', 'coffe_maker', 'curtain', 'lighter', 'towel_rack', 'kitchen_counter', 'controller', 'bathtub', 'bathroom_cabinet', 'table', 'instrument_violin', 'creditcard'] Task:Open bathroom window response: { thoughts : Make sure bathroom window is unlocked. Lift up bathroom window so it is open., actions : ['[WALK] <bathroom>', '[WALK] <window>', '[FIND] <window>', '[OPEN] <window>'] } Scene_Objects:['dog', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'table_cloth', 'mat', 'faucet', 'shower', 'oil', 'clothes_socks', 'dustpan', 'wall', 'toy', 'bed', 'razor', 'water', 'coffee_pot', 'cupboard', 'hairdryer', 'sink', 'napkin', 'bathroom_cabinet', 'teeth'] Task:Wash teeth response: | { Wash the teeth } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'homework', 'towel', 'dining_room', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bag', 'napkin', 'soap'] Task:Put groceries in Fridge response: { thoughts : Walk to kitchen counter, grab a grocery, walk to fridge, open fridge, put the grocery into fridge, and close fridge, actions : ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'tablelamp', 'freezer', 'ground_coffee', 'walllamp', 'food_egg', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'stovefan', 'plate', 'mousepad', 'wall', 'nightstand', 'powersocket', 'novel', 'coffe_maker', 'check', 'coffee_filter', 'water', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'soap', 'teeth', 'shoe_rack'] Task:Make coffee response: | { Walk to kitchen, open coffee maker, find coffee filter, grab coffee filter, put coffee filter in coffee maker, find ground coffee, put ground coffee in coffee maker, pour water in coffee maker, close coffee maker and switch on coffee maker. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'detergent', 'cat', 'food_butter', 'knife', 'phone', 'character', 'table_cloth', 'mat', 'deck_of_cards', 'stereo', 'form', 'pillow', 'dining_room', 'nightstand', 'wall', 'basket_for_clothes', 'photoframe', 'tray', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'clothes_dress', 'table', 'soap', 'washing_machine', 'creditcard'] 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:['sheets', 'pot', 'food_pizza', 'food_salt', 'freezer', 'drawing', 'knife', 'cpuscreen', 'knifeblock', 'floor', 'character', 'bookshelf', 'laptop', 'plate', 'mousepad', 'candle', 'dining_room', 'wall', 'light_bulb', 'food_food', 'coffe_maker', 'tray', 'kitchen_counter', 'chessboard', 'dishrack', 'shoes', 'cupboard', 'laundry_detergent', 'dishwasher', 'instrument_violin'] Task:Wash dishes with dishwasher response: | { I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I 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:['food_salt', 'chair', 'blow_dryer', 'nail_polish', 'ground_coffee', 'milk', 'knife', 'wallshelf', 'hanger', 'character', 'desk', 'keyboard', 'stovefan', 'mat', 'plate', 'food_jam', 'nightstand', 'wall', 'toy', 'bed', 'coffe_maker', 'wine', 'rag', 'centerpiece', 'pencil', 'dresser', 'door', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Read book response: { thoughts : Pick up the book, open to current page, read the words., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['spectacles', 'scissors', 'microwave', 'walllamp', 'nail_polish', 'detergent', 'blow_dryer', 'orchid', 'hanger', 'bathroom_counter', 'character', 'desk', 'stamp', 'computer', 'stereo', 'mousepad', 'pillow', 'powersocket', 'toy', 'check', 'food_food', 'television', 'oven_mitts', 'curtain', 'shaving_cream', 'pencil', 'cd', 'cupboard', 'instrument_guitar', 'soap'] Task:Listen to music response: | { Find radio, turn it on } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'freezer', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'microphone', 'pillow', 'wall', 'wall_clock', 'nightstand', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'home_office', 'table', 'soap'] Task:Relax on sofa response: { thoughts : go to the living room and sit on the couch, ease into the sofa and relax., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['glue', 'crayon', 'chair', 'cat', 'dough', 'milk', 'hanger', 'floor', 'keyboard', 'mail', 'table_cloth', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'couch', 'form', 'dining_room', 'cutting_board', 'photoframe', 'check', 'wine', 'dresser', 'hairbrush', 'pajamas', 'conditioner', 'home_office', 'bathroom_cabinet', 'table'] 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:['scissors', 'blender', 'tablelamp', 'ground_coffee', 'bathroom', 'toothbrush', 'drawing', 'knife', 'orchid', 'desk', 'keyboard', 'brush', 'shower', 'homework', 'food_jam', 'pillow', 'dining_room', 'bowl', 'wall_clock', 'check', 'television', 'toothbrush_holder', 'tray', 'kettle', 'kitchen_counter', 'maindoor', 'sink', 'clothes_skirt', 'tooth_paste', 'dirt'] Task:Wash teeth response: { 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:['toilet', 'freezer', 'drawing', 'knifeblock', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'shower', 'picture', 'window', 'food_noodles', 'food_jam', 'wall', 'powersocket', 'oven', 'photoframe', 'check', 'television', 'toothbrush_holder', 'water', 'curtain', 'doorjamb', 'kitchen_counter', 'cd', 'headset', 'door', 'bathroom_cabinet', 'light', 'soap'] 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:['tablelamp', 'freezer', 'walllamp', 'detergent', 'drawing', 'knife', 'wallshelf', 'hanger', 'floor', 'ceiling', 'computer', 'mop_bucket', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'couch', 'clothes_hat', 'pillow', 'wall', 'box', 'photoframe', 'bed', 'coffe_maker', 'television', 'coin', 'doorjamb', 'door', 'sink'] Task:Relax on sofa response: { thoughts : walk to living room ,find sofa ,sit on sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['water_glass', 'food_salt', 'microwave', 'chair', 'jelly', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'toaster', 'tvstand', 'faucet', 'shower', 'closetdrawer', 'candle', 'food_orange', 'wall', 'cup', 'oven_mitts', 'water', 'doorjamb', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'creditcard'] 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:['microwave', 'toilet', 'dog', 'toothbrush', 'bills', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'purse', 'faucet', 'balanceball', 'food_noodles', 'wall', 'bench', 'cup', 'photoframe', 'mouthwash', 'console', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : go to bathroom. walk to sink,turn on faucet, put hands in water. rub hands together. grab soap. rub soap in hands. put soap down. put hands under water. rubs hands together. turn off faucet, actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['pot', 'microwave', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'character', 'stamp', 'keyboard', 'toaster', 'plate', 'faucet', 'tvstand', 'bowl', 'wall', 'oven', 'photoframe', 'coffe_maker', 'food_food', 'ice', 'curtain', 'shaving_cream', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher'] Task:Wash dishes with dishwasher response: | { Walk to the kitchen. Open the dishwasher and turn on the faucet. Rinse off the dishes. Put the dishes in the dishwasher. Put detergent in 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:['filing_cabinet', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'purse', 'mail', 'computer', 'laptop', 'deck_of_cards', 'faucet', 'foundation', 'mousepad', 'wall', 'wall_clock', 'bench', 'cup', 'doorjamb', 'mouse', 'door', 'light', 'table'] Task:Sent email response: { thoughts : Walk into home office. Sit down in a chair at a desk. Turn on laptop. Bring up the internet. Go to gmail website. Begin composing an email. Hit the send button., actions : ['[WALK] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <laptop>'] } Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'cd_player', 'chair', 'walllamp', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'envelope', 'mail', 'button', 'toaster', 'ceilinglamp', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'nightstand', 'wall', 'video_game_controller', 'television', 'doorjamb', 'kitchen_counter', 'headset', 'hair', 'door', 'sink'] 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:['toilet', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'centerpiece', 'mouse', 'shoes', 'dresser', 'door', 'maindoor', 'sink', 'light', 'table', 'soap'] Task:Browse internet response: { thoughts : go to the office, turn computer on, open an browser or any application to open any website., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <computer>'] } Scene_Objects:['pot', 'measuring_cup', 'microwave', 'toilet', 'dog', 'bathroom', 'knifeblock', 'bills', 'bathroom_counter', 'floor', 'table_cloth', 'toaster', 'plate', 'faucet', 'couch', 'towel', 'wall', 'bed', 'oven_mitts', 'water', 'shaving_cream', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher', 'soap', 'hands_both'] Task:Wash hands response: | { Walk to kitchen. Find sink. Walk to sink. Find soap. Put soap on sink. Pour water into hands. Scrub soap. Wash 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:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'wallshelf', 'cpuscreen', 'floor', 'shampoo', 'mop_bucket', 'toaster', 'mat', 'plate', 'shower', 'dish_soap', 'closetdrawer', 'dining_room', 'wall', 'photoframe', 'coffe_maker', 'colander', 'pencil', 'kitchen_counter', 'cupboard', 'clothes_dress', 'food_steak', 'home_office', 'dishwasher', 'soap', 'tooth_paste'] Task:Wash dishes with dishwasher response: { thoughts : Go to the kitchen. Find the dishwasher. Open the dishwasher. Find the plates. Load the plates into the dishwasher. Find the soap. Load the soap into the dishwasher. Close the dishwasher. Turn on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'cat', 'drawing', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'bookshelf', 'computer', 'food_bacon', 'bookmark', 'brush', 'mat', 'mousepad', 'clothes_hat', 'wall', 'nightstand', 'powersocket', 'wall_clock', 'cup', 'oven_mitts', 'doorjamb', 'door', 'sink', 'light'] Task:Turn on light response: | { push any ligth button to turn it on, for example in the living room } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'crayon', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'door', 'clothes_scarf', 'light'] Task:Re arrange office response: { thoughts : Walk in.Turn on light.Move furniture. Change the room, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[PUSH] <desk>', '[WALK] <chair>', '[PUSH] <chair>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <filing_cabinet>', '[PUSH] <filing_cabinet>'] } Scene_Objects:['dry_pasta', 'juice', 'food_ice_cream', 'microwave', 'knifeblock', 'orchid', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'ceilinglamp', 'laptop', 'faucet', 'stereo', 'couch', 'wall', 'toy', 'cup', 'coin', 'ice', 'wine', 'curtain', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'clothes_dress', 'sink', 'instrument_guitar', 'light'] Task:Drink response: | { Drink water from a 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:['filing_cabinet', 'toilet', 'chair', 'freezer', 'trashcan', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'window', 'closetdrawer', 'clothes_pants', 'wall', 'bed', 'coffe_maker', 'television', 'tray', 'towel_rack', 'dresser', 'cupboard', 'hair', 'bathtub', 'sink', 'home_office', 'table', 'bathroom_cabinet', '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:['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: | { 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', 'water_glass', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'stovefan', 'mat', 'shower', 'closetdrawer', 'couch', 'wall', 'powersocket', 'oven', 'food_food', 'check', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light'] Task:Drink response: { thoughts : walk to kitchen ,find fridge ,open fridge ,find water glass , drink from water glass, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['dry_pasta', 'fork', 'filing_cabinet', 'chair', 'cat', 'drawing', 'hanger', 'floor', 'character', 'tea_bag', 'mat', 'picture', 'electric_shaver', 'couch', 'food_jam', 'towel', 'dining_room', 'wall', 'oven', 'coffe_maker', 'tray', 'curtain', 'doorjamb', 'diary', 'cards', 'cupboard', 'door', 'bathroom_cabinet', 'light', 'tooth_paste'] Task:Read book response: | { pick up the book open the book and read } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'photoframe', 'food_food', 'television', 'after_shave', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet'] Task:Watch TV response: { thoughts : Turn on tv. Sit with kids., actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[FIND] <child>', '[GREET] <child>', '[FIND] <child>', '[GREET] <child>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'orchid', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'button', 'tvstand', 'stereo', 'window', 'closetdrawer', 'couch', 'candle', 'clothes_hat', 'pillow', 'nightstand', 'wall', 'cup', 'television', 'oven_mitts', 'curtain', 'centerpiece', 'coffee_pot', 'dresser', 'table', 'instrument_violin'] Task:Change TV channel response: | { Walk into the Living room. Find the television remote. Use it to turn on the television. Point the remote at the television. Press the channel button on the remote. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'microwave', 'chair', 'walllamp', 'bathroom', 'detergent', 'bathroom_counter', 'button', 'toaster', 'brush', 'stereo', 'shower', 'faucet', 'food_orange', 'pillow', 'oven', 'photoframe', 'check', 'television', 'tray', 'kettle', 'mouse', 'cupboard', 'conditioner', 'door', 'home_office', 'table', 'dishwasher', 'clothes_skirt', 'soap'] Task:Listen to music response: { thoughts : Walk into living room, look for radio, grab on button, actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>'] } Scene_Objects:['fork', 'pot', 'filing_cabinet', 'chair', 'blow_dryer', 'ceiling', 'character', 'tea_bag', 'keyboard', 'piano_bench', 'ceilinglamp', 'mousepad', 'closetdrawer', 'dustpan', 'pillow', 'television', 'coffee_filter', 'drinking_glass', 'water', 'wine', 'curtain', 'pencil', 'vacuum_cleaner', 'controller', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'clothes_scarf'] Task:Drink response: | { I walk to the kitchen. Take a glass out of the cabinet. Then I walk to the sink and turn the water on and fill the glass. Then I take a drink. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'trashcan', 'floor', 'tea_bag', 'thread', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'wall', 'bed', 'coffe_maker', 'food_food', 'check', 'oven_mitts', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'hairbrush', 'cupboard', 'hair', 'controller', 'bathroom_cabinet', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['sheets', 'tea', 'chair', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'plate', 'mousepad', 'couch', 'clothes_hat', 'wall', 'nightstand', 'cup', 'food_food', 'check', 'coffe_maker', 'after_shave', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'hairdryer', 'table'] Task:Read book response: | { go to living room,find the text book on the self ,sat on the chair ,open and read the book } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'beer', 'toilet', 'chair', 'ceilingfan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'folder', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'couch', 'microphone', 'wall', 'bench', 'light_bulb', 'television', 'curtain', 'food_steak', 'sink', 'napkin', 'home_office', 'table'] Task:Watch TV response: { thoughts : I walk into my living room, find the remote and sit on my sofa. I look at the remote and switch on the television. I look at the Television., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['pot', 'mop', 'microwave', 'band-aids', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'phone', 'desk', 'clothes_jacket', 'toaster', 'faucet', 'picture', 'couch', 'clothes_hat', 'dining_room', 'wall', 'cup', 'coffe_maker', 'mouthwash', 'drinking_glass', 'kettle', 'kitchen_counter', 'paper_towel', 'cupboard', 'controller', 'laundry_detergent', 'sink', 'dishwasher'] Task:Wash dishes with dishwasher response: | { wipe loose dirt, place in 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:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'soap'] Task:Work response: { thoughts : I go to my home office, sit on the chair and turn on the computer. I open my email account to look for all the information I need.I pull up my online task on the computer to look at what the assigned task is., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'tea', 'knifeblock', 'cpuscreen', 'folder', 'bedroom', 'table_cloth', 'toaster', 'plate', 'homework', 'oil', 'closetdrawer', 'powersocket', 'tape', 'bed', 'novel', 'coffe_maker', 'television', 'razor', 'wine', 'doorjamb', 'shoes', 'dishrack', 'headset', 'cupboard', 'hairdryer', 'light', 'shoe_rack'] Task:Listen to music response: | { walk into living room, walk to stereo, turn on stereo, listen to music } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'fork', 'filing_cabinet', 'tablelamp', 'blender', 'mop', 'bathroom', 'detergent', 'toothbrush', 'bills', 'hanger', 'floor', 'bedroom', 'envelope', 'toaster', 'stovefan', 'clothes_socks', 'mousepad', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'toilet_paper', 'towel_rack', 'clothes_dress', 'bag', 'home_office', 'light', 'vase', 'soap', 'washing_machine'] Task:Wash clothes response: { thoughts : Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine., actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['filing_cabinet', 'ground_coffee', 'walllamp', 'knife', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bedroom', 'button', 'stovefan', 'mat', 'shower', 'clothes_socks', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'bed', 'light_bulb', 'check', 'video_game_controller', 'mouthwash', 'food_onion', 'vacuum_cleaner', 'pajamas', 'cupboard', 'hair', 'instrument_guitar'] Task:Go to sleep response: | { 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:['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', 'chair', 'drawing', 'floor', 'bedroom', 'bookshelf', 'stovefan', 'ceilinglamp', 'plate', 'dish_soap', 'towel', 'pillow', 'wall', 'cup', 'bed', 'food_food', 'check', 'coffe_maker', 'television', 'doorjamb', 'console', 'kitchen_counter', 'cupboard', 'door', 'clothes_scarf', 'table', 'dishwasher', 'clothes_skirt', 'soap', 'board_game'] 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:['chair', 'dough', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'tvstand', 'stereo', 'mousepad', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'sink', 'bathtub', 'light'] Task:Listen to music response: { thoughts : I go to the bedroom and sit at my desk. I turn my radio on and listen to music., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['fork', 'filing_cabinet', 'chair', 'dog', 'toothbrush', 'drawing', 'bills', 'ceiling', 'folder', 'desk', 'bedroom', 'remote_control', 'button', 'clothes_jacket', 'stovefan', 'mat', 'faucet', 'dining_room', 'broom', 'nightstand', 'wall', 'cutting_board', 'novel', 'mouse', 'kitchen_counter', 'cd', 'pajamas', 'sink', 'bathroom_cabinet', 'home_office'] 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:['filing_cabinet', 'tea', 'chair', 'freezer', 'bathroom', 'trashcan', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'bedroom', 'computer', 'plate', 'stereo', 'window', 'food_kiwi', 'wall', 'nightstand', 'box', 'bed', 'clothes_gloves', 'coffe_maker', 'wooden_spoon', 'curtain', 'shoes', 'dishwasher', 'creditcard'] Task:Listen to music response: { thoughts : I go into my bedroom and see my stereo. I decide to play music. I walk over to the stereo and turn it on. I sit down on the bed to listen to the music., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[SIT] <bed>'] } 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: | { Robot Drinks the water } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'shaving_cream', 'mouse', 'dresser', 'door'] Task:Browse internet response: { thoughts : switch on the computer, grab a chair and sit in front of the computer. type with keyboard and browse the internet., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['juice', 'toilet', 'freezer', 'band-aids', 'ground_coffee', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'mat', 'shower', 'couch', 'food_jam', 'wall', 'pasta', 'powersocket', 'oven', 'novel', 'coffe_maker', 'food_food', 'check', 'curtain', 'doorjamb', 'door', 'napkin', 'light', 'table', 'clothes_skirt'] Task:Go to toilet response: | { Travel through the house and locate the bathroom, and proceed to the toilet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'phone', 'dvd_player', 'character', 'bedroom', 'ceilinglamp', 'balanceball', 'iron', 'window', 'couch', 'food_orange', 'wall', 'tape', 'cup', 'basket_for_clothes', 'check', 'wooden_spoon', 'console', 'mouse', 'kitchen_counter', 'hairbrush', 'food_steak', 'sink', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Wash hands with soap, actions : ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>'] } Scene_Objects:['spectacles', 'tablelamp', 'toilet', 'bathroom', 'knifeblock', 'drawing', 'cpuscreen', 'orchid', 'hanger', 'floor', 'bedroom', 'bookshelf', 'mop_bucket', 'stovefan', 'mat', 'homework', 'electric_shaver', 'clothes_socks', 'closetdrawer', 'food_orange', 'pillow', 'bowl', 'basket_for_clothes', 'cup', 'coffe_maker', 'tray', 'shaving_cream', 'cupboard', 'sink', 'board_game'] Task:Pet cat response: | { Find Cat in living room. Walk to cat. 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:['sheets', 'tea', 'chair', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'plate', 'mousepad', 'couch', 'clothes_hat', 'wall', 'nightstand', 'cup', 'food_food', 'check', 'coffe_maker', 'after_shave', 'rag', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'hairdryer', 'table'] Task:Read book response: { thoughts : go to living room,find the text book on the self ,sat on the chair ,open and read the book, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'foundation', 'homework', 'closetdrawer', 'couch', 'pillow', 'broom', 'nightstand', 'wall', 'oven', 'light_bulb', 'television', 'curtain', 'dresser', 'bathroom_cabinet', 'table', 'dishwasher', 'creditcard'] Task:Watch TV response: | { I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'dvd_player', 'character', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'electric_shaver', 'mousepad', 'couch', 'form', 'wall', 'nightstand', 'clothes_gloves', 'television', 'curtain', 'headset', 'maindoor', 'table', 'clothes_shirt'] Task:Watch TV response: { thoughts : Walk to Living room. Find Television. Walk to sofa. Sit on sofa. Find Remote. Grab remote. Turn to television. Look at television. Switch on Television., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>'] } Scene_Objects:['water_glass', 'food_pizza', 'chair', 'drawing', 'food_egg', 'hanger', 'floor', 'phone', 'ceiling', 'mail', 'table_cloth', 'stovefan', 'ceilinglamp', 'stereo', 'homework', 'couch', 'microphone', 'form', 'food_orange', 'bowl', 'oven', 'box', 'newspaper', 'tray', 'kitchen_counter', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'shoe_rack'] Task:Drink response: | { walk to kitchen, walk to table, grab water glass 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:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'bathroom', 'milk', 'floor', 'bookshelf', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'bench', 'oven', 'toy', 'cutting_board', 'shelf', 'cup', 'standingmirror', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'console', 'pencil', 'comb', 'sink', 'home_office', 'scrabble'] Task:Pick up toys response: { thoughts : Grab toys off floor. Put it in a container., actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>'] } Scene_Objects:['dry_pasta', 'pot', 'food_pizza', 'toilet', 'chair', 'freezer', 'walllamp', 'food_butter', 'drawing', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'toaster', 'nightstand', 'wall', 'powersocket', 'oven', 'pasta', 'box', 'food_cheese', 'photoframe', 'food_food', 'wooden_spoon', 'food_onion', 'tray', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'door', 'light', 'table', 'dishwasher'] Task:Cook some food response: | { Walk to the kitchen and open the fridge. From the fridge take some chicken and close the fridge. Walk to the table and put the chicken on the table. Plug in oven and put the chicken into the oven. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'couch', 'wall', 'nightstand', 'toy', 'photoframe', 'curtain', 'rag', 'doorjamb', 'mouse', 'dresser', 'door', 'light'] Task:Browse internet response: { thoughts : walk into Living room, look for computer, walk to computer, turn on computer, grab mouse, click mouse, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[TURNTO] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>'] } Scene_Objects:['microwave', 'board_game', 'chair', 'ground_coffee', 'detergent', 'knifeblock', 'floor', 'ceiling', 'alcohol', 'toaster', 'faucet', 'picture', 'closetdrawer', 'couch', 'dining_room', 'broom', 'wall', 'coffe_maker', 'check', 'water', 'drinking_glass', 'after_shave', 'rag', 'kitchen_counter', 'shoes', 'cupboard', 'hair', 'sink', 'table', 'tooth_paste'] Task:Drink response: | { Walk to kitchen. Walk to faucet. Switch on faucet. Pour water into drinking glass. Switch off faucet. 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:['sponge', 'microwave', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'folder', 'desk', 'alcohol', 'stovefan', 'plate', 'mousepad', 'wall', 'oven', 'food_food', 'check', 'tray', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'sink', 'clothes_scarf', 'light', 'clothes_shirt', 'teeth'] Task:Pick up phone response: { thoughts : walk over and pick up the phone, actions : ['[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'mousepad', 'closetdrawer', 'microphone', 'pillow', 'wall', 'bed', 'television', 'razor', 'doorjamb', 'kettle', 'mouse', 'address_book', 'door', 'light', 'table', 'dishwasher'] Task:Work response: | { Walk to home office. Walk to computer. Switch on computer. Open the address book. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'toaster', 'ceilinglamp', 'window', 'floor_lamp', 'couch', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'comb', 'door', 'bathtub', 'bathroom_cabinet', 'coffee'] Task:Turn on light response: { thoughts : Turning on lights, actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'detergent', 'cat', 'food_butter', 'knife', 'phone', 'character', 'table_cloth', 'mat', 'deck_of_cards', 'stereo', 'form', 'pillow', 'dining_room', 'nightstand', 'wall', 'basket_for_clothes', 'photoframe', 'tray', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'clothes_dress', 'table', 'soap', 'washing_machine', 'creditcard'] Task:Wash clothes response: | { Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'pot', 'fork', 'scissors', 'food_ice_cream', 'microwave', 'walllamp', 'knifeblock', 'knife', 'wallshelf', 'floor', 'ceiling', 'phone', 'alcohol', 'clothes_jacket', 'toaster', 'stovefan', 'faucet', 'couch', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'rag', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'colander'] Task:Clean response: { thoughts : Take out a rag. Turn on faucet and get water on the rag. Clean counter off., actions : ['[WALK] <dining_room>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <rag> <sink>', '[SWITCHOFF] <faucet>', '[GRAB] <rag>', '[SQUEEZE] <rag>', '[WALK] <kitchen_counter>', '[WIPE] <kitchen_counter>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['glue', 'toilet', 'freezer', 'wallshelf', 'hanger', 'bathroom_counter', 'bookshelf', 'mail', 'brush', 'mat', 'shoe-shine_kit', 'homework', 'closetdrawer', 'couch', 'food_orange', 'towel', 'dining_room', 'wall', 'powersocket', 'box', 'novel', 'check', 'coffe_maker', 'tray', 'doorjamb', 'diary', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap'] Task:Read book response: | { Pick up the book, open to current page, read the words. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'dog', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'envelope', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'pasta', 'nightstand', 'bench', 'photoframe', 'tray', 'mouse', 'door', 'table', 'soap'] Task:Work response: { thoughts : go to home office. turn the computer on. begin working, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['sheets', 'filing_cabinet', 'mop', 'bathroom', 'food_egg', 'clothes_underwear', 'bathroom_counter', 'phone', 'ceiling', 'computer', 'toaster', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'clothes_pants', 'food_orange', 'food_kiwi', 'basket_for_clothes', 'coffe_maker', 'television', 'curtain', 'mouse', 'cd', 'comb', 'clothes_dress', 'clothes_skirt', 'soap', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: | { I need to get the dirty clothes basket. Walk to bathroom. Put all the clothes in washing machine. Add soap. Turn on machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'television', 'doorjamb', 'mouse', 'hairdryer', 'door', 'sink', 'home_office', 'table'] Task:Work response: { thoughts : Using desktop computer in home office, actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['fork', 'food_bread', 'scissors', 'microwave', 'jelly', 'detergent', 'toothbrush', 'drawing', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'envelope', 'shower', 'faucet', 'window', 'candle', 'pillow', 'wall', 'tape', 'keys', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'sink', 'light'] Task:Pick up phone response: | { I walk over to the phone and pick it up. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['tablelamp', 'chair', 'walllamp', 'cat', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'couch', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'box', 'food_food', 'television', 'coffee_pot', 'kettle', 'cards', 'mouse', 'home_office', 'dishwasher'] Task:Pet cat response: | { I walk to the living room. I locate the cat. I walk to the couch and sit down beside the cat. I pet the cat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'crayon', 'chair', 'cat', 'dough', 'milk', 'hanger', 'floor', 'keyboard', 'mail', 'table_cloth', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'couch', 'form', 'dining_room', 'cutting_board', 'photoframe', 'check', 'wine', 'dresser', 'hairbrush', 'pajamas', 'conditioner', 'home_office', 'bathroom_cabinet', 'table'] Task:Give milk to cat response: { thoughts : Grab milk and pour it into the plate so that the cat can drink, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[POINTAT] <cat>', '[PULL] <cat>', '[FIND] <milk>', '[GRAB] <milk>', '[FIND] <plate>', '[POUR] <milk> <plate>', '[TOUCH] <cat>', '[SCRUB] <cat>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'ground_coffee', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'toaster', 'plate', 'faucet', 'foundation', 'mousepad', 'food_jam', 'food_kiwi', 'wall', 'pasta', 'powersocket', 'food_food', 'coffe_maker', 'rag', 'shaving_cream', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'dishwasher'] Task:Wash dishes with dishwasher response: | { Take a dish and put it in the dishwasher to be washed } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'tvstand', 'faucet', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'food_orange', 'wall', 'powersocket', 'shelf', 'food_food', 'oven_mitts', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'vacuum_cleaner', 'dresser', 'light', 'table'] Task:Turn on light response: { thoughts : approach the light switch, raise hand to the switch, flip the switch, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'floor', 'ceiling', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'basket_for_clothes', 'food_food', 'check', 'television', 'tray', 'curtain', 'dresser', 'door', 'home_office', 'table', 'clothes_shirt', 'coffee'] Task:Watch TV response: | { I walk to the living room. I reach for the remote. I push the on button on the remote. I sit down on the couch and watch television. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'water_glass', 'microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'wallshelf', 'bookshelf', 'clothes_jacket', 'toaster', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'dining_room', 'nightstand', 'wall', 'wall_clock', 'powersocket', 'basket_for_clothes', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'console', 'dishrack', 'hairdryer', 'door', 'bathtub'] Task:Drink response: { thoughts : Drink water, actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['pot', 'chair', 'walllamp', 'knife', 'desk', 'bookshelf', 'button', 'clothes_jacket', 'stovefan', 'deck_of_cards', 'mousepad', 'closetdrawer', 'oil', 'towel', 'pillow', 'broom', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'television', 'wine', 'curtain', 'after_shave', 'cards', 'home_office', 'light', 'clothes_skirt', 'soap', 'washing_machine'] Task:Wash clothes response: | { walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn 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:['pot', 'filing_cabinet', 'freezer', 'blow_dryer', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'picture', 'iron', 'mousepad', 'bowl', 'wall', 'powersocket', 'bench', 'photoframe', 'toilet_paper', 'coffe_maker', 'toothbrush_holder', 'tray', 'doorjamb', 'dishrack', 'sink', 'bathroom_cabinet', 'home_office', 'light'] Task:Get toilet paper response: { thoughts : There are extra toilet papers in the bottom cabinet., actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>'] } 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: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['freezer', 'bathroom', 'detergent', 'cat', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'form', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'coffee_filter', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'controller', 'door', 'light', 'coffee'] Task:Put groceries in Fridge response: { thoughts : I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['fork', 'tea', 'jelly', 'dog', 'chair', 'ground_coffee', 'bathroom', 'phone', 'bedroom', 'stovefan', 'mat', 'plate', 'faucet', 'shoe-shine_kit', 'wall', 'nightstand', 'powersocket', 'cup', 'basket_for_clothes', 'newspaper', 'food_food', 'coffe_maker', 'tray', 'curtain', 'food_steak', 'door', 'bag', 'instrument_guitar', 'light', 'dishwasher'] Task:Set up table response: | { Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['dog', 'freezer', 'bathroom', 'food_carrot', 'knifeblock', 'food_egg', 'hanger', 'floor', 'phone', 'stovefan', 'mat', 'plate', 'stereo', 'dish_soap', 'food_noodles', 'closetdrawer', 'mousepad', 'dustpan', 'cup', 'food_food', 'coffe_maker', 'check', 'oven_mitts', 'water', 'food_rice', 'curtain', 'mouse', 'hairbrush', 'sink', 'home_office'] Task:Wash dishes by hand response: | { walk to kitchen, fins soap, arrange dishes, wash 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:['tablelamp', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'bathroom_counter', 'bookshelf', 'keyboard', 'computer', 'button', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mousepad', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'curtain', 'shoes', 'cd', 'vacuum_cleaner', 'dresser', 'cupboard', 'clothes_dress', 'home_office', 'table', 'shoe_rack'] Task:Take off shoes response: { thoughts : Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area., actions : ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PULL] <shoes>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PULL] <shoes>', '[WALK] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['pot', 'tablelamp', 'scissors', 'food_ice_cream', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'stamp', 'piano_bench', 'ceilinglamp', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'check', 'television', 'toothbrush_holder', 'curtain', 'diary', 'vacuum_cleaner', 'sink', 'home_office', 'light', 'dishwasher'] Task:Relax on sofa response: | { walk to living room, walk to 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:['filing_cabinet', 'tablelamp', 'beer', 'jelly', 'bills', 'food_egg', 'hanger', 'floor', 'phone', 'ceiling', 'dvd_player', 'mat', 'window', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'wall', 'cutting_board', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'hair', 'table', 'soap', 'clothes_shirt'] Task:Relax on sofa response: { thoughts : Go to living room. Find sofa. Sit on sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'dog', 'detergent', 'needle', 'hanger', 'floor', 'ceiling', 'envelope', 'table_cloth', 'ceilinglamp', 'broom', 'wall', 'cutting_board', 'photoframe', 'bed', 'coffe_maker', 'check', 'coffee_filter', 'water', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'controller', 'table', 'dishwasher', 'clothes_skirt', 'coffee'] Task:Make coffee response: | { I find the coffee machine, fill it with water and coffee then press the button to make the coffee } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'bed', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Work response: { thoughts : Type on a computer in the home office., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['tablelamp', 'walllamp', 'food_carrot', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'remote_control', 'computer', 'button', 'stovefan', 'tvstand', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'newspaper', 'toilet_paper', 'television', 'tray', 'curtain', 'mouse', 'dresser', 'sink', 'bathroom_cabinet', 'table'] Task:Change TV channel response: | { I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['pot', 'tablelamp', 'toilet', 'freezer', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'character', 'desk', 'food_cake', 'toaster', 'ceilinglamp', 'couch', 'pillow', 'powersocket', 'basket_for_clothes', 'cup', 'newspaper', 'food_food', 'check', 'oven_mitts', 'wooden_spoon', 'centerpiece', 'kitchen_counter', 'door', 'light'] Task:Pick up phone response: | { I walk to the home office, find where the phone is and lift the reciever. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'microwave', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'bills', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'folder', 'stovefan', 'tvstand', 'window', 'homework', 'wall', 'oven', 'powersocket', 'cutting_board', 'basket_for_clothes', 'food_cheese', 'clothes_gloves', 'check', 'television', 'toothbrush_holder', 'curtain', 'bathroom_cabinet', 'laser_pointer'] Task:Open window response: { thoughts : Unlock the latch at the top. Push the bottom half of the window upwards., actions : ['[WALK] <home_office>', '[WALK] <window>', '[OPEN] <window>'] } Scene_Objects:['sheets', 'fork', 'pot', 'tablelamp', 'measuring_cup', 'freezer', 'detergent', 'cat', 'bathroom_counter', 'keyboard', 'purse', 'bookshelf', 'toaster', 'brush', 'faucet', 'stereo', 'homework', 'toy', 'box', 'basket_for_clothes', 'coin', 'curtain', 'rag', 'centerpiece', 'dishrack', 'clothes_dress', 'bag', 'table', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: | { Walk to the kitchen. Find the washing machine. Open the washing machine. Find the basket for clothes. Find the clothes_dress. Grab the clothes_dress. Put the clothes_dress into the washing machine. Find the clothes_shirt. Grab the clothes_shirt. Put the clothes_shirt into the washing machine. Close the washing machine. Switch on the washing machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'freezer', 'drawing', 'knifeblock', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'shower', 'picture', 'window', 'food_noodles', 'food_jam', 'wall', 'powersocket', 'oven', 'photoframe', 'check', 'television', 'toothbrush_holder', 'water', 'curtain', 'doorjamb', 'kitchen_counter', 'cd', 'headset', 'door', 'bathroom_cabinet', 'light', 'soap'] Task:Take shower response: { thoughts : go to a bathroom, open the shower, let water wash your body, actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'computer', 'mat', 'shoe-shine_kit', 'oil', 'pillow', 'wall', 'pasta', 'powersocket', 'cup', 'food_food', 'video_game_controller', 'toothbrush_holder', 'television', 'doorjamb', 'kettle', 'door', 'light', 'clothes_skirt', 'coffee'] Task:Turn on light response: | { switching on light in an area } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'ground_coffee', 'knifeblock', 'hanger', 'floor', 'ceiling', 'purse', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'wall', 'cup', 'razor', 'coin', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher'] Task:Drink response: { thoughts : To go kitchen and find a cup. open the faucet and fill water in the cup and drink., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <cup>', '[GRAB] <cup>', '[TURNTO] <faucet>', '[POINTAT] <faucet>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>'] } Scene_Objects:['tablelamp', 'tea', 'measuring_cup', 'walllamp', 'orchid', 'floor', 'ceiling', 'bookshelf', 'computer', 'tvstand', 'window', 'electric_shaver', 'oil', 'closetdrawer', 'couch', 'mousepad', 'pillow', 'nightstand', 'wall', 'tape', 'bed', 'television', 'curtain', 'rag', 'mouse', 'shoes', 'dresser', 'cupboard', 'controller', 'table'] Task:Watch TV response: | { Watch TV in the living room. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'scissors', 'food_ice_cream', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'stamp', 'piano_bench', 'ceilinglamp', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'check', 'television', 'toothbrush_holder', 'curtain', 'diary', 'vacuum_cleaner', 'sink', 'home_office', 'light', 'dishwasher'] Task:Relax on sofa response: { thoughts : walk to living room, walk to sofa, sit on sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['pot', 'food_ice_cream', 'microwave', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'food_egg', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'toaster', 'shower', 'faucet', 'oil', 'food_kiwi', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'food_food', 'oven_mitts', 'tray', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'light', 'dishwasher'] Task:Cook some food response: | { Walk into kitchen. Open fridge. Take food from fridge. Close fridge. Put food on kitchen counter. Prepare food. Turn on stove. Open kitchen cabinet. Take pot. Close cabinet. Put food in pot. Put pot on stove. Cook food. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'character', 'video_game_console', 'bedroom', 'computer', 'button', 'table_cloth', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'box', 'video_game_controller', 'television', 'curtain', 'pencil', 'dresser', 'door', 'table'] Task:Play games response: { thoughts : Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video game remote controller., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['pot', 'tea', 'chair', 'detergent', 'toothbrush', 'orchid', 'knifeblock', 'cpuscreen', 'kitchen_cabinet', 'floor', 'phone', 'bedroom', 'keyboard', 'ceilinglamp', 'faucet', 'window', 'dish_soap', 'food_jam', 'food_orange', 'pillow', 'wall', 'oven', 'bed', 'novel', 'coffe_maker', 'kitchen_counter', 'dishrack', 'cupboard', 'table', 'dishwasher'] Task:Wash dishes with dishwasher response: | { I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'floor', 'ceiling', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'basket_for_clothes', 'food_food', 'check', 'television', 'tray', 'curtain', 'dresser', 'door', 'home_office', 'table', 'clothes_shirt', 'coffee'] Task:Watch TV response: { thoughts : I walk to the living room. I reach for the remote. I push the on button on the remote. I sit down on the couch and watch television., actions : ['[WALK] <home_office>', '[WALK] <button>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['tablelamp', 'chair', 'jelly', 'bathroom', 'knife', 'dvd_player', 'character', 'bedroom', 'thread', 'computer', 'toaster', 'shoe-shine_kit', 'deck_of_cards', 'shower', 'electric_shaver', 'homework', 'food_peanut_butter', 'form', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'novel', 'light_bulb', 'food_food', 'curtain', 'coffee_pot', 'food_steak', 'door', 'light'] Task:Listen to music response: | { Go to the living room. Find the radio. Turn on the radio. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : Find the playback device you want to listen to. turn on. press play. enjoyu music., actions : ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>'] } Scene_Objects:['scissors', 'mop', 'bathroom', 'food_egg', 'wallshelf', 'clothes_underwear', 'character', 'bookshelf', 'food_cake', 'button', 'bookmark', 'laptop', 'mat', 'iron', 'wall', 'powersocket', 'television', 'console', 'mouse', 'shoes', 'pajamas', 'cupboard', 'door', 'hairdryer', 'home_office', 'light', 'bathroom_cabinet', 'soap', 'laser_pointer', 'washing_machine'] Task:Wash clothes response: | { Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'ground_coffee', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'doorjamb', 'mouse', 'pencil', 'dresser', 'sink', 'light', 'table'] Task:Work response: { thoughts : I go to the home office to work on my project. I turn on the light and walk to my desk. I turn on the computer. Then I look through the documents. After I'm done, I turn off the computer., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[TURNTO] <check>', '[LOOKAT] <check>', '[SWITCHOFF] <computer>'] } Scene_Objects:['tablelamp', 'food_oatmeal', 'toilet', 'freezer', 'food_carrot', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'stamp', 'food_cake', 'computer', 'mat', 'shower', 'food_cereal', 'wall', 'nightstand', 'powersocket', 'food_vegetable', 'photoframe', 'newspaper', 'food_food', 'coffe_maker', 'doorjamb', 'pencil', 'door', 'bathroom_cabinet', 'light', 'scrabble'] Task:Put groceries in Fridge response: | { Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'microwave', 'toilet', 'ground_coffee', 'blow_dryer', 'orchid', 'wallshelf', 'bathroom_counter', 'character', 'desk', 'bookshelf', 'alcohol', 'computer', 'ceilinglamp', 'laptop', 'faucet', 'pillow', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'cup', 'television', 'oven_mitts', 'after_shave', 'doorjamb', 'diary', 'towel_rack', 'cards', 'maindoor'] Task:Pet cat response: { thoughts : Walk to living room. Find cat. Walk to cat. Pull cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[PULL] <cat>'] } Scene_Objects:['sheets', 'toilet', 'bathroom', 'bills', 'orchid', 'cpuscreen', 'floor', 'phone', 'character', 'bedroom', 'piano_bench', 'toaster', 'mat', 'ceilinglamp', 'window', 'foundation', 'electric_shaver', 'oil', 'closetdrawer', 'couch', 'broom', 'nightstand', 'wall', 'cup', 'bed', 'check', 'toothbrush_holder', 'sink', 'napkin', 'dishwasher'] Task:Go to sleep response: | { Enter bedroom, turn on the light, and shut door. Change into night clothes. Turn off light. Turn down comforter, climb into bed, lay head on pillow, and cover up with comforter. Close eyes and drift off to sleep. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['crayon', 'microwave', 'toilet', 'freezer', 'ground_coffee', 'longboard', 'shampoo', 'character', 'thread', 'food_bacon', 'piano_bench', 'balanceball', 'stereo', 'window', 'picture', 'mousepad', 'pillow', 'toy', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'oven_mitts', 'colander', 'doorjamb', 'shaving_cream', 'dresser', 'soap', 'washing_machine', 'creditcard'] Task:Wash clothes response: { thoughts : walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on, actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[WALK] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['water_glass', 'tablelamp', 'toilet', 'chair', 'walllamp', 'detergent', 'cat', 'knife', 'cpuscreen', 'floor', 'ceiling', 'mail', 'toaster', 'ceilinglamp', 'stovefan', 'stereo', 'homework', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'tape', 'newspaper', 'photoframe', 'food_food', 'television', 'water', 'tray', 'bathroom_cabinet'] Task:Drink response: | { GOING TO DRINK WATER IN KITCHEN } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tea', 'chair', 'freezer', 'cpuscreen', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'stovefan', 'mousepad', 'wall', 'keys', 'check', 'oven_mitts', 'doorjamb', 'mouse', 'pencil', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'napkin', 'home_office', 'light'] Task:Turn on light response: { thoughts : turn on the light for room, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[SWITCHON] <light>', '[FIND] <chair>', '[SIT] <chair>'] } Scene_Objects:['tablelamp', 'beer', 'toilet', 'freezer', 'bathroom', 'drawing', 'floor', 'ceiling', 'character', 'computer', 'table_cloth', 'mat', 'shower', 'window', 'food_orange', 'broom', 'nightstand', 'wall', 'powersocket', 'basket_for_clothes', 'photoframe', 'bed', 'food_food', 'doorjamb', 'hairbrush', 'controller', 'door', 'sink', 'napkin', 'light'] Task:Cook some food response: | { Go kitchen and make something for eat } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'bathroom', 'toothbrush', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'computer', 'button', 'toaster', 'mat', 'stereo', 'foundation', 'window', 'couch', 'bench', 'oven', 'cup', 'check', 'television', 'tray', 'dresser', 'home_office', 'light', 'bathroom_cabinet'] Task:Listen to music response: { thoughts : Walk into living room, look for radio, grab on button, actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>'] } Scene_Objects:['sheets', 'glue', 'chair', 'milk', 'toothbrush', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'alcohol', 'mop_bucket', 'table_cloth', 'mat', 'faucet', 'homework', 'clothes_socks', 'closetdrawer', 'teeth', 'mousepad', 'wall', 'powersocket', 'doorjamb', 'shaving_cream', 'sink', 'bathroom_cabinet', 'light', 'hands_both'] Task:Wash hands response: | { I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_pants', 'form', 'pillow', 'towel', 'wall', 'powersocket', 'bench', 'newspaper', 'television', 'curtain', 'doorjamb', 'mouse', 'hair', 'door', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Watch TV response: { thoughts : SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['glue', 'food_bread', 'filing_cabinet', 'scissors', 'knife', 'character', 'stamp', 'bookshelf', 'keyboard', 'bookmark', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'food_noodles', 'towel', 'tape', 'check', 'mouthwash', 'television', 'wooden_spoon', 'tray', 'kettle', 'kitchen_counter', 'cd', 'laundry_detergent', 'sink', 'light', 'soap', 'instrument_violin'] Task:Wash hands response: | { I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'dresser', 'door', 'home_office'] Task:Vacuum response: { thoughts : Keep my keyboard vacuumed and free of debris., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>'] } Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'chair', 'walllamp', 'knifeblock', 'hanger', 'floor', 'ceiling', 'food_bacon', 'toaster', 'ceilinglamp', 'oil', 'closetdrawer', 'couch', 'food_jam', 'pillow', 'wall', 'nightstand', 'newspaper', 'television', 'coin', 'lighter', 'laundry_detergent', 'napkin', 'home_office', 'dishwasher', 'soap', 'laser_pointer'] Task:Relax on sofa response: | { walk to living room, find sofa, sit in sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'television', 'curtain', 'doorjamb', 'cd', 'pajamas', 'door', 'table', 'light', 'dishwasher'] Task:Watch TV response: { thoughts : Sitting on the couch watching my favorite television show., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['water_glass', 'blender', 'food_salt', 'chair', 'walllamp', 'nail_polish', 'bathroom', 'milk', 'drawing', 'wallshelf', 'clothes_underwear', 'bathroom_counter', 'floor', 'character', 'stamp', 'envelope', 'button', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'closetdrawer', 'form', 'coffe_maker', 'water', 'mouse', 'dresser', 'hairbrush', 'cupboard', 'table'] Task:Drink response: | { walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'bed', 'coin', 'curtain', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'light'] Task:Wipe down baseboards please response: { thoughts : Use a rag to get all the dust off the baseboards please., actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <wall>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['pot', 'microwave', 'chair', 'walllamp', 'detergent', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'stovefan', 'toaster', 'faucet', 'dining_room', 'wall', 'pasta', 'oven', 'cup', 'food_cheese', 'keys', 'coffe_maker', 'water', 'tray', 'centerpiece', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'clothes_shirt'] Task:Drink response: | { Walk to kitchen, walk to cupboard, open cupboard, grab cup, walk to sink, pour water in cup, drink water. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'scissors', 'walllamp', 'orchid', 'needle', 'clothes_underwear', 'dvd_player', 'character', 'desk', 'mop_bucket', 'table_cloth', 'brush', 'ceilinglamp', 'mat', 'stereo', 'dining_room', 'nightstand', 'powersocket', 'toy', 'shelf', 'check', 'toothbrush_holder', 'mouse', 'chessboard', 'dresser', 'laundry_detergent', 'home_office', 'bathroom_cabinet', 'teeth', 'creditcard'] Task:Put toys away response: { thoughts : Pick up all the toys on the floor and put them in their correct storage bin or shelf., actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>'] } Scene_Objects:['sheets', 'pot', 'crayon', 'toilet', 'chair', 'freezer', 'milk', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'brush', 'mat', 'shower', 'nightstand', 'wall', 'powersocket', 'tape', 'food_cheese', 'photoframe', 'food_food', 'check', 'doorjamb', 'cupboard', 'controller', 'door', 'clothes_scarf', 'light', 'table'] Task:Put groceries in Fridge response: | { I pick up groceries. I open fridge. I put groceries in the fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['beer', 'walllamp', 'drawing', 'orchid', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'nightstand', 'powersocket', 'keys', 'television', 'curtain', 'doorjamb', 'door', 'sink', 'table'] Task:Watch movie response: { thoughts : Sit down on couch in front of TV. Use remote to turn on the TV, 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:['sheets', 'scissors', 'toilet', 'band-aids', 'food_carrot', 'dough', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'folder', 'bedroom', 'shoe-shine_kit', 'closetdrawer', 'food_orange', 'nightstand', 'wall', 'powersocket', 'coin', 'shaving_cream', 'pencil', 'cupboard', 'sink', 'napkin', 'instrument_guitar', 'bathroom_cabinet', 'soap', 'scrabble', 'washing_machine'] Task:Wash clothes response: | { I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'water_glass', 'pot', 'freezer', 'walllamp', 'bathroom', 'food_butter', 'food_carrot', 'milk', 'knifeblock', 'knife', 'floor', 'ceiling', 'mail', 'computer', 'stovefan', 'ceilinglamp', 'brush', 'faucet', 'wall', 'nightstand', 'cutting_board', 'cup', 'photoframe', 'water', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'soap'] Task:Drink response: { thoughts : I enter the kitchen and grab a waterglass from the cupboard. I open the fridge and grap some water. I pour the water into the cup and drink it., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[OPEN] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['food_ice_cream', 'microwave', 'toilet', 'chair', 'knifeblock', 'hanger', 'floor', 'toaster', 'stovefan', 'shoe-shine_kit', 'faucet', 'homework', 'food_noodles', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'cup', 'newspaper', 'coffee_filter', 'food_rice', 'console', 'mouse', 'kitchen_counter', 'dishrack', 'comb', 'cupboard', 'door', 'sink'] Task:Drink response: | { go to the kitchen, walk to the cabinet, pic up a glass. carry the glass to the sink. turn on the water and fill up the glass. drink the water. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'table_cloth', 'bookmark', 'mat', 'shower', 'faucet', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'oven', 'keys', 'coffe_maker', 'television', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'hairdryer', 'bathroom_cabinet', 'light', 'home_office'] Task:Turn on light response: { thoughts : I open the room door and press the light button on, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table'] Task:Write an email response: | { I go to the home office to find the computer. I turn switch computer on , i open the email. i write the email and send it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'freezer', 'ceilingfan', 'dough', 'milk', 'knifeblock', 'bills', 'floor', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'mop_bucket', 'ceilinglamp', 'microphone', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'light_bulb', 'food_food', 'coffe_maker', 'tray', 'curtain', 'shaving_cream', 'controller', 'door', 'maindoor', 'dirt'] Task:Put groceries in Fridge response: { thoughts : Go to kitchen and put groceries in fridge, actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'floor', 'ceiling', 'keyboard', 'food_cake', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'stereo', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'cup', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'food_steak', 'bathroom_cabinet', 'light', 'dishwasher'] Task:Relax on sofa response: | { I sit on the sofa. I put my legs on the sofa and recline. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'crayon', 'microwave', 'walllamp', 'knifeblock', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'purse', 'toaster', 'faucet', 'shower', 'homework', 'pillow', 'wall', 'oven', 'water', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'soap', 'teeth'] Task:Wash hands response: { thoughts : walk to kitchen, turn on water, find soap, apply to hand, lather, rinse, dry hands, actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[FIND] <water>', '[RINSE] <water>'] } Scene_Objects:['scissors', 'chair', 'ground_coffee', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'keyboard', 'mat', 'tvstand', 'plate', 'pillow', 'wall', 'nightstand', 'bed', 'coffe_maker', 'television', 'coffee_filter', 'razor', 'tray', 'kitchen_counter', 'cupboard', 'hairdryer', 'home_office', 'light', 'dishwasher', 'table', 'dirt'] Task:Make coffee response: | { Make coffee in the kitchen. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'milk', 'floor', 'ceiling', 'desk', 'keyboard', 'button', 'mop_bucket', 'toaster', 'stereo', 'window', 'wall', 'powersocket', 'bench', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'food_sugar', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'coffee_cup', 'dishwasher', 'light', 'clothes_shirt'] Task:Make coffee response: { thoughts : walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[LOOKAT] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <milk>', '[GRAB] <milk>', '[PUTBACK] <milk> <coffe_maker>', '[FIND] <food_sugar>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>'] } Scene_Objects:['sheets', 'pot', 'blender', 'chair', 'bathroom', 'hanger', 'floor', 'tea_bag', 'food_cake', 'food_bacon', 'piano_bench', 'mat', 'plate', 'dish_soap', 'mousepad', 'closetdrawer', 'couch', 'clothes_socks', 'wall', 'powersocket', 'coffe_maker', 'curtain', 'console', 'kitchen_counter', 'cupboard', 'door', 'sink', 'napkin', 'dishwasher', 'colander'] Task:Wash dishes with dishwasher response: | { I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'band-aids', 'toothbrush', 'orchid', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'faucet', 'picture', 'shower', 'mousepad', 'candle', 'food_orange', 'oven', 'basket_for_clothes', 'bed', 'check', 'food_food', 'television', 'tray', 'after_shave', 'headset', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'bathroom_cabinet'] Task:Sit in chair response: { thoughts : I sit in a chair to rest and eat., actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>'] } Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'food_carrot', 'orchid', 'floor', 'ceiling', 'shampoo', 'bedroom', 'remote_control', 'computer', 'button', 'ceilinglamp', 'tvstand', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'pasta', 'oven', 'novel', 'television', 'curtain', 'pencil', 'dresser', 'sink', 'table'] Task:Change TV channel response: | { walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'detergent', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'purse', 'toaster', 'mat', 'faucet', 'iron', 'mousepad', 'wall', 'powersocket', 'cup', 'coffe_maker', 'water', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'clothes_scarf', 'colander'] Task:Drink response: { thoughts : I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>'] } Scene_Objects:['food_salt', 'microwave', 'walllamp', 'bathroom', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'shoe-shine_kit', 'faucet', 'window', 'mousepad', 'couch', 'wall', 'oven', 'newspaper', 'coffe_maker', 'food_food', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'light'] Task:Pick up phone response: | { Walk to living room. Go near telephone. take the receiver and then talk to other person on that side. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'crayon', 'chair', 'walllamp', 'toothbrush', 'wallshelf', 'dvd_player', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'mousepad', 'couch', 'form', 'pillow', 'bowl', 'nightstand', 'wall_clock', 'bench', 'oven', 'powersocket', 'clothes_gloves', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'hairdryer', 'bathtub', 'home_office', 'table'] Task:Write an email response: { thoughts : I go to my bed room and sit on the chair and in front of me is my desktop computer and start writing an email., actions : ['[WALK] <bathroom>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['filing_cabinet', 'toilet', 'band-aids', 'freezer', 'food_carrot', 'toothbrush', 'orchid', 'floor', 'mail', 'button', 'faucet', 'foundation', 'oil', 'pillow', 'towel', 'food_food', 'toothbrush_holder', 'doorjamb', 'lighter', 'kettle', 'headset', 'cd', 'dresser', 'hairbrush', 'controller', 'napkin', 'light', 'dishwasher', 'tooth_paste', 'teeth'] Task:Brush teeth response: | { walk to bathroom, look at the toothbrush holder, take toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now brush teeth } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'dog', 'cpuscreen', 'keyboard', 'ceilinglamp', 'plate', 'laptop', 'faucet', 'window', 'stereo', 'oil', 'food_noodles', 'mousepad', 'dining_room', 'nightstand', 'food_food', 'check', 'wine', 'curtain', 'after_shave', 'comb', 'dresser', 'napkin', 'home_office', 'table', 'bathroom_cabinet', 'light'] Task:Listen to music response: { thoughts : I reach out arm. I put hand on radio. I turn on radio. I pick a station., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[TOUCH] <stereo>', '[TURNTO] <stereo>'] } Scene_Objects:['sheets', 'detergent', 'orchid', 'wallshelf', 'floor', 'ceiling', 'tea_bag', 'stovefan', 'toaster', 'faucet', 'shower', 'foundation', 'tooth_paste', 'closetdrawer', 'candle', 'nightstand', 'cup', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'tray', 'curtain', 'rag', 'clothes_scarf', 'table', 'soap', 'instrument_violin', 'dirt', 'hands_both'] Task:Wash hands response: | { Wash hands with soap } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'crayon', 'microwave', 'chair', 'freezer', 'detergent', 'food_egg', 'hanger', 'floor', 'ceiling', 'toaster', 'plate', 'shower', 'mousepad', 'broom', 'wall', 'pasta', 'keys', 'novel', 'coffe_maker', 'toothbrush_holder', 'coffee_filter', 'wooden_spoon', 'towel_rack', 'controller', 'maindoor', 'sink', 'dishwasher', 'coffee', 'creditcard'] Task:Make coffee response: { thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[PUTBACK] <coffee> <coffe_maker>'] } Scene_Objects:['tablelamp', 'chair', 'toothbrush', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'food_noodles', 'form', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'keys', 'toothbrush_holder', 'rag', 'doorjamb', 'sink', 'bathroom_cabinet', 'instrument_guitar', 'dishwasher', 'tooth_paste', 'teeth'] Task:Wash teeth response: | { I walk in to the bathroom. I turn on the faucet. I find the toothbrush and toothpaste. I grab the toothbrush and toothpaste. I rinse off the toothbrush. I add toothpaste to the toothbrush. I put back the toothpaste. I wash my teeth with the toothbrush. I rinse off the toothbrush. I put the toothbrush back. I rinse my mouth out. I turn the faucet off. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'tablelamp', 'beer', 'measuring_cup', 'band-aids', 'woman', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'ceiling', 'character', 'desk', 'man', 'thread', 'clothes_jacket', 'tvstand', 'stereo', 'faucet', 'window', 'shower', 'couch', 'form', 'cutting_board', 'novel', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'instrument_violin'] 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:['toilet', 'freezer', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'mat', 'deck_of_cards', 'shower', 'tvstand', 'food_jam', 'dining_room', 'wall', 'nightstand', 'powersocket', 'food_cheese', 'photoframe', 'novel', 'food_food', 'toilet_paper', 'coffe_maker', 'food_donut', 'doorjamb', 'kitchen_counter', 'dresser', 'door', 'light', 'tooth_paste', 'coffee'] Task:Put groceries in Fridge response: | { in my home i walk to the kitchen with some groceries and locate the fridge,then open the fridge put the groceries into the fridge and closed. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'bed', 'coin', 'curtain', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'light'] Task:Wipe down baseboards please response: { thoughts : Use a rag to get all the dust off the baseboards please., actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <wall>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['dry_pasta', 'pot', 'food_salt', 'jelly', 'walllamp', 'detergent', 'knife', 'drawing', 'hanger', 'floor', 'dvd_player', 'character', 'desk', 'bedroom', 'plate', 'dish_soap', 'oil', 'wall', 'powersocket', 'bed', 'light_bulb', 'coffe_maker', 'toilet_paper', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'dishwasher'] Task:Wash dishes with dishwasher response: | { Put dishes in the dishwasher and start the dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_salt', 'beer', 'microwave', 'chair', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'floor', 'computer', 'stovefan', 'mat', 'balanceball', 'faucet', 'window', 'couch', 'candle', 'wall', 'toy', 'bed', 'photoframe', 'coffe_maker', 'video_game_controller', 'wooden_spoon', 'curtain', 'dresser', 'pajamas', 'hair', 'maindoor'] Task:Go to sleep response: { thoughts : go to bedroom, put pajamas on, lie in bed, sleep, actions : ['[WALK] <bedroom>', '[WALK] <pajamas>', '[FIND] <pajamas>', '[GRAB] <pajamas>', '[PUTON] <pajamas>', '[FIND] <bed>', '[LIE] <bed>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'bathroom', 'orchid', 'floor', 'ceiling', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'food_peanut_butter', 'pillow', 'bowl', 'dining_room', 'nightstand', 'wall', 'powersocket', 'cup', 'check', 'television', 'curtain', 'dresser', 'cupboard', 'home_office', 'table', 'dishwasher'] Task:Watch TV response: | { Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'blender', 'microwave', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'keyboard', 'toaster', 'laptop', 'stereo', 'window', 'food_peanut_butter', 'dining_room', 'broom', 'nightstand', 'oven', 'cup', 'photoframe', 'bed', 'television', 'after_shave', 'curtain', 'pencil', 'bathroom_cabinet', 'light', 'dishwasher', 'vase'] Task:Clean response: { thoughts : Clean the welcome mat, actions : ['[WALK] <home_office>', '[WALK] <vacuum_cleaner>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>'] } Scene_Objects:['tablelamp', 'scissors', 'chair', 'dough', 'wallshelf', 'hanger', 'phone', 'tea_bag', 'bookshelf', 'thread', 'stovefan', 'mat', 'tvstand', 'faucet', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'oven', 'cup', 'food_donut', 'centerpiece', 'mouse', 'vacuum_cleaner', 'chessboard', 'laundry_detergent', 'sink', 'home_office', 'washing_machine', 'creditcard'] Task:Wash clothes response: | { Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'juice', 'microwave', 'toilet', 'walllamp', 'orchid', 'bathroom_counter', 'bookshelf', 'bookmark', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'wall_clock', 'food_food', 'coffe_maker', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'cupboard', 'bathtub', 'home_office', 'bathroom_cabinet'] Task:Drink response: { thoughts : Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass., actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['filing_cabinet', 'food_salt', 'cat', 'cpuscreen', 'desk', 'bookshelf', 'computer', 'alcohol', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'stereo', 'shower', 'closetdrawer', 'candle', 'basket_for_clothes', 'photoframe', 'food_food', 'check', 'television', 'water', 'curtain', 'lighter', 'doorjamb', 'vacuum_cleaner', 'cupboard', 'home_office', 'table', 'bathroom_cabinet'] Task:Drink response: | { Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'nail_polish', 'detergent', 'orchid', 'drawing', 'hanger', 'floor', 'phone', 'desk', 'button', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'dining_room', 'nightstand', 'wall_clock', 'oven', 'cup', 'photoframe', 'bed', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office'] Task:Listen to music response: { thoughts : I go into the living room and turn on the radio. Then, I select the station I want, which is usually a preset., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['spectacles', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'stereo', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'powersocket', 'cup', 'toilet_paper', 'television', 'after_shave', 'rag', 'doorjamb', 'coffee_pot', 'dishrack', 'instrument_guitar', 'table', 'soap', 'laser_pointer'] Task:Relax on sofa response: | { walk to living room, walk to sofa, sit in sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'tablelamp', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'envelope', 'toaster', 'ceilinglamp', 'stereo', 'faucet', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'clothes_gloves', 'novel', 'check', 'video_game_controller', 'television', 'kitchen_counter', 'hairdryer', 'light', 'table'] Task:Relax on sofa response: { thoughts : Walk to the living room. Walk to the sofa and sit on the sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['filing_cabinet', 'tea', 'microwave', 'cd_player', 'freezer', 'band-aids', 'bathroom', 'food_carrot', 'orchid', 'music_stand', 'phone', 'bookshelf', 'thread', 'mail', 'stereo', 'homework', 'mousepad', 'closetdrawer', 'clothes_hat', 'form', 'broom', 'newspaper', 'photoframe', 'check', 'food_rice', 'food_donut', 'dresser', 'sink', 'napkin', 'light'] Task:Listen to music response: | { Walk to the living and turn to the music stand. Switch on the CD player to listen to music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'glue', 'chair', 'walllamp', 'ceilingfan', 'knife', 'orchid', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'balanceball', 'mousepad', 'clothes_socks', 'bowl', 'wall', 'check', 'television', 'mouse', 'kitchen_counter', 'cd', 'door', 'light', 'soap'] Task:Pick up phone response: { thoughts : When the phone rings, I pick up the call and give response to the call., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['juice', 'toilet', 'chair', 'freezer', 'detergent', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'bedroom', 'piano_bench', 'ceilinglamp', 'mat', 'shower', 'faucet', 'oil', 'food_orange', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'check', 'doorjamb', 'vacuum_cleaner', 'door', 'table', 'light'] Task:Put groceries in Fridge response: | { Put the groceries on the table into the fridge } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : Pick up phone, actions : ['[WALK] <table>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>'] } Scene_Objects:['sponge', 'filing_cabinet', 'food_ice_cream', 'microwave', 'chair', 'food_carrot', 'wallshelf', 'food_egg', 'cpuscreen', 'hanger', 'shampoo', 'phone', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'microphone', 'pillow', 'nightstand', 'bed', 'rag', 'cards', 'shoes', 'pajamas', 'door', 'sink', 'home_office', 'light'] Task:Change TV channel response: | { I walk to the living room. I find the TV remote. I change the channel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'button', 'brush', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'standingmirror', 'coffe_maker', 'television', 'food_rice', 'wine', 'curtain', 'doorjamb', 'diary', 'pencil', 'door', 'bathroom_cabinet', 'table'] Task:Change TV channel response: { thoughts : walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[GRAB] <button>'] } Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'food_ice_cream', 'hanger', 'floor', 'ceiling', 'character', 'bookshelf', 'mat', 'tvstand', 'faucet', 'ceilinglamp', 'wall', 'powersocket', 'photoframe', 'clothes_gloves', 'bed', 'food_food', 'check', 'ice', 'doorjamb', 'pencil', 'kitchen_counter', 'laundry_detergent', 'door', 'napkin', 'home_office', 'light', 'dishwasher'] Task:Turn on light response: | { switching on the light } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'filing_cabinet', 'food_pizza', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'brush', 'toaster', 'tvstand', 'balanceball', 'window', 'food_noodles', 'mousepad', 'food_peanut_butter', 'clothes_hat', 'dining_room', 'pasta', 'bench', 'photoframe', 'oven_mitts', 'ice', 'rag', 'dresser', 'cupboard', 'food_steak', 'maindoor', 'table'] Task:Clean mirror response: { thoughts : GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR, 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>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['sponge', 'filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'ground_coffee', 'knifeblock', 'hanger', 'floor', 'ceiling', 'purse', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'wall', 'cup', 'razor', 'coin', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher'] Task:Drink response: | { To go kitchen and find a cup. open the faucet and fill water in the cup and drink. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'freezer', 'trashcan', 'orchid', 'drawing', 'bills', 'wallshelf', 'cpuscreen', 'knife', 'ceiling', 'character', 'stamp', 'keyboard', 'computer', 'ceilinglamp', 'couch', 'pillow', 'pasta', 'bench', 'oven', 'keys', 'novel', 'mouthwash', 'ice', 'tray', 'towel_rack', 'mouse', 'cupboard', 'bathtub'] Task:Change TV channel response: { thoughts : I walk to the living room. I find the TV remote. I change the channel., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>'] } Scene_Objects:['fork', 'tablelamp', 'chair', 'walllamp', 'detergent', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'check', 'television', 'tray', 'wooden_spoon', 'kettle', 'controller', 'food_steak', 'sink'] Task:Relax on sofa response: | { go to the living room and sit on the couch, ease into the sofa and relax. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'scissors', 'tablelamp', 'food_ice_cream', 'toilet', 'bathroom', 'toothbrush', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceilinglamp', 'faucet', 'clothes_socks', 'closetdrawer', 'tape', 'cup', 'check', 'food_food', 'razor', 'food_onion', 'centerpiece', 'mouse', 'dresser', 'bathtub', 'bathroom_cabinet', 'light', 'clothes_skirt', 'tooth_paste', 'shoe_rack'] Task:Brush teeth response: { thoughts : EARLY MORNING AND BEFORE GOING TO BED, actions : ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>'] } Scene_Objects:['tablelamp', 'scissors', 'walllamp', 'bathroom', 'orchid', 'floor', 'ceiling', 'remote_control', 'computer', 'tvstand', 'faucet', 'window', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'nightstand', 'wall', 'cup', 'check', 'mouthwash', 'television', 'coffee_filter', 'curtain', 'after_shave', 'dresser', 'hairbrush', 'sink', 'table', 'board_game'] Task:Watch TV response: | { Walk into living room. Sit on couch. Pick up remote. Turn on TV. Watch TV. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'chair', 'walllamp', 'trashcan', 'food_carrot', 'clothes_underwear', 'hanger', 'longboard', 'floor', 'ceiling', 'toaster', 'electric_shaver', 'couch', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'food_food', 'television', 'cards', 'mouse', 'kitchen_counter', 'maindoor', 'home_office', 'light', 'dishwasher', 'coffee'] Task:Make coffee response: { thoughts : Making coffee, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['microwave', 'bathroom', 'cat', 'food_carrot', 'toothbrush', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'mat', 'faucet', 'closetdrawer', 'couch', 'form', 'wall', 'novel', 'coffe_maker', 'wine', 'kettle', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'light', 'table', 'soap', 'hands_both'] Task:Wash hands response: | { Washing Hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : I prepare meals and cook them on the stove., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[CLOSE] <freezer>', '[FIND] <oven>', '[SWITCHON] <oven>', '[SWITCHOFF] <oven>'] } Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'homework', 'foundation', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'bed', 'novel', 'check', 'television', 'doorjamb', 'mouse', 'door', 'sink', 'light', 'table', 'dishwasher'] Task:Work response: | { Find a PC and do homework } |
Subsets and Splits