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:['sheets', 'food_pizza', 'chair', 'cat', 'drawing', 'floor', 'tea_bag', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'stovefan', 'window', 'couch', 'food_orange', 'wall', 'food_food', 'television', 'oven_mitts', 'food_onion', 'curtain', 'after_shave', 'comb', 'napkin', 'home_office', 'table', 'dishwasher', 'bathroom_cabinet', 'laser_pointer', 'scrabble'] Task:Relax on sofa response: { thoughts : go to the living room,find the sofa,sat down in the sofa,take some relaxation., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['pot', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'toy', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'pencil', 'dresser', 'sink', 'board_game'] Task:Watch TV response: | { Walk to living room, walk to TV, grab TV remote, turn on TV, put down the remote, walk to sofa, sit in soft, watch TV } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'juice', 'microwave', 'toilet', 'freezer', 'ceiling', 'clothes_jacket', 'table_cloth', 'toaster', 'stovefan', 'plate', 'faucet', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'table'] Task:Get out dish response: { thoughts : Open cupboard. Get out the dish., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[OPEN] <cupboard>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <cupboard>'] } Scene_Objects:['glue', 'toilet', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'mail', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cutting_board', 'photoframe', 'bed', 'television', 'doorjamb', 'dishrack', 'dresser', 'door', 'dishwasher'] Task:Watch TV response: | { go to the living room to watch TV } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'cat', 'ceilingfan', 'food_butter', 'drawing', 'longboard', 'floor', 'ceiling', 'shampoo', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'couch', 'clothes_pants', 'wall', 'wall_clock', 'bench', 'television', 'curtain', 'kettle', 'towel_rack', 'hair', 'pajamas', 'maindoor', 'home_office', 'table', 'vase'] Task:Change TV channel response: { thoughts : Changing channel, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[DROP] <remote_control>'] } Scene_Objects:['fork', 'tablelamp', 'tea', 'drawing', 'wallshelf', 'hanger', 'ceiling', 'tea_bag', 'bookshelf', 'stovefan', 'toaster', 'mat', 'faucet', 'floor_lamp', 'mousepad', 'nightstand', 'box', 'bed', 'photoframe', 'novel', 'food_food', 'coffee_filter', 'food_donut', 'wine', 'after_shave', 'curtain', 'doorjamb', 'clothes_dress', 'conditioner', 'sink'] Task:Read book response: | { Turn a light on and read a book in the bedroom. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'bathroom', 'detergent', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'video_game_console', 'keyboard', 'stovefan', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall_clock', 'oven', 'bed', 'coffe_maker', 'video_game_controller', 'television', 'doorjamb', 'cd', 'cupboard', 'door', 'bathtub', 'bathroom_cabinet', 'light', 'home_office', 'table'] Task:Playing video game response: { thoughts : Playing video games on various video game systems such as wii u and xbox, actions : ['[WALK] <home_office>', '[WALK] <video_game_console>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[PUTOBJBACK] <video_game_controller>', '[SWITCHOFF] <video_game_console>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>'] } Scene_Objects:['sheets', 'tablelamp', 'microwave', 'walllamp', 'milk', 'clothes_underwear', 'character', 'bedroom', 'keyboard', 'clothes_socks', 'candle', 'clothes_pants', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'bed', 'food_food', 'curtain', 'diary', 'shoes', 'headset', 'laundry_detergent', 'sink', 'home_office', 'table', 'colander', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: | { I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. 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:['spectacles', 'sponge', 'food_bread', 'blender', 'chair', 'walllamp', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'tvstand', 'window', 'mousepad', 'clothes_socks', 'wall', 'oven', 'cup', 'television', 'mouse', 'cupboard', 'door', 'home_office', 'table'] 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', 'food_salt', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'tape', 'photoframe', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser'] Task:Watch TV response: | { walk to living room, find the television, switch on the television, find the sofa, walk to sofa, sit in sofa, watch the television } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'scissors', 'crayon', 'chair', 'walllamp', 'knifeblock', 'bills', 'wallshelf', 'bathroom_counter', 'phone', 'ceiling', 'bedroom', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'dining_room', 'nightstand', 'oven', 'television', 'tray', 'curtain', 'towel_rack', 'door', 'bathtub', 'napkin', 'bag'] Task:Read book response: { thoughts : walk to living room ,find a book ,open the book ,read the book, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['pot', 'microwave', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'character', 'stovefan', 'mat', 'tvstand', 'faucet', 'shower', 'clothes_pants', 'towel', 'wall', 'nightstand', 'powersocket', 'oven', 'light_bulb', 'tray', 'curtain', 'rag', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher'] Task:Take shower response: | { Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'mat', 'ceilinglamp', 'tvstand', 'homework', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Work response: | { I walk to the office. I push the on button on the computer. I sit down in the chair. I work on the computer. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'light'] Task:Work response: | { you go into your office, switch on the light, find chair at desk, sit in the chair, switch on the computer and work. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'orchid', 'hanger', 'ceiling', 'keyboard', 'piano_bench', 'tvstand', 'shower', 'electric_shaver', 'clothes_socks', 'couch', 'wall', 'powersocket', 'bench', 'cutting_board', 'toy', 'photoframe', 'bed', 'razor', 'wooden_spoon', 'after_shave', 'coffee_pot', 'dresser', 'clothes_dress', 'bathtub', 'bathroom_cabinet', 'light', 'clothes_shirt', 'washing_machine', 'shoe_rack'] Task:Wash clothes response: { thoughts : walk to kitchen. grab clothes_dress. look at washing machine. open washing machine. put clothes_dress on washing machine. close washing machine. switch on washing machine. switch off washing machine., actions : ['[WALK] <dining_room>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[TURNTO] <washing_machine>', '[LOOKAT] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>', '[SWITCHOFF] <washing_machine>'] } Scene_Objects:['dry_pasta', 'tablelamp', 'measuring_cup', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'character', 'desk', 'bedroom', 'table_cloth', 'mat', 'shower', 'stereo', 'microphone', 'clothes_hat', 'pillow', 'nightstand', 'wall_clock', 'oven', 'keys', 'light_bulb', 'check', 'razor', 'tray', 'doorjamb', 'dresser', 'clothes_dress', 'bag', 'dishwasher'] 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:['cd_player', 'freezer', 'ground_coffee', 'bathroom', 'milk', 'orchid', 'cpuscreen', 'hanger', 'dvd_player', 'character', 'ceilinglamp', 'stereo', 'faucet', 'dustpan', 'clothes_hat', 'nightstand', 'wall', 'newspaper', 'check', 'mouthwash', 'video_game_controller', 'food_food', 'tray', 'doorjamb', 'pencil', 'cupboard', 'door', 'sink', 'home_office', 'dishwasher'] Task:Listen to music response: { thoughts : I walk in the living room, then I go the the stereo and the cd player and turn them on., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>'] } Scene_Objects:['sponge', 'fork', 'pot', 'sheets', 'food_salt', 'detergent', 'food_butter', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'shampoo', 'desk', 'food_cake', 'mat', 'faucet', 'food_kiwi', 'wall', 'powersocket', 'toy', 'novel', 'food_food', 'curtain', 'dresser', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'hands_both'] Task:Wash hands response: | { Going to the sink and scrubbing hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'bathroom', 'hanger', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'bookshelf', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'closetdrawer', 'couch', 'pillow', 'cup', 'coffe_maker', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'home_office', 'light', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['chair', 'freezer', 'dough', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'bookmark', 'mat', 'faucet', 'shower', 'closetdrawer', 'couch', 'food_peanut_butter', 'microphone', 'pillow', 'towel', 'wall', 'food_food', 'television', 'kitchen_counter', 'cupboard', 'controller', 'door', 'bag', 'light', 'table'] Task:Put groceries in Fridge response: | { walk to kitchen and seprate the groceries and arrange in fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'pencil', 'bathtub', 'home_office', 'table'] Task:Browse internet response: { thoughts : For browsing internet walk to home office. Find Computer. Walk to Computer. Find Chair. Sit in a chair and switch on computer. Connect with internet and browse the net., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>'] } Scene_Objects:['pot', 'juice', 'microwave', 'chair', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'phone', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'stovefan', 'pillow', 'wall', 'oven', 'clothes_gloves', 'coffe_maker', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'dishwasher', 'soap'] Task:Wash dishes by hand response: | { Walk into Kitchen, walk to sink, grab a plate,put soap on sponge,wash plate with sponge, rinse with water, put away plate in cupboard. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'mat', 'plate', 'faucet', 'ceilinglamp', 'dish_soap', 'mousepad', 'couch', 'dining_room', 'wall', 'oven', 'bench', 'basket_for_clothes', 'towel_rack', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'light'] Task:Wash dirty dishes response: { thoughts : Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <sponge> <sink>', '[GRAB] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['filing_cabinet', 'chair', 'band-aids', 'walllamp', 'nail_polish', 'drawing', 'bills', 'wallshelf', 'orchid', 'hanger', 'knife', 'floor', 'ceiling', 'desk', 'alcohol', 'mat', 'foundation', 'closetdrawer', 'couch', 'pillow', 'wall', 'bed', 'novel', 'check', 'oven_mitts', 'rag', 'kitchen_counter', 'dresser', 'bag', 'napkin'] Task:Read book response: | { I go to the book case, I select a book, I go back and sit down, then 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:['sheets', 'tablelamp', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'stereo', 'faucet', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_food', 'food_donut', 'towel_rack', 'mouse', 'shoes', 'dishrack', 'sink', 'spoon', 'light', 'coffee'] Task:Go to toilet response: { thoughts : Walk to bathroom, find toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>'] } Scene_Objects:['pot', 'tablelamp', 'chair', 'cat', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'cutting_board', 'coffee_table', 'novel', 'food_food', 'television', 'towel_rack', 'mouse', 'shoes', 'door', 'light'] Task:Read book response: | { 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:['filing_cabinet', 'tablelamp', 'tea', 'chair', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'powersocket', 'television', 'food_rice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'door', '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:['spectacles', 'filing_cabinet', 'food_salt', 'chair', 'freezer', 'cat', 'orchid', 'knife', 'bathroom_counter', 'ceiling', 'folder', 'purse', 'bookmark', 'ceilinglamp', 'stereo', 'closetdrawer', 'clothes_pants', 'dirt', 'wall', 'food_food', 'wine', 'rag', 'console', 'shaving_cream', 'pencil', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'home_office', 'washing_machine'] 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:['water_glass', 'pot', 'freezer', 'milk', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'alcohol', 'computer', 'toaster', 'shoe-shine_kit', 'faucet', 'pillow', 'dining_room', 'wall', 'cup', 'bed', 'check', 'toilet_paper', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'clothes_dress', 'food_steak', 'sink', 'bathroom_cabinet'] Task:Drink response: { thoughts : I walk into the kitchen. I reach into the cabinet and pick up a water glass. Turn on the faucet and place the glass under the water stream. Bring the glass of water to lips and drink., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[DRINK] <water_glass>'] } Scene_Objects:['measuring_cup', 'tea', 'microwave', 'freezer', 'ground_coffee', 'hanger', 'floor', 'ceiling', 'dvd_player', 'bedroom', 'computer', 'toaster', 'shoe-shine_kit', 'shower', 'picture', 'wall', 'keys', 'coffe_maker', 'check', 'video_game_controller', 'coffee_filter', 'oven_mitts', 'water', 'television', 'after_shave', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher'] 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:['scissors', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'window', 'toaster', 'clothes_pants', 'broom', 'powersocket', 'bench', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'dresser', 'hair', 'door', 'sink', 'clothes_shirt'] Task:Get dressed response: { thoughts : Get some clothes together that make an appropriate outfit. Put them on, actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>'] } Scene_Objects:['pot', 'tablelamp', 'cat', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'ceilinglamp', 'brush', 'faucet', 'stereo', 'tvstand', 'towel', 'pillow', 'wall', 'pasta', 'powersocket', 'coffe_maker', 'oven_mitts', 'tray', 'curtain', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response: | { I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'beer', 'trashcan', 'dough', 'cpuscreen', 'desk', 'keyboard', 'toaster', 'stovefan', 'tvstand', 'shower', 'faucet', 'window', 'oil', 'couch', 'dining_room', 'cutting_board', 'bed', 'food_food', 'television', 'ice', 'doorjamb', 'towel_rack', 'cd', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office'] Task:Pick up phone response: { thoughts : I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>', '[SWITCHON] <phone>'] } Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'comb', 'door', 'light'] Task:Read book response: | { Find book, grab book, fin bookmark, sit down somewhere comfortable, open book, read book, close book after reading. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'bookmark', 'stovefan', 'ceilinglamp', 'mat', 'mousepad', 'oil', 'food_peanut_butter', 'broom', 'wall', 'novel', 'diary', 'mouse', 'cupboard', 'clothes_dress', 'door', 'table', 'light', 'dirt'] Task:Browse internet response: { thoughts : Go to office. Turn on computer. Pull out chair. Sit in chair. Use keyboard and mouse., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>'] } Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'cards', 'dresser', 'door', 'colander'] Task:Change TV channel response: | { I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'sheets', 'filing_cabinet', 'food_bread', 'food_salt', 'microwave', 'chair', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'mail', 'stovefan', 'ceilinglamp', 'mat', 'stereo', 'couch', 'wall', 'powersocket', 'cup', 'check', 'mouthwash', 'food_donut', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'table', 'teeth'] Task:Play games response: { thoughts : I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours., actions : ['[WALK] <home_office>', '[WALK] <board_game>', '[FIND] <board_game>', '[GRAB] <board_game>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <board_game> <table>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mop_bucket', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Change TV channel response: | { its time for my favorite show and im going change with the help of remote control and watch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'detergent', 'ceilingfan', 'drawing', 'needle', 'knifeblock', 'floor', 'ceiling', 'phone', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'bench', 'check', 'television', 'oven_mitts', 'curtain', 'conditioner', 'food_steak', 'home_office', 'table', 'vase', 'clothes_shirt'] Task:Watch TV response: { thoughts : I walk into the living room and sit on the sofa to watch tv, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'measuring_cup', 'toilet', 'drawing', 'needle', 'hanger', 'floor', 'computer', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'bed', 'novel', 'food_food', 'video_game_controller', 'coffe_maker', 'tray', 'food_onion', 'doorjamb', 'lighter', 'cd', 'clothes_dress', 'bathroom_cabinet', 'light', 'soap'] Task:Read book response: | { I would go lie down in my bed and open the book and start reading. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'food_butter', 'floor', 'ceiling', 'stovefan', 'faucet', 'dustpan', 'food_jam', 'wall', 'oven', 'cutting_board', 'newspaper', 'coffe_maker', 'water', 'drinking_glass', 'tray', 'doorjamb', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'home_office', 'bathroom_cabinet', 'clothes_skirt', 'vase', 'scrabble'] Task:Drink response: { thoughts : go to the kitchen, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'tea_bag', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'hair', 'door'] Task:Write an email response: | { I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer 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:['pot', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'toaster', 'mat', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'photoframe', 'coffe_maker', 'food_rice', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'home_office'] Task:Set up table response: { thoughts : Get dishes. Place dishes neatly around table. Get food. Place food on middle of table., actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>'] } Scene_Objects:['sheets', 'filing_cabinet', 'blender', 'toilet', 'jelly', 'chair', 'drawing', 'bathroom_counter', 'floor', 'character', 'food_bacon', 'mat', 'shoe-shine_kit', 'shower', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'pasta', 'oven', 'newspaper', 'check', 'television', 'ice', 'tray', 'doorjamb', 'pencil', 'comb', 'dresser', 'bathroom_cabinet'] Task:Go to toilet response: | { Walk to the bathroom. Pull down pants. Use 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:['chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'toy', 'photoframe', 'bed', 'television', 'doorjamb', 'towel_rack', 'dresser', 'dishwasher', 'shoe_rack'] 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', 'juice', 'toilet', 'freezer', 'bathroom', 'bills', 'orchid', 'shampoo', 'ceiling', 'stamp', 'desk', 'keyboard', 'tvstand', 'couch', 'dustpan', 'dining_room', 'powersocket', 'newspaper', 'check', 'video_game_controller', 'television', 'coffe_maker', 'ice', 'tray', 'doorjamb', 'shoes', 'controller', 'door', 'napkin'] 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:['pot', 'scissors', 'chair', 'drawing', 'needle', 'hanger', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'laptop', 'iron', 'mat', 'deck_of_cards', 'mousepad', 'oil', 'wall', 'basket_for_clothes', 'food_donut', 'food_rice', 'tray', 'curtain', 'doorjamb', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light'] Task:Put on coat response: { thoughts : I remove my scarf from a coat peg in the entrance hall. I wrap the scarf around my neck, actions : ['[WALK] <home_office>', '[WALK] <hanger>', '[TURNTO] <hanger>', '[LOOKAT] <hanger>', '[FIND] <clothes_scarf>', '[GRAB] <clothes_scarf>', '[PUTON] <clothes_scarf>'] } Scene_Objects:['sponge', 'filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'detergent', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'mat', 'microphone', 'pillow', 'nightstand', 'wall', 'powersocket', 'bed', 'novel', 'television', 'doorjamb', 'headset', 'shoes', 'controller', 'door', 'light', 'table'] Task:Read book response: | { Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. Read the book. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : walk to kitchen, fins soap, arrange dishes, wash dishes, actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[FIND] <dish_soap>', '[FIND] <water>', '[GRAB] <plate>', '[GRAB] <dish_soap>', '[WASH] <plate>', '[RINSE] <plate>', '[DROP] <plate>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'chair', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'powersocket', 'television', 'food_rice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'door', 'light'] Task:Turn on light response: | { turn on the light for 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:['microwave', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'phone', 'bookshelf', 'table_cloth', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'cup', 'photoframe', 'check', 'television', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'sink', 'light', 'tooth_paste'] Task:Pet dog response: { thoughts : Pet my dog in hall, actions : ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>'] } Scene_Objects:['pot', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'bed', 'check', 'mouthwash', 'television', 'doorjamb', 'dresser', 'dishwasher'] Task:Watch TV response: | { walk to living room. look at remote control. grab remote control. plug in television. switch on television. lie in sofa. point at remote control. watch television. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'fork', 'filing_cabinet', 'tablelamp', 'chair', 'band-aids', 'floor', 'ceiling', 'stamp', 'alcohol', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'towel', 'wall', 'toy', 'bed', 'keys', 'photoframe', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'dresser', 'cupboard', 'food_steak', 'sink', 'table'] Task:Wash dishes response: { thoughts : Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <plate>', '[PUTOBJBACK] <towel>', '[WALK] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>'] } Scene_Objects:['sheets', 'pot', 'microwave', 'chair', 'freezer', 'food_carrot', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'clothes_jacket', 'table_cloth', 'mat', 'tvstand', 'shower', 'stereo', 'couch', 'pillow', 'wall', 'oven', 'cup', 'food_food', 'television', 'coffee_filter', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'dishwasher'] Task:Cook some food response: | { Walk Into Kitchen. Open Refrigerator. Grab Food. Walk to Microwave. Insert food into microwave. Cook until warm. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dog', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'coin', 'curtain', 'doorjamb', 'coffee_pot', 'door', 'table', 'light'] Task:Watch TV response: { thoughts : I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['chair', 'walllamp', 'drawing', 'knife', 'wallshelf', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'box', 'photoframe', 'television', 'coffee_filter', 'after_shave', 'doorjamb', 'diary', 'kitchen_counter', 'dresser'] Task:Change TV channel response: | { Walk to livingroom, grab remote and change the channel on 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:['scissors', 'freezer', 'walllamp', 'knifeblock', 'wallshelf', 'clothes_underwear', 'ceiling', 'bookshelf', 'keyboard', 'ceilinglamp', 'plate', 'stereo', 'clothes_socks', 'clothes_pants', 'pillow', 'bowl', 'powersocket', 'cutting_board', 'basket_for_clothes', 'razor', 'coin', 'wine', 'curtain', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'laundry_detergent', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: { thoughts : I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on., actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'creditcard'] Task:Browse internet response: | { Walk to the Home office. Sit on the chair. Switch on the computer. Type with keyboard for internet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table'] Task:Change TV channel response: { thoughts : Walk into living room. Find television remote control. Pick up remote control. Press button., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } 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: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'freezer', 'walllamp', 'dough', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'oven', 'cutting_board', 'shelf', 'coffe_maker', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'kitchen_counter', 'maindoor', 'bathtub', 'table'] Task:Drink response: { thoughts : Get a can of beer, open it, sit on couch, relax, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <beer>', '[GRAB] <beer>', '[CLOSE] <freezer>', '[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[DRINK] <beer>'] } 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: | { walk to living room ,find sofa ,sit on sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'foundation', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'napkin', 'light', 'table', 'dirt'] Task:Work response: { thoughts : go to home office. turn the computer on. begin working, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'chair', 'cpuscreen', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'toaster', 'mat', 'stovefan', 'faucet', 'shower', 'mousepad', 'broom', 'wall', 'powersocket', 'cup', 'novel', 'coffe_maker', 'mouthwash', 'tray', 'kitchen_counter', 'cupboard', 'conditioner', 'sink', 'napkin', 'soap'] 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:['pot', 'toilet', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'shampoo', 'stovefan', 'mat', 'shower', 'window', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'newspaper', 'food_food', 'drinking_glass', 'water', 'curtain', 'doorjamb', 'dresser', 'food_steak', 'door', 'home_office', 'light'] Task:Drink response: { thoughts : im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <drinking_glass>', '[DRINK] <drinking_glass>'] } Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'homework', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'keys', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Work response: | { walk to Office,Walk to desk ,sit down in chair, turn on computer, start homework. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'trashcan', 'bills', 'knife', 'floor', 'desk', 'mail', 'button', 'toaster', 'plate', 'faucet', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'nightstand', 'oven', 'bed', 'clothes_gloves', 'novel', 'coffe_maker', 'check', 'tray', 'sink', 'table', 'dishwasher', 'shoe_rack'] Task:Wash dishes with dishwasher response: { thoughts : In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['cd_player', 'freezer', 'ground_coffee', 'bathroom', 'milk', 'orchid', 'cpuscreen', 'hanger', 'dvd_player', 'character', 'ceilinglamp', 'stereo', 'faucet', 'dustpan', 'clothes_hat', 'nightstand', 'wall', 'newspaper', 'check', 'mouthwash', 'video_game_controller', 'food_food', 'tray', 'doorjamb', 'pencil', 'cupboard', 'door', 'sink', 'home_office', 'dishwasher'] Task:Listen to music response: | { I walk in the living room, then I go the the stereo and the cd player and turn them on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'wall', 'powersocket', 'oven', 'coffe_maker', 'television', 'coffee_filter', 'food_rice', 'tray', 'curtain', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'dirt'] Task:Watch TV response: { thoughts : I like to set on my sofa.Turn on the tv. And watch Perry Mason. Monday's through Friday's., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>'] } Scene_Objects:['tablelamp', 'chair', 'dog', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'wall', 'nightstand', 'oven', 'photoframe', 'novel', 'television', 'lighter', 'towel_rack', 'mouse', 'dresser', 'door'] Task:Read book response: | { Reading a book } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_salt', 'microwave', 'drawing', 'orchid', 'wallshelf', 'floor', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'shower', 'faucet', 'dish_soap', 'closetdrawer', 'pillow', 'wall', 'novel', 'coffe_maker', 'food_rice', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : Walk to kitchen. Find dishwasher. Open dishwasher. Find dishrack. Find plate 1. Grab plate 1. Put plate 1 in dishrack. Repeat for dish 2. Find dish soap. Grab dish soap. Put dish soap to dishwasher. Close dishwasher. Switch on dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['pot', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'button', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'iron', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'newspaper', 'food_food', 'television', 'doorjamb', 'dresser', 'conditioner'] 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:['fork', 'chair', 'walllamp', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'candle', 'pillow', 'wall', 'cup', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'bathroom_cabinet', 'teeth'] Task:Watch TV response: { thoughts : SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['sheets', 'water_glass', 'food_salt', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'stovefan', 'mat', 'iron', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'newspaper', 'keys', 'food_food', 'television', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'tooth_paste'] Task:Drink response: | { walk to kitchen ,find fridge ,open fridge ,find water glass , drink from water glass } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'novel', 'television', 'tray', 'curtain', 'dresser', 'bathtub', 'sink', 'bathroom_cabinet', 'coffee_cup', 'table', 'light'] Task:Relax on sofa response: { thoughts : you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[DRINK] <coffee_cup>'] } Scene_Objects:['pot', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'dresser', 'conditioner', 'door', 'table', 'shoe_rack'] Task:Relax on sofa response: | { For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'home_office', 'table', 'light'] Task:Read book response: { thoughts : Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>'] } Scene_Objects:['filing_cabinet', 'toilet', 'bathroom', 'food_butter', 'drawing', 'knife', 'bathroom_counter', 'ceiling', 'phone', 'desk', 'bedroom', 'clothes_jacket', 'faucet', 'shower', 'mousepad', 'couch', 'clothes_pants', 'wall', 'powersocket', 'food_donut', 'tray', 'curtain', 'after_shave', 'pencil', 'vacuum_cleaner', 'clothes_dress', 'sink', 'napkin', 'bathroom_cabinet', 'washing_machine'] Task:Wash clothes response: | { Walk to bathroom, open cabinet and collect clothes and put them into washing machine and wash clothes } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['trashcan', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'folder', 'keyboard', 'remote_control', 'alcohol', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'couch', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'curtain', 'food_steak', 'napkin', 'table', 'clothes_shirt', 'creditcard'] Task:Change TV channel response: { thoughts : Take TV remote to change TV Channel. Press channel/program +/- button on TV remote., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>'] } Scene_Objects:['sponge', 'pot', 'tablelamp', 'microwave', 'hanger', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'mousepad', 'couch', 'candle', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'drinking_glass', 'wooden_spoon', 'curtain', 'tray', 'doorjamb', 'kitchen_counter', 'paper_towel', 'cupboard', 'sink', 'table', 'dishwasher'] Task:Wash dishes with dishwasher response: | { 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:['glue', 'blender', 'microwave', 'toilet', 'bathroom', 'food_carrot', 'milk', 'wallshelf', 'cpuscreen', 'toaster', 'window', 'clothes_socks', 'pillow', 'wall', 'standingmirror', 'food_food', 'mouthwash', 'razor', 'ice', 'rag', 'lighter', 'cards', 'mouse', 'cd', 'hairbrush', 'pajamas', 'dresser', 'laundry_detergent', 'sink', 'light'] Task:Read book response: { thoughts : walk to living room ,find a book ,open the book ,read the book, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['microwave', 'toilet', 'milk', 'toothbrush', 'drawing', 'orchid', 'cpuscreen', 'character', 'bedroom', 'stovefan', 'toaster', 'mousepad', 'clothes_pants', 'food_kiwi', 'wall_clock', 'bed', 'television', 'toothbrush_holder', 'water', 'tray', 'curtain', 'pencil', 'kitchen_counter', 'shoes', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'dirt'] Task:Brush teeth response: | { today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'pot', 'filing_cabinet', 'microwave', 'chair', 'jelly', 'bathroom', 'detergent', 'knife', 'floor', 'toaster', 'mat', 'plate', 'shower', 'faucet', 'dish_soap', 'bowl', 'wall', 'cup', 'coffe_maker', 'food_food', 'after_shave', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'spoon', 'home_office', 'table', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I walk to the kitchen and find the dishwasher. I open it. I find the sink and grab the dirty plates, cups, bowls, and utensils. I rinse off the dirty dishes under the faucet. I then place the dirty dishes into the dishwasher. I add soap to the dishwasher and close the lid. I turn it on and wait., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <sink>', '[FIND] <bowl>', '[GRAB] <bowl>', '[RINSE] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[RINSE] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[RINSE] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[RINSE] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[RINSE] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[TURNTO] <dishwasher>'] } Scene_Objects:['fork', 'filing_cabinet', 'crayon', 'microwave', 'chair', 'orchid', 'drawing', 'wallshelf', 'floor', 'character', 'table_cloth', 'ceilinglamp', 'plate', 'stereo', 'mat', 'tvstand', 'wall', 'oven', 'cup', 'bed', 'food_food', 'razor', 'oven_mitts', 'tray', 'kitchen_counter', 'spoon', 'table', 'dishwasher', 'teeth', 'creditcard'] Task:Set up table response: | { Place your plate on the placemat. The forks will be placed on the left side of the plate and the knife and spoon on the right and place the spoon to the right of the knife. If you want to set out food, place them above 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:['pot', 'walllamp', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'laptop', 'plate', 'stovefan', 'shower', 'dish_soap', 'wall', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher', 'coffee'] Task:Wash dishes with dishwasher response: { thoughts : Put the dishes on dinner table in the dishwasher and wash them, actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[WALK] <table>', '[FIND] <pot>', '[GRAB] <pot>', '[WALK] <dishwasher>', '[PUTBACK] <pot> <dishwasher>', '[CLOSE] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'box', 'novel', 'toilet_paper', 'television', 'mouse', 'dresser', 'door', 'food_steak', 'clothes_skirt', 'tooth_paste'] Task:Read book response: | { \ walk to entrance\ \ walk to living room\ \ look for book\ \ find book\ \ pick up book\ \ look for chair\ \ find chair\ \ sit in chair\ \ read book\ } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'pot', 'mop', 'walllamp', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'remote_control', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'powersocket', 'box', 'love_seat', 'photoframe', 'television', 'curtain', 'doorjamb', 'dresser', 'clothes_dress', 'bathtub', 'light'] Task:Watch TV response: { thoughts : I'll watch TV, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['measuring_cup', 'microwave', 'chair', 'walllamp', 'cat', 'wallshelf', 'floor', 'character', 'desk', 'tea_bag', 'toaster', 'plate', 'couch', 'dining_room', 'box', 'newspaper', 'bed', 'toilet_paper', 'curtain', 'coffee_pot', 'mouse', 'kettle', 'cupboard', 'controller', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap'] 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:['fork', 'filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'wall', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'hair', 'clothes_dress', 'door', 'table', 'clothes_skirt', 'scrabble'] Task:Watch TV response: { thoughts : Walk into the living room/den. Turn on the television. Switch channels to find a program with remote. I find a program and look at the screen., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['spectacles', 'mop', 'dog', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'mat', 'closetdrawer', 'couch', 'food_jam', 'food_orange', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'food_cheese', 'keys', 'food_food', 'video_game_controller', 'television', 'ice', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher'] Task:Put groceries in Fridge response: | { Walk to kitchen. Open fridge. Put groceries in fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'chair', 'bathroom', 'food_carrot', 'knifeblock', 'floor', 'phone', 'bedroom', 'envelope', 'mail', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'tvstand', 'shower', 'window', 'candle', 'microphone', 'pillow', 'basket_for_clothes', 'toilet_paper', 'check', 'rag', 'chessboard', 'laundry_detergent', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'washing_machine', 'coffee'] Task:Wash clothes response: { thoughts : Pick up my dirty clothes, load the washer, add detergent, turn on washer, actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>'] } Scene_Objects:['pot', 'blender', 'toilet', 'bathroom', 'detergent', 'food_butter', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'mousepad', 'couch', 'food_kiwi', 'wall', 'oven', 'toy', 'coffe_maker', 'television', 'oven_mitts', 'coffee_filter', 'ice', 'coffee_pot', 'shaving_cream', 'kitchen_counter', 'cd', 'cupboard', 'sink', 'home_office', 'dishwasher', 'coffee'] Task:Make coffee response: | { Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, 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', 'food_salt', 'chair', 'bathroom', 'drawing', 'food_egg', 'floor', 'desk', 'bookshelf', 'computer', 'mat', 'stereo', 'shower', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'pajamas', 'controller', 'door', 'clothes_scarf', 'light', 'dishwasher', 'board_game'] Task:Pull up carpet response: { thoughts : Pry up a corner of your old dirty carpet. Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt., actions : ['[WALK] <home_office>', '[WALK] <mat>', '[FIND] <mat>', '[TOUCH] <mat>', '[PULL] <mat>'] } Scene_Objects:['pot', 'food_salt', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'phone', 'bookshelf', 'computer', 'toaster', 'tvstand', 'stereo', 'closetdrawer', 'food_peanut_butter', 'clothes_pants', 'form', 'wall', 'oven', 'cup', 'bed', 'mouthwash', 'rag', 'towel_rack', 'kitchen_counter', 'pajamas', 'food_steak', 'door', 'napkin', 'bathroom_cabinet'] Task:Listen to music response: | { Find the playback device you want to listen to. turn on. press play. enjoyu music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['water_glass', 'food_salt', 'microwave', 'freezer', 'orchid', 'cpuscreen', 'ceiling', 'character', 'bedroom', 'desk', 'food_bacon', 'bookmark', 'toaster', 'stovefan', 'faucet', 'shower', 'mousepad', 'wall', 'wall_clock', 'oven', 'bench', 'coffe_maker', 'television', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'light'] Task:Drink response: { thoughts : I go to the kitchen, take a glass from the cupboard, fill with water and drink, actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>', '[RINSE] <water_glass>', '[PUTBACK] <water_glass> <cupboard>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'toilet_paper', 'television', 'doorjamb', 'dresser', 'cupboard', 'light', 'clothes_shirt'] Task:Change TV channel response: | { Go to the living room, Switch on the television. Find the remote and press the change channel button, change the channel } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'cpuscreen', 'clothes_underwear', 'hanger', 'shampoo', 'bookshelf', 'alcohol', 'table_cloth', 'faucet', 'shower', 'clothes_socks', 'clothes_pants', 'wall', 'wall_clock', 'oven', 'nightstand', 'basket_for_clothes', 'newspaper', 'clothes_gloves', 'tray', 'doorjamb', 'lighter', 'cards', 'clothes_dress', 'laundry_detergent', 'napkin', 'clothes_skirt', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: { thoughts : I go to the bathroom, take the dirt clothes and put into the washing machine, then put the soap, set the cleaning program and switch on the machine, actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_skirt>', '[GRAB] <clothes_skirt>', '[PUTBACK] <clothes_skirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[CLOSE] <basket_for_clothes>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['pot', 'tablelamp', 'food_salt', 'mop', 'toilet', 'freezer', 'bathroom', 'dough', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'mat', 'ceilinglamp', 'couch', 'food_orange', 'pillow', 'wall', 'oven', 'tape', 'food_cheese', 'food_food', 'coffe_maker', 'television', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'light'] Task:Put groceries in Fridge response: | { Put groceries 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:['water_glass', 'filing_cabinet', 'juice', 'milk', 'hanger', 'kitchen_cabinet', 'bathroom_counter', 'button', 'food_bacon', 'stovefan', 'mat', 'shoe-shine_kit', 'tvstand', 'electric_shaver', 'food_peanut_butter', 'form', 'dining_room', 'cutting_board', 'cup', 'photoframe', 'coffe_maker', 'television', 'water', 'wooden_spoon', 'kettle', 'kitchen_counter', 'chessboard', 'dresser', 'sink', 'spoon'] Task:Drink response: { thoughts : Go to kitchen. Open the the cabinet. Locate the water glass. Pour water into glass. Drag the bottle close to mouth. Drink water., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[CLOSE] <kitchen_cabinet>', '[GRAB] <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'wall', 'pasta', 'oven', 'powersocket', 'box', 'water', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'sauce_pan', 'cupboard', 'door', 'light', 'dishwasher', 'tooth_paste', 'teeth'] Task:Cook some food response: | { Cook some pasta on the stove } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'juice', 'microwave', 'freezer', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'tea_bag', 'keyboard', 'computer', 'button', 'stovefan', 'mat', 'ceilinglamp', 'homework', 'closetdrawer', 'couch', 'wall', 'oven', 'cutting_board', 'toilet_paper', 'television', 'curtain', 'diary', 'pencil', 'shoes', 'dresser', 'table'] Task:Put out flowers response: { thoughts : Place a flower centrepiece on the entrance hall table., actions : ['[WALK] <home_office>', '[WALK] <centerpiece>', '[FIND] <centerpiece>', '[GRAB] <centerpiece>', '[WALK] <table>', '[PUTBACK] <centerpiece> <table>'] } Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'towel', 'dining_room', 'wall', 'nightstand', 'cup', 'photoframe', 'television', 'food_rice', 'doorjamb', 'mouse', 'dresser', 'clothes_scarf', 'light'] Task:Watch TV response: | { Walk to the living room. Sit on the sofa. Grab the remote and turn on 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', 'measuring_cup', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'remote_control', 'bookshelf', 'computer', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'broom', 'nightstand', 'wall', 'television', 'curtain', 'doorjamb', 'pencil', 'dresser', 'pajamas', 'laundry_detergent', 'clothes_dress', 'bag', 'table'] Task:Watch TV response: { thoughts : walk into the living room walk to the remote pick it up and turn in the tv and watch, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[WATCH] <television>'] } Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'controller', 'door', 'light'] Task:Work response: | { I need to finish some work on my computer in my home office to meet a deadline for tomorrow. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'drawing', 'knife', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'check', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'controller', 'bathtub', 'home_office', 'light'] 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:['microwave', 'freezer', 'ground_coffee', 'cat', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'food_bacon', 'mat', 'iron', 'couch', 'food_peanut_butter', 'food_orange', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'clothes_gloves', 'food_food', 'television', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'hair', 'clothes_dress', 'light', 'table'] Task:Put groceries in Fridge response: | { I put my groceries 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:['filing_cabinet', 'tablelamp', 'freezer', 'orchid', 'floor', 'bedroom', 'keyboard', 'stovefan', 'stereo', 'shower', 'closetdrawer', 'couch', 'dining_room', 'tape', 'cup', 'bed', 'novel', 'television', 'toothbrush_holder', 'doorjamb', 'mouse', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'spoon', 'instrument_guitar', 'table', 'clothes_shirt', 'shoe_rack'] Task:Look out window response: { thoughts : I head into my child's room and look out the window to view the neighborhood from a different area in the house., actions : ['[WALK] <bedroom>', '[WALK] <window>', '[TURNTO] <window>', '[LOOKAT] <window>'] } Scene_Objects:['tablelamp', 'chair', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'television', 'doorjamb', 'mouse', 'pencil', 'dresser', 'door', 'dishwasher'] Task:Read book response: | { Go to home office and read a book } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'fork', 'filing_cabinet', 'tablelamp', 'chair', 'band-aids', 'floor', 'ceiling', 'stamp', 'alcohol', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'towel', 'wall', 'toy', 'bed', 'keys', 'photoframe', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'dresser', 'cupboard', 'food_steak', 'sink', 'table'] Task:Wash dishes response: { thoughts : Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <plate>', '[PUTOBJBACK] <towel>', '[WALK] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>'] } Scene_Objects:['fork', 'pot', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'food_egg', 'wallshelf', 'floor', 'stamp', 'computer', 'alcohol', 'toaster', 'plate', 'shower', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'water', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'spoon', 'instrument_guitar', 'light', 'dishwasher', 'soap', 'scrabble'] Task:Wash dishes with dishwasher response: | { first i will take all the dishes to the dish washer and with the help of dishwasher and water i will clean all the dishes } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : walk to kitchen, walk to table, grab water glass and drink water, actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>', '[PUTBACK] <water_glass> <table>'] } Scene_Objects:['toilet', 'chair', 'freezer', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'toaster', 'mat', 'faucet', 'stereo', 'food_jam', 'food_orange', 'pillow', 'towel', 'wall', 'food_cheese', 'coffe_maker', 'check', 'coffee_filter', 'water', 'drinking_glass', 'curtain', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet', 'home_office'] 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:['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: { thoughts : 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., actions : ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['pot', 'water_glass', 'food_ice_cream', 'microwave', 'freezer', 'drawing', 'floor', 'ceiling', 'toaster', 'stovefan', 'mat', 'shower', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'coffe_maker', 'television', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'door', 'dishwasher'] Task:Drink response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'computer', 'deck_of_cards', 'mousepad', 'couch', 'pillow', 'wall', 'child', 'bed', 'coin', 'coffee_filter', 'doorjamb', 'centerpiece', 'door', 'table', 'light', 'dishwasher'] Task:Let baby learn how to walk response: { thoughts : The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe., actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[GREET] <child>', '[FIND] <couch>', '[TURNTO] <couch>', '[POINTAT] <couch>', '[TURNTO] <child>', '[LOOKAT] <child>'] } Scene_Objects:['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: | { 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:['sponge', 'pot', 'sheets', 'food_ice_cream', 'food_salt', 'measuring_cup', 'microwave', 'toilet', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'floor', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'plate', 'window', 'floor_lamp', 'mousepad', 'couch', 'pillow', 'wall', 'clothes_gloves', 'novel', 'check', 'television', 'food_rice', 'doorjamb', 'table'] Task:Read book response: { thoughts : A person brings a book into the living room and sits down in a comfortable chair. If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read. The person begins reading the book until they need to stop for some reason., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <novel>'] } Scene_Objects:['tablelamp', 'beer', 'tea', 'ground_coffee', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'plate', 'tvstand', 'closetdrawer', 'couch', 'food_jam', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'chessboard', 'door', 'light'] Task:Turn on light response: | { walk into living room, walk to light, turn on light switch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'detergent', 'food_butter', 'toothbrush', 'drawing', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'dish_soap', 'wall', 'nightstand', 'cup', 'coffe_maker', 'coffee_filter', 'drinking_glass', 'tray', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'sink', 'coffee_cup', 'dishwasher', 'shoe_rack'] Task:Clean dishes response: { thoughts : Wash dishes in the sink then place them in the dishwasher. Put detergent in the dishwasher and turn it on when full., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <drinking_glass>', '[WASH] <drinking_glass>', '[FIND] <coffee_cup>', '[WASH] <coffee_cup>', '[FIND] <plate>', '[WASH] <plate>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <dishwasher>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <detergent>', '[GRAB] <detergent>', '[PUTBACK] <detergent> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['microwave', 'walllamp', 'nail_polish', 'cat', 'drawing', 'knife', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'toilet_paper', 'check', 'television', 'doorjamb', 'towel_rack', 'mouse', 'vacuum_cleaner', 'dresser', 'cupboard', 'home_office'] Task:Pet cat response: | { I walk into the living room. I see my cat on the couch. I go sit next to the cat on the couch. I pet the cat on the back. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'mop', 'microwave', 'walllamp', 'detergent', 'food_carrot', 'knifeblock', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'stereo', 'window', 'oil', 'clothes_socks', 'wall', 'oven', 'food_vegetable', 'bed', 'photoframe', 'television', 'food_donut', 'water', 'tray', 'kitchen_counter', 'cupboard', 'dishwasher'] Task:Cook some food response: { thoughts : walk to kicthen , find stove , find cooking pot , find vegetables , find water ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove, actions : ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <oven>', '[FIND] <pot>', '[FIND] <food_vegetable>', '[FIND] <water>', '[GRAB] <water>', '[WASH] <food_vegetable>', '[POUR] <water> <pot>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <oven>', '[SWITCHON] <oven>'] } Scene_Objects:['pot', 'microwave', 'jelly', 'walllamp', 'drawing', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'shower', 'microphone', 'wall', 'oven', 'cup', 'photoframe', 'coffe_maker', 'television', 'tray', 'curtain', 'wooden_spoon', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'table', 'dishwasher', 'board_game', 'dirt'] Task:Take shower response: | { Walk to the bathroom and wash with the shower. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'sheets', 'pot', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mail', 'tvstand', 'stereo', 'window', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'powersocket', 'pasta', 'oven', 'light_bulb', 'coffe_maker', 'food_rice', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'door', 'light'] Task:Turn light off response: { thoughts : Put the light switch into the down, or off, position., actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>'] } Scene_Objects:['tablelamp', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Write an email response: | { Find the computer. Turn on the computer. Open the e-mail program. Create a new message. Write the message. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'crayon', 'microwave', 'toilet', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'shampoo', 'computer', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'bathroom_cabinet', 'light', 'instrument_violin'] Task:Pick up phone response: { thoughts : I walk over to the phone. .I reach my arm out. I open my hand. I place my hand on the phone. I close my fingers around the phone. I pick up the phone., actions : ['[WALK] <phone>', '[TOUCH] <phone>', '[GRAB] <phone>'] } Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'mop', 'chair', 'detergent', 'cat', 'phone', 'stamp', 'keyboard', 'stovefan', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'deck_of_cards', 'toaster', 'mousepad', 'closetdrawer', 'dining_room', 'food_kiwi', 'wall', 'check', 'coffe_maker', 'curtain', 'rag', 'mouse', 'comb', 'bathroom_cabinet', 'dishwasher', 'soap'] Task:Pet cat response: | { I go looking for the cat in the living room where he usually sleeps. Once I find the cat I just pet him for a few minutes. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'spectacles', 'filing_cabinet', 'food_salt', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'character', 'shower', 'stereo', 'microphone', 'wall', 'toy', 'cutting_board', 'cup', 'novel', 'food_food', 'check', 'food_onion', 'coffee_pot', 'console', 'shaving_cream', 'towel_rack', 'shoes', 'cd', 'hairbrush', 'maindoor', 'soap', 'coffee'] Task:Read response: { thoughts : Read a book in the living room, actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[READ] <novel>'] } Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'light'] Task:Write an email response: | { I need to write an e-mail to my boss about the meeting at work tomorrow. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_bread', 'toilet', 'chair', 'freezer', 'floor', 'ceiling', 'thread', 'table_cloth', 'ceilinglamp', 'faucet', 'food_peanut_butter', 'dining_room', 'wall', 'nightstand', 'powersocket', 'tape', 'photoframe', 'bed', 'food_food', 'cards', 'kitchen_counter', 'dishrack', 'dresser', 'hair', 'pajamas', 'door', 'home_office', 'dishwasher', 'vase'] Task:Put groceries in Fridge response: { thoughts : go to the kitchen and put the groceries in the fridge, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>'] } Scene_Objects:['pot', 'filing_cabinet', 'food_pizza', 'beer', 'tea', 'microwave', 'toilet', 'chair', 'freezer', 'toothbrush', 'cpuscreen', 'piano_bench', 'faucet', 'mousepad', 'couch', 'nightstand', 'powersocket', 'food_food', 'coffe_maker', 'curtain', 'shaving_cream', 'shoes', 'dishrack', 'dresser', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'light'] Task:Pick up phone response: | { walk to living room, walk to the phone reach for the phone and pick up the phone. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'beer', 'crayon', 'freezer', 'walllamp', 'bathroom', 'detergent', 'wallshelf', 'floor', 'ceiling', 'purse', 'computer', 'mat', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'dining_room', 'wall', 'photoframe', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Wipe down baseboards please response: { thoughts : Use a rag to get all the dust off the baseboards please., actions : ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <wall>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'brush', 'mat', 'tvstand', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'photoframe', 'food_food', 'television', 'doorjamb', 'bag', 'light', 'dishwasher', 'table'] Task:Relax on sofa response: | { Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'food_ice_cream', 'microwave', 'walllamp', 'orchid', 'bills', 'knife', 'wallshelf', 'floor', 'ceiling', 'remote_control', 'computer', 'tvstand', 'faucet', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'light_bulb', 'coffe_maker', 'television', 'curtain', 'lighter', 'vacuum_cleaner', 'dresser', 'table'] Task:Watch TV response: { thoughts : I grab the remote. I find the red power circular button. I point the remote at the television. I push button down and TV screen lights up. I sit and watch., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>'] } Scene_Objects:['tablelamp', 'food_ice_cream', 'jelly', 'chair', 'blow_dryer', 'bathroom', 'wallshelf', 'shampoo', 'phone', 'desk', 'clothes_jacket', 'stovefan', 'faucet', 'oil', 'closetdrawer', 'food_noodles', 'mousepad', 'microphone', 'towel', 'broom', 'bed', 'newspaper', 'after_shave', 'centerpiece', 'console', 'dresser', 'bathroom_cabinet', 'soap', 'tooth_paste', 'scrabble'] Task:Read book response: | { Walk to living room. Find book. Grab book. Open book. Read book. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'shelf', 'cup', 'television', 'doorjamb', 'mouse', 'address_book', 'dresser', 'conditioner', 'bathtub', 'spoon', 'light', 'table', 'soap'] Task:Work response: { thoughts : Walk to home office. Walk to computer. Switch on computer. Open the address book., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[FIND] <address_book>'] } Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'couch', 'microphone', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'photoframe', 'keys', 'television', 'tray', 'doorjamb', 'dresser', 'bathroom_cabinet'] Task:Change TV channel response: | { Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'chair', 'walllamp', 'orchid', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'powersocket', 'oven', 'bench', 'photoframe', 'television', 'curtain', 'food_onion', 'doorjamb', 'towel_rack', 'bathroom_cabinet', 'light', 'home_office'] Task:Watch TV response: { thoughts : Walk to living room. Find remote control. Find television. Point remote at television. Press on button. Watch., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['pot', 'chair', 'walllamp', 'bathroom', 'toothbrush', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'box', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'comb', 'dresser', 'laundry_detergent', 'instrument_guitar', 'dishwasher'] 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:['sheets', 'pot', 'shoe_rack', 'toilet', 'chair', 'band-aids', 'freezer', 'walllamp', 'cat', 'trashcan', 'folder', 'bookshelf', 'deck_of_cards', 'shower', 'mousepad', 'food_kiwi', 'wall', 'powersocket', 'cup', 'bed', 'clothes_gloves', 'keys', 'television', 'kitchen_counter', 'dishrack', 'controller', 'napkin', 'light', 'soap', 'creditcard'] Task:Pet cat response: { thoughts : I go to the living room then go to the cat and touch it., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['tablelamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'desk', 'bookshelf', 'mat', 'deck_of_cards', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'bed', 'coffee_filter', 'wine', 'curtain', 'doorjamb', 'kitchen_counter', 'pajamas', 'door', 'food_steak', 'bag', 'light', 'electrical_outlet'] Task:Turn on light response: | { I walk to the living room. I find the electric outlet. I switch 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:['beer', 'bathroom', 'orchid', 'knifeblock', 'food_egg', 'clothes_underwear', 'shampoo', 'bedroom', 'tvstand', 'shoe-shine_kit', 'pillow', 'dining_room', 'bench', 'powersocket', 'coffe_maker', 'video_game_controller', 'television', 'food_rice', 'tray', 'after_shave', 'food_onion', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'comb', 'cupboard', 'bathroom_cabinet', 'light', 'tooth_paste'] Task:Turn on light response: { thoughts : I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it., actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TOUCH] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['spectacles', 'microwave', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'wall', 'food_food', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'headset', 'cupboard', 'food_steak', 'light', 'laser_pointer', 'clothes_shirt'] Task:Put groceries in Fridge response: | { Find groceries. Grab groceries. Walk to refrigerator. Open refrigerator door. Place groceries into refrigerator. Close refrigerator door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'chair', 'bathroom', 'detergent', 'trashcan', 'toothbrush', 'knifeblock', 'bathroom_counter', 'character', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'nightstand', 'oven', 'bench', 'powersocket', 'cup', 'bed', 'ice', 'diary', 'cards', 'dresser', 'hairbrush', 'home_office', 'dishwasher', 'scrabble'] Task:Listen to music response: { thoughts : go to radio. run on radio., actions : ['[WALK] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'photoframe', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Write an email response: | { go to home office,switch on computer and send the mail by typing with keyboard } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'food_pizza', 'filing_cabinet', 'tablelamp', 'freezer', 'nail_polish', 'cat', 'food_carrot', 'drawing', 'orchid', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'stamp', 'ceilinglamp', 'plate', 'candle', 'dining_room', 'wall', 'bench', 'food_vegetable', 'newspaper', 'food_food', 'television', 'after_shave', 'cards', 'cd', 'clothes_dress', 'table'] Task:Fix snack response: { thoughts : Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTBACK] <food_carrot> <plate>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[PUTBACK] <food_vegetable> <plate>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <plate> <table>'] } Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'bathroom', 'toothbrush', 'clothes_underwear', 'character', 'stamp', 'clothes_jacket', 'table_cloth', 'stovefan', 'oil', 'clothes_socks', 'clothes_pants', 'towel', 'wall', 'powersocket', 'basket_for_clothes', 'photoframe', 'coffee_filter', 'wooden_spoon', 'kitchen_counter', 'laundry_detergent', 'conditioner', 'napkin', 'bathroom_cabinet', 'soap', 'tooth_paste', '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:['filing_cabinet', 'chair', 'band-aids', 'freezer', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'envelope', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'towel', 'wall', 'powersocket', 'light_bulb', 'novel', 'curtain', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'board_game'] Task:Read to child response: { thoughts : Read a book out loud to a child, actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>'] } Scene_Objects:['beer', 'microwave', 'cd_player', 'walllamp', 'bathroom', 'detergent', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'mat', 'tvstand', 'shower', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'clothes_gloves', 'television', 'doorjamb', 'cd', 'hair', 'controller', 'instrument_guitar', 'clothes_skirt', 'instrument_violin'] Task:Listen to music response: | { I go to the living room, switch on the CD player (then choose the music cd and insert into the player) and sit on the sofa } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'crayon', 'chair', 'food_butter', 'food_carrot', 'ceilingfan', 'drawing', 'knife', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'thread', 'brush', 'plate', 'wall', 'bench', 'powersocket', 'oven', 'check', 'food_food', 'doorjamb', 'console', 'dresser', 'cupboard', 'door', 'maindoor', 'table', 'light'] Task:Eat response: { thoughts : I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food, actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <food_food> <table>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <plate>', '[EAT] <plate>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'chair', 'detergent', 'orchid', 'drawing', 'floor', 'ceiling', 'desk', 'mail', 'toaster', 'ceilinglamp', 'plate', 'mat', 'shower', 'homework', 'stovefan', 'dish_soap', 'wall', 'wall_clock', 'oven', 'check', 'coffe_maker', 'tray', 'console', 'towel_rack', 'kitchen_counter', 'cupboard', 'controller', 'table', 'dishwasher', 'light'] Task:Wash dishes with dishwasher response: | { Put the dishes on dinner table in the dishwasher and wash them } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'food_bread', 'freezer', 'food_carrot', 'milk', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'mousepad', 'garbage_can', 'clothes_hat', 'food_orange', 'food_dessert', 'wall', 'powersocket', 'food_vegetable', 'food_cheese', 'doorjamb', 'lighter', 'mouse', 'coffee', 'door', 'light', 'colander', 'teeth'] Task:Rotate stock in refrigerator response: { thoughts : Throw out expired items, put older items in front., actions : ['[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[TURNTO] <food_bread>', '[LOOKAT] <food_bread>', '[PUTOBJBACK] <food_bread>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[TURNTO] <food_cheese>', '[LOOKAT] <food_cheese>', '[FIND] <garbage_can>', '[PUTBACK] <food_cheese> <garbage_can>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[TURNTO] <food_cheese>', '[LOOKAT] <food_cheese>', '[PUTOBJBACK] <food_cheese>', '[FIND] <food_dessert>', '[TURNTO] <food_dessert>', '[LOOKAT] <food_dessert>', '[PUSH] <food_dessert>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <milk>', '[GRAB] <milk>', '[TURNTO] <milk>', '[LOOKAT] <milk>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>'] } Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'walllamp', 'food_butter', 'drawing', 'cpuscreen', 'hanger', 'floor', 'phone', 'desk', 'stamp', 'keyboard', 'computer', 'alcohol', 'toaster', 'laptop', 'mat', 'mousepad', 'wall', 'oven', 'bed', 'mouthwash', 'doorjamb', 'mouse', 'chessboard', 'door', 'clothes_scarf'] Task:Write an email response: | { walk to home office and switch on laptop and with the useof mouse and keyboard send mail } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'keyboard', 'computer', 'stovefan', 'brush', 'window', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'oven', 'coffe_maker', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'shaving_cream', 'cards', 'door', 'table', 'light', 'tooth_paste', 'laser_pointer'] Task:Pet cat response: { thoughts : The cat is laying on the couch in the living room. I want to pet it, so I am going to walk to the living room, sit on the couch, and pet the cat., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['sheets', 'pot', 'food_bread', 'filing_cabinet', 'tablelamp', 'hanger', 'ceiling', 'computer', 'bookmark', 'stovefan', 'mat', 'plate', 'shower', 'dish_soap', 'mousepad', 'closetdrawer', 'candle', 'food_orange', 'food_cheese', 'photoframe', 'food_food', 'food_rice', 'water', 'tray', 'doorjamb', 'towel_rack', 'headset', 'table', 'light', 'tooth_paste'] 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:['pot', 'food_salt', 'beer', 'chair', 'freezer', 'knifeblock', 'bathroom_counter', 'longboard', 'phone', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'nightstand', 'bench', 'bed', 'photoframe', 'novel', 'television', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'food_steak', 'sink', 'hairdryer', 'vase'] Task:Read book response: { thoughts : Go to the book shelf, get a book, open the book and read the book., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['glue', 'pot', 'tablelamp', 'microwave', 'dog', 'milk', 'orchid', 'floor', 'ceiling', 'computer', 'toaster', 'plate', 'shower', 'dish_soap', 'wall', 'food_cheese', 'coffe_maker', 'check', 'coffee_filter', 'oven_mitts', 'cards', 'towel_rack', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'conditioner', 'door', 'bathroom_cabinet', 'dishwasher'] Task:Wash dishes with dishwasher response: | { Walk to the kitchen. Open the dishwasher. Put plates into the dishwasher. Put dish soap into the dishwasher. Close the dishwasher. Turn on the dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'water_glass', 'pot', 'spectacles', 'walllamp', 'food_carrot', 'kitchen_cabinet', 'shampoo', 'longboard', 'computer', 'bookmark', 'mat', 'stereo', 'shower', 'homework', 'oil', 'clothes_socks', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'water', 'food_onion', 'headset', 'cd', 'dresser', 'controller', 'sink', 'napkin', 'clothes_skirt'] Task:Drink response: { thoughts : Go to kitchen. Open the the cabinet. Locate the water glass. Pour water into glass. Drag the bottle close to mouth. Drink water., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[CLOSE] <kitchen_cabinet>', '[GRAB] <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['microwave', 'toilet', 'milk', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'button', 'toaster', 'shower', 'oil', 'closetdrawer', 'clothes_hat', 'pillow', 'wall', 'toy', 'box', 'coffe_maker', 'television', 'toothbrush_holder', 'razor', 'wine', 'food_sugar', 'kitchen_counter', 'cupboard', 'pajamas', 'sink', 'coffee_cup', 'dishwasher', 'shoe_rack'] Task:Make coffee response: | { walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'tape', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Work response: { thoughts : I go to my home office. I find the computer along with mechanical keyboard on the desk. I sit on chair. I switch on the computer. I type on keyboard and work on the computer., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'mail', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'tape', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Work response: | { Go to home office and open door. Walk to desk and sit in computer chair. Look at computer. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'knife', 'cpuscreen', 'bathroom_counter', 'floor', 'keyboard', 'face', 'ceilinglamp', 'mat', 'faucet', 'shower', 'mousepad', 'closetdrawer', 'towel', 'bench', 'oven', 'bed', 'coffe_maker', 'television', 'wine', 'tray', 'towel_rack', 'kitchen_counter', 'chessboard', 'hair', 'controller', 'bathtub', 'bathroom_cabinet'] Task:Rain welcome response: { thoughts : The robot would greet me and then hand me a towel. It would make an appropriate quip about the weather while I dried off. It would receive the wet towel when I was done., actions : ['[WALK] <bedroom>', '[WALK] <towel>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <hair>', '[WIPE] <hair>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['food_salt', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'coin', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'table'] Task:Watch TV response: | { Watch the television } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'microwave', 'trashcan', 'hanger', 'floor', 'bedroom', 'computer', 'button', 'brush', 'mat', 'shower', 'faucet', 'window', 'clothes_hat', 'wall', 'child', 'oven', 'bed', 'newspaper', 'novel', 'curtain', 'centerpiece', 'doorjamb', 'mouse', 'cd', 'dresser', 'hairdryer', 'clothes_scarf', 'vase', 'board_game'] Task:Story reading time response: { thoughts : Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures, actions : ['[WALK] <bedroom>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[SIT] <bed>', '[TURNTO] <child>', '[LOOKAT] <child>', '[TURNTO] <novel>', '[POINTAT] <novel>', '[READ] <novel>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser', 'hair', 'door', 'coffee'] Task:Browse internet response: | { walk to living room. look at computer. switch on computer. sit in chair. watch computer. switch off 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:['chair', 'freezer', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'mat', 'shower', 'mousepad', 'wall', 'powersocket', 'oven', 'bench', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'table', 'light', 'coffee'] Task:Browse internet response: { thoughts : I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'food_cake', 'computer', 'toaster', 'mat', 'pillow', 'wall', 'powersocket', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'console', 'kitchen_counter', 'hairbrush', 'cupboard', 'conditioner', 'hairdryer', 'sink', 'instrument_violin', 'door', 'bathroom_cabinet', 'dishwasher', 'board_game', '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:['scissors', 'microwave', 'toilet', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'food_egg', 'cpuscreen', 'clothes_underwear', 'tea_bag', 'keyboard', 'faucet', 'clothes_socks', 'food_noodles', 'dining_room', 'bench', 'cup', 'bed', 'check', 'toilet_paper', 'television', 'after_shave', 'console', 'comb', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'board_game', 'teeth'] Task:Pet cat response: { thoughts : I walk to my cat, and I pet him, actions : ['[WALK] <cat>', '[TOUCH] <cat>'] } 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: | { switch on the computer, grab a chair and sit in front of the computer. type with keyboard and browse the internet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'stereo', 'tvstand', 'mousepad', 'couch', 'broom', 'wall', 'bed', 'check', 'toilet_paper', 'television', 'ice', 'kettle', 'mouse', 'door', 'sink', 'home_office', 'table'] Task:Browse internet response: { thoughts : I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['glue', 'food_salt', 'microwave', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'tvstand', 'stereo', 'closetdrawer', 'food_orange', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'coffee_filter', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'pajamas', 'door', 'light'] Task:Turn on light response: | { I walk into the kitchen, I find the light switch, and then i switch on the lights in the kitchen. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['beer', 'microwave', 'drawing', 'floor', 'purse', 'computer', 'plate', 'balanceball', 'shower', 'stereo', 'dustpan', 'clothes_hat', 'microphone', 'bench', 'basket_for_clothes', 'cup', 'bed', 'check', 'coffe_maker', 'food_onion', 'after_shave', 'cards', 'pencil', 'chessboard', 'maindoor', 'napkin', 'table', 'board_game', 'clothes_shirt', 'coffee'] Task:Set up table response: { thoughts : Get dishes. Place dishes neatly around table. Get food. Place food on middle of table., actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>'] } Scene_Objects:['tablelamp', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'bookshelf', 'keyboard', 'food_cake', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'razor', 'television', 'wine', 'tray', 'doorjamb', 'dresser', 'hair', 'controller', 'door', 'clothes_scarf', 'light', 'instrument_violin'] Task:Turn on light response: | { Turning on lights } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'mop', 'measuring_cup', 'microwave', 'chair', 'freezer', 'ground_coffee', 'bathroom', 'floor', 'ceiling', 'dvd_player', 'bookshelf', 'toaster', 'stovefan', 'faucet', 'iron', 'wall', 'wall_clock', 'cutting_board', 'shelf', 'clothes_gloves', 'coffe_maker', 'coffee_filter', 'food_rice', 'curtain', 'kitchen_counter', 'controller', 'sink', 'clothes_shirt'] Task:Make coffee response: { thoughts : You walk into the kitchen and turn to the coffee maker. You grab the coffee filter and put into the coffee machine, you also grab the ground coffee and put it into the coffee machine. You turn on the coffee machine., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'folder', 'desk', 'character', 'tea_bag', 'remote_control', 'purse', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'television', 'doorjamb', 'dresser', 'hairbrush', 'spoon', 'table'] Task:Watch TV response: | { Walk to living room. Find remote control. Find television. Point remote at television. Press \ on\ button. Watch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'cat', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'ceilinglamp', 'homework', 'mousepad', 'wall', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'shoes', 'comb', 'dresser', 'hairdryer'] Task:Write an email response: { thoughts : I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email, actions : ['[WALK] <laptop>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['sponge', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'cat', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'tooth_paste', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'coin', 'doorjamb', 'dresser', 'board_game'] 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:['food_ice_cream', 'chair', 'walllamp', 'trashcan', 'bills', 'knife', 'floor', 'desk', 'mail', 'button', 'toaster', 'plate', 'faucet', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'nightstand', 'oven', 'bed', 'clothes_gloves', 'novel', 'coffe_maker', 'check', 'tray', 'sink', 'table', 'dishwasher', 'shoe_rack'] Task:Wash dishes with dishwasher response: { thoughts : In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['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: | { I open the room door and press the light button on } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'food_bread', 'microwave', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'box', 'oven_mitts', 'food_onion', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'door', 'light', 'soap'] Task:Turn on light response: { thoughts : Turning on lights, actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <bathroom>'] } Scene_Objects:['fork', 'filing_cabinet', 'food_ice_cream', 'chair', 'freezer', 'detergent', 'cpuscreen', 'hanger', 'bookshelf', 'bookmark', 'stovefan', 'mat', 'faucet', 'stereo', 'couch', 'candle', 'dining_room', 'nightstand', 'novel', 'coffe_maker', 'ice', 'doorjamb', 'shaving_cream', 'cd', 'laundry_detergent', 'clothes_dress', 'hairdryer', 'light', 'table', 'colander'] Task:Listen to music response: | { turn radio on, listen to music } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'shower', 'mousepad', 'pillow', 'dining_room', 'wall', 'wall_clock', 'nightstand', 'tape', 'bed', 'console', 'mouse', 'clothes_scarf', 'light', 'soap', 'teeth'] Task:Check email response: { thoughts : Sit in teak deck chair, have wooden drawing board on lap, laptop on wooden drawing board, log in to my two email accounts, go through new emails and respond., actions : ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <chair>', '[SIT] <chair>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <laptop>'] } Scene_Objects:['pot', 'food_bread', 'tablelamp', 'food_salt', 'microwave', 'chair', 'freezer', 'ground_coffee', 'dough', 'drawing', 'orchid', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'toaster', 'mat', 'ceilinglamp', 'stovefan', 'faucet', 'shower', 'oil', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'powersocket', 'food_food', 'coffe_maker', 'television', 'wine', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'food_steak', 'door', 'sink', 'table', 'dishwasher', 'light'] 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:['filing_cabinet', 'blender', 'band-aids', 'freezer', 'orchid', 'cpuscreen', 'floor', 'bookshelf', 'envelope', 'toaster', 'stovefan', 'plate', 'shower', 'faucet', 'foundation', 'oil', 'mousepad', 'food_jam', 'microphone', 'dining_room', 'bench', 'oven', 'toy', 'box', 'food_food', 'food_onion', 'diary', 'kitchen_counter', 'cupboard', 'colander'] Task:Get out dish response: { thoughts : Open cupboard. Get out the dish., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[OPEN] <cupboard>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <cupboard>'] } Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'tvstand', 'foundation', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'television', 'food_rice', 'doorjamb', 'shoes', 'dresser', 'door', 'light', 'clothes_skirt'] Task:Turn on light response: | { I walk to room. I enter room. I find where the lightswitch is. I turn on the lights with the lightswitch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'pot', 'freezer', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'stamp', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'couch', 'food_peanut_butter', 'form', 'pillow', 'wall', 'bench', 'novel', 'food_food', 'oven_mitts', 'food_rice', 'diary', 'towel_rack', 'controller', 'maindoor', 'light', 'clothes_skirt'] Task:Put groceries in Fridge response: { thoughts : Walk to kitchen. Find groceries. Grab groceries. Find fridge. Walk to fridge. Put groceries in fridge., actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>'] } Scene_Objects:['food_salt', 'chair', 'orchid', 'bills', 'drawing', 'floor', 'ceiling', 'table_cloth', 'toaster', 'mat', 'faucet', 'mousepad', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'cup', 'keys', 'coffe_maker', 'food_food', 'check', 'water', 'wine', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'board_game'] Task:Drink response: | { Go to the kitchen and drink some 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', 'ceilingfan', 'drawing', 'food_egg', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'television', 'food_rice', 'curtain', 'kitchen_counter', 'hair', 'home_office', 'table', 'light', 'dishwasher', 'dirt'] Task:Change TV channel response: { thoughts : I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['fork', 'pot', 'crayon', 'microwave', 'walllamp', 'drawing', 'knife', 'wallshelf', 'food_egg', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mat', 'tvstand', 'stereo', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'television', 'razor', 'oven_mitts', 'doorjamb', 'home_office', 'scrabble'] Task:Relax on sofa response: | { allow sofa to support weight in order to decrease gravity induced entropy } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'mat', 'tvstand', 'shower', 'shoe-shine_kit', 'window', 'mousepad', 'clothes_socks', 'couch', 'food_noodles', 'pillow', 'wall', 'bed', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'home_office', 'light', 'table'] Task:Turn on light response: { thoughts : Walk into the bedroom and walk to the light switch. Flip the switch., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['pot', 'scissors', 'toilet', 'dog', 'freezer', 'band-aids', 'chair', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'couch', 'wall', 'nightstand', 'cup', 'basket_for_clothes', 'photoframe', 'food_food', 'coffe_maker', 'check', 'lighter', 'pencil', 'dishrack', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'colander'] Task:Listen to music response: | { Go to the living room. Find the radio. Turn on the radio. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_ice_cream', 'chair', 'freezer', 'bathroom', 'trashcan', 'orchid', 'cpuscreen', 'hanger', 'character', 'computer', 'mail', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'bed', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'cupboard', 'sink', 'light'] Task:Pet cat response: { thoughts : I walk to the living room. I find the cat. I pet the cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['sheets', 'filing_cabinet', 'toilet', 'detergent', 'dough', 'bills', 'wallshelf', 'clothes_underwear', 'ceiling', 'keyboard', 'table_cloth', 'faucet', 'electric_shaver', 'mousepad', 'couch', 'dustpan', 'form', 'dining_room', 'newspaper', 'photoframe', 'food_food', 'coffe_maker', 'check', 'wooden_spoon', 'tray', 'rag', 'instrument_guitar', 'soap', 'washing_machine', 'coffee'] 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', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'tea_bag', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'hair', 'door'] Task:Write an email response: { thoughts : I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer off., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <computer>'] } Scene_Objects:['food_oatmeal', 'microwave', 'freezer', 'bathroom', 'nail_polish', 'dough', 'food_carrot', 'orchid', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'brush', 'mat', 'couch', 'pillow', 'food_cereal', 'wall', 'food_vegetable', 'food_food', 'television', 'console', 'cards', 'kitchen_counter', 'cupboard', 'hair', 'door', 'light'] Task:Put groceries in Fridge response: | { Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door', 'teeth', 'printing_paper'] Task:Print out papers response: { thoughts : Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print., actions : ['[WALK] <home_office>', '[WALK] <fax_machine>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[PUTBACK] <printing_paper> <fax_machine>', '[FIND] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <printing_paper>'] } Scene_Objects:['freezer', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'mat', 'faucet', 'food_noodles', 'couch', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'toy', 'photoframe', 'newspaper', 'food_food', 'coffe_maker', 'television', 'check', 'ice', 'curtain', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'dishwasher', 'teeth'] Task:Put groceries in Fridge response: | { Open the fridge, and put groceries in the fridge. Close the fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_bread', 'tablelamp', 'food_salt', 'microwave', 'chair', 'freezer', 'ground_coffee', 'dough', 'drawing', 'orchid', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'toaster', 'mat', 'ceilinglamp', 'stovefan', 'faucet', 'shower', 'oil', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'powersocket', 'food_food', 'coffe_maker', 'television', 'wine', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'food_steak', 'door', 'sink', 'table', 'dishwasher', 'light'] Task:Cook some food response: { thoughts : 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., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <kitchen_counter>', '[PUTBACK] <food_food> <kitchen_counter>', '[CLOSE] <freezer>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[CLOSE] <kitchen_cabinet>', '[FIND] <oven>', '[PUTBACK] <pot> <oven>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <oven>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'food_salt', 'toilet', 'chair', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'food_bacon', 'tvstand', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'check', 'food_food', 'food_donut', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'napkin', 'light'] Task:Turn on light response: | { I enter the bedroom and find the light. Then I turn it on. } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.