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:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'towel', 'wall', 'wall_clock', 'oven', 'television', 'tray', 'rag', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'laser_pointer'] Task:Take shower response: { thoughts : Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower., actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <bathroom_cabinet>', '[FIND] <shower>', '[RINSE] <shower>'] } Scene_Objects:['food_bread', 'filing_cabinet', 'microwave', 'toilet', 'freezer', 'dough', 'food_carrot', 'drawing', 'knife', 'clothes_underwear', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'ceilinglamp', 'plate', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'bench', 'coffe_maker', 'toothbrush_holder', 'diary', 'laundry_detergent', 'table', 'coffee'] Task:Cut bread response: | { I get a slice of bread, grab a knife, and then cut the piece of bread in half. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'drawing', 'knifeblock', 'floor', 'character', 'keyboard', 'stovefan', 'mat', 'ceilinglamp', 'stereo', 'shower', 'window', 'toaster', 'wall', 'nightstand', 'box', 'food_cheese', 'bed', 'after_shave', 'lighter', 'diary', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'food_steak', 'light', 'dishwasher', 'clothes_shirt'] Task:Listen to music response: { thoughts : Turn on radio, put on favorite channel, listen to music., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[LIE] <bed>'] } Scene_Objects:['pot', 'juice', 'freezer', 'walllamp', 'knifeblock', 'drawing', 'food_egg', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'laptop', 'faucet', 'oil', 'wall', 'bench', 'box', 'cup', 'food_food', 'check', 'coffee_filter', 'lighter', 'centerpiece', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'spoon', 'table', 'colander', 'board_game'] Task:Grab some juice response: | { I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['spectacles', 'filing_cabinet', 'microwave', 'walllamp', 'ceilingfan', 'drawing', 'clothes_underwear', 'bathroom_counter', 'dvd_player', 'character', 'stamp', 'keyboard', 'food_cake', 'shower', 'picture', 'window', 'electric_shaver', 'couch', 'broom', 'box', 'food_food', 'toothbrush_holder', 'food_donut', 'after_shave', 'food_onion', 'mouse', 'hairdryer', 'sink', 'table', 'clothes_shirt'] Task:Open bathroom window response: | { Make sure bathroom window is unlocked. Lift up bathroom window so it is open. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'mop', 'bathroom', 'food_egg', 'clothes_underwear', 'bathroom_counter', 'phone', 'ceiling', 'computer', 'toaster', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'clothes_pants', 'food_orange', 'food_kiwi', 'basket_for_clothes', 'coffe_maker', 'television', 'curtain', 'mouse', 'cd', 'comb', 'clothes_dress', 'clothes_skirt', 'soap', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: { thoughts : I need to get the dirty clothes basket. Walk to bathroom. Put all the clothes in washing machine. Add soap. Turn on machine., actions : ['[WALK] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[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_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['tablelamp', 'juice', 'walllamp', 'bathroom', 'ceilingfan', 'trashcan', 'drawing', 'floor', 'ceiling', 'food_bacon', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'bench', 'bed', 'food_food', 'television', 'coin', 'curtain', 'mouse', 'controller', 'table', 'vase', 'instrument_violin'] Task:Watch TV response: | { Sitting on the couch watching my favorite television show. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'ceiling', 'bookshelf', 'envelope', 'toaster', 'mat', 'food_orange', 'pillow', 'wall', 'wall_clock', 'powersocket', 'cutting_board', 'bed', 'oven_mitts', 'coin', 'doorjamb', 'lighter', 'pencil', 'kitchen_counter', 'dresser', 'pajamas', 'door', 'home_office', 'light', 'colander'] Task:Turn on light response: { thoughts : I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['dry_pasta', 'measuring_cup', 'toilet', 'freezer', 'walllamp', 'food_carrot', 'knife', 'bathroom_counter', 'stamp', 'food_bacon', 'tvstand', 'plate', 'couch', 'oven', 'cup', 'photoframe', 'check', 'television', 'coffee_filter', 'toothbrush_holder', 'food_rice', 'tray', 'kitchen_counter', 'shoes', 'hairbrush', 'napkin', 'spoon', 'table', 'vase', 'creditcard'] Task:Shut off alarm response: | { Shutting of the alarm clock } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'chair', 'ground_coffee', 'bathroom', 'detergent', 'bathroom_counter', 'bedroom', 'bookshelf', 'button', 'toaster', 'mat', 'ceilinglamp', 'window', 'mousepad', 'couch', 'dining_room', 'photoframe', 'bed', 'novel', 'coffe_maker', 'food_food', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'sink', 'dishwasher', 'clothes_skirt', 'soap'] Task:Pick up phone response: { thoughts : walk to living room , find phone ,pick up phone 3, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>'] } Scene_Objects:['pot', 'freezer', 'walllamp', 'detergent', 'ceilingfan', 'dough', 'milk', 'knifeblock', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'faucet', 'iron', 'wall', 'nightstand', 'cup', 'food_food', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'food_steak', 'sink', 'bag', 'dishwasher', 'vase'] Task:Get something to drink response: | { Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'stovefan', 'mat', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'dresser', 'napkin', 'bathroom_cabinet', 'light', 'table'] Task:Relax on sofa response: { thoughts : I want to relax on the sofa to some relaxing music in the living room., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <stereo>', '[PLUGIN] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'dustpan', 'dining_room', 'wall', 'nightstand', 'pasta', 'tape', 'photoframe', 'tray', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'light'] Task:Turn on computer response: | { Press the power button on the computer to turn it on } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stovefan', 'window', 'mat', 'plate', 'couch', 'candle', 'microphone', 'dining_room', 'wall', 'powersocket', 'box', 'photoframe', 'coffe_maker', 'television', 'curtain', 'table', 'dishwasher'] Task:Watch TV response: { thoughts : Turn on the TV, sit on the couch, find a show, and watch it., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['dog', 'food_egg', 'bathroom_counter', 'folder', 'bedroom', 'computer', 'table_cloth', 'piano_bench', 'stovefan', 'tvstand', 'faucet', 'foundation', 'homework', 'couch', 'nightstand', 'powersocket', 'oven', 'basket_for_clothes', 'cup', 'keys', 'food_food', 'mouthwash', 'after_shave', 'doorjamb', 'shoes', 'controller', 'maindoor', 'bag', 'dirt', 'coffee'] Task:Get ready to leave response: | { Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'orchid', 'hanger', 'floor', 'ceiling', 'video_game_console', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'candle', 'broom', 'wall', 'powersocket', 'check', 'video_game_controller', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'hairbrush', 'door', 'table', 'dishwasher', 'dirt'] Task:Play games response: { thoughts : Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video game remote controller., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['sheets', 'jelly', 'freezer', 'food_carrot', 'drawing', 'needle', 'knifeblock', 'longboard', 'floor', 'character', 'ceilinglamp', 'shower', 'window', 'foundation', 'couch', 'wall', 'nightstand', 'food_cheese', 'newspaper', 'coffee_table', 'food_food', 'check', 'television', 'ice', 'doorjamb', 'kettle', 'maindoor', 'table', 'vase', 'board_game'] Task:Read magazine response: | { Get magazine off coffee table. Sit in arm chair. Open magazine to first page. Read until finished. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'blender', 'toilet', 'detergent', 'knife', 'hanger', 'floor', 'character', 'food_cake', 'brush', 'mat', 'plate', 'faucet', 'dish_soap', 'oil', 'closetdrawer', 'food_jam', 'dining_room', 'food_kiwi', 'oven', 'powersocket', 'cup', 'after_shave', 'kitchen_counter', 'dishrack', 'pajamas', 'spoon', 'dishwasher', 'vase'] 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:['blender', 'chair', 'shampoo', 'ceiling', 'folder', 'face', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'oil', 'food_orange', 'dining_room', 'bench', 'box', 'newspaper', 'check', 'video_game_controller', 'mirror', 'curtain', 'towel_rack', 'hair', 'clothes_dress', 'laundry_detergent', 'bathroom_cabinet', 'table', 'clothes_skirt', 'vase', 'scrabble'] Task:Check appearance in mirror response: | { Walk to full-length mirror. Look in mirror. Make sure everything about your appearance is adequate. Adjust clothes as needed. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'pot', 'filing_cabinet', 'microwave', 'chair', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'face', 'toaster', 'stovefan', 'faucet', 'oil', 'towel', 'wall', 'facial_cleanser', 'check', 'coffe_maker', 'tray', 'rag', 'mouse', 'kitchen_counter', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap'] Task:Wash face response: { thoughts : Turn the faucet on. Wet the face. Take facial cleanser out of packaging. Lather on face. Rinse face with water. Turn off the faucet. Dry face with towel., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <face>', '[WASH] <face>', '[FIND] <rag>', '[GRAB] <rag>', '[RINSE] <rag>', '[FIND] <facial_cleanser>', '[GRAB] <facial_cleanser>', '[POUR] <facial_cleanser> <rag>', '[PUTOBJBACK] <facial_cleanser>', '[SCRUB] <face>', '[RINSE] <rag>', '[PUTOBJBACK] <rag>', '[RINSE] <face>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['trashcan', 'dough', 'drawing', 'needle', 'longboard', 'floor', 'desk', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'stovefan', 'shower', 'window', 'floor_lamp', 'mousepad', 'wall', 'nightstand', 'bed', 'television', 'coffee_filter', 'curtain', 'rag', 'doorjamb', 'cards', 'mouse', 'pencil', 'maindoor', 'sink', 'door'] Task:Turn on lights response: | { Walk to your lamp, switch it on, and lay on your bed } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['beer', 'walllamp', 'blow_dryer', 'knifeblock', 'hanger', 'floor', 'ceiling', 'piano_bench', 'ceilinglamp', 'faucet', 'stereo', 'oil', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'toilet_paper', 'coffee_filter', 'water', 'wine', 'tray', 'curtain', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'dishwasher', 'laser_pointer', 'coffee'] Task:Make coffee response: { thoughts : Go to the kitchen and make coffee., actions : ['[RUN] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[PUTOBJBACK] <coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['pot', 'food_pizza', 'bathroom', 'trashcan', 'food_butter', 'food_carrot', 'floor', 'dvd_player', 'desk', 'food_cake', 'button', 'mat', 'shower', 'stereo', 'clothes_socks', 'couch', 'oven', 'food_food', 'television', 'tray', 'food_onion', 'coffee_pot', 'pencil', 'kitchen_counter', 'cd', 'cupboard', 'clothes_dress', 'food_steak', 'electrical_outlet', 'creditcard'] Task:Turn on radio response: | { Go to the radio. Switch on the power button. Tune the station. Set the volume. Listen to the music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'toilet', 'chair', 'freezer', 'detergent', 'food_butter', 'wallshelf', 'hanger', 'phone', 'character', 'desk', 'remote_control', 'button', 'piano_bench', 'toaster', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'clothes_pants', 'pillow', 'towel', 'wall', 'novel', 'razor', 'diary', 'conditioner', 'table', 'coffee'] Task:Change TV channel response: { thoughts : Take the Tv Remote Control in the Living Room table And Press the Channel Change Button to change the channel, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[PUTOBJBACK] <remote_control>'] } Scene_Objects:['spectacles', 'tablelamp', 'beer', 'toilet', 'band-aids', 'nail_polish', 'ceilingfan', 'food_carrot', 'toothbrush', 'knife', 'shampoo', 'ceiling', 'bedroom', 'stamp', 'tea_bag', 'mop_bucket', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'homework', 'food_noodles', 'dining_room', 'bed', 'ice', 'mouse', 'spoon', 'home_office', 'bathroom_cabinet', 'vase', 'colander'] Task:Shut front door response: | { Close the storm door. Lock the storm door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', '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: { thoughts : 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., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>'] } Scene_Objects:['pot', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'hanger', 'longboard', 'floor', 'phone', 'table_cloth', 'ceilinglamp', 'balanceball', 'window', 'couch', 'dustpan', 'powersocket', 'bench', 'cup', 'newspaper', 'photoframe', 'coin', 'console', 'mouse', 'comb', 'maindoor', 'spoon', 'light', 'shoe_rack'] Task:Leave home response: | { Put on shoes. Put on coat. Open door and exit through it. Lock door behind you. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'freezer', 'band-aids', 'trashcan', 'dough', 'food_egg', 'cpuscreen', 'floor', 'ceiling', 'folder', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'pillow', 'wall', 'powersocket', 'newspaper', 'food_food', 'check', 'oven_mitts', 'food_donut', 'food_onion', 'doorjamb', 'kettle', 'mouse', 'pajamas', 'door', 'light'] 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:['sheets', 'fork', 'crayon', 'tea', 'toilet', 'bathroom', 'orchid', 'hanger', 'floor', 'character', 'bedroom', 'tea_bag', 'keyboard', 'purse', 'toaster', 'mat', 'deck_of_cards', 'window', 'food_orange', 'pillow', 'photoframe', 'food_food', 'coffe_maker', 'food_donut', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'sink'] Task:Open door response: | { Open the door when leaving or coming in. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'measuring_cup', 'chair', 'trashcan', 'toothbrush', 'cpuscreen', 'hanger', 'ceiling', 'character', 'keyboard', 'alcohol', 'mat', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'oven', 'bench', 'bed', 'photoframe', 'food_food', 'coffe_maker', 'toothbrush_holder', 'tray', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'home_office', 'tooth_paste'] Task:Wash teeth response: { thoughts : WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR TEETH, actions : ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>'] } Scene_Objects:['chair', 'bills', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'table_cloth', 'oil', 'mousepad', 'couch', 'microphone', 'dining_room', 'wall', 'coffe_maker', 'coin', 'tray', 'centerpiece', 'console', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'vase', 'teeth'] Task:Put in chair response: | { Take a comfortable chair. Place it in the entrance hall } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'cat', 'drawing', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'bookshelf', 'computer', 'food_bacon', 'bookmark', 'brush', 'mat', 'mousepad', 'clothes_hat', 'wall', 'nightstand', 'powersocket', 'wall_clock', 'cup', 'oven_mitts', 'doorjamb', 'door', 'sink', 'light'] Task:Turn on light response: { thoughts : push any ligth button to turn it on, for example in the living room, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['tablelamp', 'blender', 'crayon', 'microwave', 'nail_polish', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'couch', 'dining_room', 'wall', 'nightstand', 'oven', 'novel', 'television', 'curtain', 'dresser', 'pajamas', 'table', 'instrument_violin'] Task:Turn off TV response: | { Walk over to tv and press power button } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'toothbrush', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'thread', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'plate', 'dining_room', 'wall', 'wall_clock', 'oven', 'toothbrush_holder', 'tray', 'doorjamb', 'towel_rack', 'chessboard', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'tooth_paste', 'teeth'] Task:Brush teeth response: { thoughts : getting ready for bed, actions : ['[WALK] <bathroom_counter>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <toothbrush> <bathroom_counter>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[GRAB] <toothbrush>', '[SCRUB] <toothbrush>', '[RINSE] <toothbrush>', '[FIND] <toothbrush_holder>', '[PUTBACK] <toothbrush> <toothbrush_holder>'] } Scene_Objects:['filing_cabinet', 'chair', 'dog', 'ceilingfan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'table_cloth', 'stovefan', 'electric_shaver', 'dining_room', 'wall', 'nightstand', 'bench', 'powersocket', 'coffe_maker', 'ice', 'lighter', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'home_office', 'table', 'light', 'vase'] Task:Push all chairs in response: | { Go around the dining room table, going to each chair, and push all the chairs in neatly. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'detergent', 'orchid', 'bathroom_counter', 'character', 'keyboard', 'remote_control', 'bookshelf', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'dustpan', 'nightstand', 'bench', 'tape', 'cup', 'bed', 'coffee_table', 'wooden_spoon', 'doorjamb', 'towel_rack', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'hair'] Task:Change TV channel response: { thoughts : walk next to the coffee table. pick up the remote control from the top of the coffee table. Point the remote to the TV. Press the blue arrow on the remote., actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'freezer', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'mop_bucket', 'shower', 'homework', 'candle', 'clothes_pants', 'pillow', 'wall', 'oven', 'bed', 'keys', 'check', 'coffe_maker', 'tray', 'centerpiece', 'pajamas', 'bag', 'spoon', 'soap', 'laser_pointer', 'scrabble'] Task:Put away keys response: | { Return keys into a bag } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'orchid', 'clothes_underwear', 'hanger', 'desk', 'clothes_jacket', 'mop_bucket', 'bookmark', 'shower', 'electric_shaver', 'clothes_socks', 'clothes_pants', 'food_kiwi', 'bench', 'basket_for_clothes', 'photoframe', 'bed', 'coffe_maker', 'food_rice', 'shaving_cream', 'dishrack', 'cupboard', 'clothes_dress', 'laundry_detergent', 'clothes_skirt', 'soap', 'board_game', '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:['sheets', 'food_ice_cream', 'food_salt', 'toilet', 'chair', 'detergent', 'orchid', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'phone', 'bookshelf', 'computer', 'clothes_jacket', 'piano_bench', 'pillow', 'wall', 'powersocket', 'photoframe', 'doorjamb', 'cd', 'dishrack', 'dresser', 'cupboard', 'door', 'home_office', 'light', 'bathroom_cabinet', 'table'] Task:Sit in chair response: | { I sit in a chair to rest and eat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : I walk to the office. I push the on button on the computer. I sit down in the chair. I work on the computer., actions : ['[WALK] <home_office>', '[WALK] <button>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['food_bread', 'food_ice_cream', 'food_salt', 'crayon', 'microwave', 'freezer', 'walllamp', 'milk', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'foundation', 'food_noodles', 'wall', 'oven', 'cup', 'bed', 'food_food', 'coffe_maker', 'toilet_paper', 'coin', 'tray', 'food_onion', 'kettle', 'light', 'dishwasher', 'electrical_outlet'] Task:Toast bread response: | { Place two slices of bread in the toaster. Select medium toast on toaster. Push down button to begin toasting. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'chair', 'walllamp', 'bills', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bathroom_counter', 'computer', 'tvstand', 'form', 'towel', 'wall', 'oven', 'photoframe', 'clothes_gloves', 'bed', 'food_food', 'doorjamb', 'towel_rack', 'dishrack', 'dresser', 'cupboard', 'door', 'light', 'table', 'colander', 'instrument_violin'] Task:Pick up phone response: { thoughts : I walk over to the phone and pick it up., actions : ['[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['sheets', 'toilet', 'chair', 'jelly', 'walllamp', 'cat', 'trashcan', 'hanger', 'floor', 'ceiling', 'phone', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'couch', 'wall', 'oven', 'bed', 'tray', 'kitchen_counter', 'shoes', 'dishrack', 'dresser', 'cupboard', 'bathroom_cabinet', 'light', 'teeth'] Task:Put away shoes response: | { Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet 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:['sheets', 'cpuscreen', 'phone', 'desk', 'cleaning_solution', 'keyboard', 'purse', 'table_cloth', 'stovefan', 'tvstand', 'shower', 'stereo', 'food_noodles', 'towel', 'pillow', 'wall', 'wall_clock', 'oven', 'basket_for_clothes', 'photoframe', 'novel', 'food_rice', 'rag', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'napkin', 'table'] Task:Clean mirror response: { thoughts : GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR, actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['glue', 'mop', 'toilet', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'floor', 'ceiling', 'computer', 'clothes_jacket', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'food_food', 'mouthwash', 'television', 'food_donut', 'curtain', 'after_shave', 'dresser', 'table'] Task:Look at painting response: | { Walk to the painting. Look up at the painting. Admire it on the wall. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'ceilinglamp', 'floor_lamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'oven', 'photoframe', 'novel', 'television', 'doorjamb', 'dresser', 'cupboard', 'light'] 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:['measuring_cup', 'microwave', 'chair', 'freezer', 'nail_polish', 'bathroom', 'food_butter', 'knifeblock', 'cpuscreen', 'hanger', 'ceiling', 'dvd_player', 'stamp', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'iron', 'nightstand', 'oven', 'cutting_board', 'check', 'television', 'coin', 'tray', 'doorjamb', 'bathroom_cabinet', 'teeth'] Task:Answer door response: | { Walk up to the door. Open the door and greet whomever is out side } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'drawing', 'hanger', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'foundation', 'oil', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'novel', 'television', 'curtain', 'after_shave', 'door', 'napkin', 'home_office', 'table'] Task:Turn off TV response: { thoughts : Walk over to tv and press power button, actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHOFF] <television>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'scissors', 'freezer', 'band-aids', 'blow_dryer', 'bathroom', 'ceilingfan', 'drawing', 'bathroom_counter', 'ceiling', 'food_cake', 'toaster', 'mat', 'faucet', 'shower', 'mousepad', 'food_jam', 'clothes_pants', 'bowl', 'wall', 'photoframe', 'keys', 'novel', 'toilet_paper', 'tray', 'controller', 'sink', 'bathroom_cabinet', 'table'] Task:Get toilet paper response: | { There are extra toilet papers in the bottom cabinet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'tablelamp', 'juice', 'scissors', 'beer', 'chair', 'freezer', 'bathroom', 'ceilingfan', 'hanger', 'floor', 'computer', 'food_bacon', 'mat', 'couch', 'creditcard', 'dining_room', 'oven', 'tape', 'bed', 'light_bulb', 'novel', 'food_food', 'mouse', 'cupboard', 'conditioner', 'home_office', 'table', 'scrabble', 'shoe_rack'] Task:Pet dog response: { thoughts : Pet my dog in hall, actions : ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>'] } Scene_Objects:['juice', 'food_salt', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'drawing', 'floor', 'stamp', 'table_cloth', 'plate', 'faucet', 'deck_of_cards', 'clothes_pants', 'wall', 'bench', 'powersocket', 'tape', 'photoframe', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee'] Task:Bring dirty plate to sink response: | { Stand up from the table. Pick up dirty plate. Walk to sink. Put plate in sink. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'love_seat', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'clothes_scarf'] Task:Watch TV response: { thoughts : Sit and watch the television, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['chair', 'freezer', 'trashcan', 'food_carrot', 'orchid', 'floor', 'ceiling', 'thread', 'mail', 'button', 'food_bacon', 'bookmark', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'wall', 'bench', 'cup', 'food_food', 'razor', 'television', 'food_donut', 'towel_rack', 'console', 'kitchen_counter', 'hairbrush', 'cupboard', 'sink', 'vase'] Task:Added meat to freezer response: | { After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'bookshelf', 'mat', 'shower', 'faucet', 'wall', 'powersocket', 'oven', 'light_bulb', 'novel', 'check', 'television', 'food_donut', 'curtain', 'doorjamb', 'kitchen_counter', 'spoon', 'home_office', 'light', 'dishwasher'] Task:Turn on light response: { thoughts : Switch on light in home office, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[SWITCHON] <light>', '[WALK] <home_office>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'microwave', 'toilet', 'chair', 'walllamp', 'cpuscreen', 'hanger', 'phone', 'computer', 'stereo', 'faucet', 'window', 'couch', 'dining_room', 'wall_clock', 'bench', 'pasta', 'coffe_maker', 'food_food', 'doorjamb', 'mouse', 'pajamas', 'controller', 'sink', 'napkin', 'light', 'table', 'dishwasher'] Task:Walk to room response: | { Leave the living room and enter the hall } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'microphone', 'form', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'television', 'curtain', 'vacuum_cleaner', 'dishrack', 'dresser', 'hairbrush', 'door', 'table', 'soap'] Task:Watch TV response: { thoughts : I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['sheets', 'mop', 'toilet', 'freezer', 'walllamp', 'food_carrot', 'knife', 'ceiling', 'purse', 'computer', 'table_cloth', 'faucet', 'clothes_pants', 'bench', 'photoframe', 'check', 'food_food', 'television', 'toilet_paper', 'ice', 'curtain', 'rag', 'lighter', 'mouse', 'pencil', 'vacuum_cleaner', 'door', 'clothes_scarf', 'sink', 'clothes_skirt'] Task:Look at mirror response: | { I look at my reflection to check my cleanliness. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'toilet', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'bathroom_counter', 'purse', 'alcohol', 'bookmark', 'stovefan', 'toaster', 'stereo', 'food_jam', 'dining_room', 'powersocket', 'food_food', 'mouthwash', 'tray', 'after_shave', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office', 'laser_pointer'] Task:Walk through response: { thoughts : Walk through the hallway., actions : ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>'] } Scene_Objects:['beer', 'crayon', 'freezer', 'detergent', 'orchid', 'drawing', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'faucet', 'window', 'electric_shaver', 'couch', 'clothes_pants', 'wall', 'photoframe', 'newspaper', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'shaving_cream', 'comb', 'hair', 'home_office', 'table', 'vase'] Task:Drink response: | { Get a can of beer, open it, sit on couch, relax } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', '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: { thoughts : 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., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[WALK] <coffee>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['food_pizza', 'beer', 'chair', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'dvd_player', 'stamp', 'bookshelf', 'toaster', 'ceilinglamp', 'faucet', 'homework', 'floor_lamp', 'window', 'food_orange', 'dining_room', 'nightstand', 'bench', 'food_cheese', 'television', 'doorjamb', 'lighter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer'] Task:Turn off light response: | { Walk to the lamp. Find the switch. Click the switch off. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'filing_cabinet', 'tablelamp', 'juice', 'food_salt', 'microwave', 'chair', 'freezer', 'detergent', 'trashcan', 'toothbrush', 'floor', 'ceiling', 'bookshelf', 'toaster', 'shower', 'stereo', 'mousepad', 'clothes_pants', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'food_food', 'check', 'food_donut', 'kitchen_counter', 'cupboard', 'door', 'home_office'] Task:Cook some food response: { thoughts : Go kitchen and make something for eat, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>'] } 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: | { Get dishes. Place dishes neatly around table. Get food. Place food on middle of table. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'toilet', 'chair', 'walllamp', 'knifeblock', 'drawing', 'floor', 'phone', 'keyboard', 'toaster', 'stovefan', 'plate', 'shower', 'tvstand', 'dish_soap', 'couch', 'wall', 'coffe_maker', 'video_game_controller', 'food_onion', 'rag', 'towel_rack', 'mouse', 'kettle', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['sponge', 'pot', 'toilet', 'detergent', 'orchid', 'longboard', 'floor', 'desk', 'food_bacon', 'stovefan', 'ceilinglamp', 'toaster', 'faucet', 'balanceball', 'window', 'bed', 'oven_mitts', 'ice', 'curtain', 'after_shave', 'lighter', 'towel_rack', 'cards', 'controller', 'laundry_detergent', 'maindoor', 'door', 'sink', 'home_office', 'table'] Task:Turn on light response: | { Twist the lamp switch until the light goes on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', '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: { thoughts : Going to the sink and scrubbing hands, actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>'] } Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'blow_dryer', 'toothbrush', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'character', 'bedroom', 'keyboard', 'ceilinglamp', 'stereo', 'shower', 'foundation', 'food_peanut_butter', 'towel', 'wall', 'clothes_gloves', 'food_food', 'toilet_paper', 'tray', 'after_shave', 'dresser', 'cupboard', 'door', 'light'] Task:Look in refrigerator response: | { Approach the refrigerator. Use the handle to open the refrigerator door. Look at each shelf of the refrigerator. Look in each refrigerator drawer. Close the refrigerator door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'jelly', 'freezer', 'chair', 'blow_dryer', 'bathroom', 'walllamp', 'knife', 'phone', 'keyboard', 'stovefan', 'homework', 'couch', 'food_jam', 'bench', 'oven', 'toy', 'box', 'food_cheese', 'oven_mitts', 'food_rice', 'tray', 'curtain', 'after_shave', 'dresser', 'clothes_dress', 'conditioner', 'hairdryer', 'vase', 'board_game'] Task:Pet cat response: { thoughts : I walk to my living room, find my cat, scrub it using my hand., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>'] } Scene_Objects:['tablelamp', 'crayon', 'tea', 'mop', 'microwave', 'toilet', 'toothbrush', 'drawing', 'knifeblock', 'orchid', 'phone', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'window', 'floor_lamp', 'couch', 'clothes_hat', 'photoframe', 'after_shave', 'food_onion', 'headset', 'chessboard', 'cupboard', 'controller', 'door', 'bathroom_cabinet', 'clothes_skirt'] Task:Switch on lamp response: | { Press the button so the light comes on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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:['sheets', 'chair', 'blow_dryer', 'trashcan', 'orchid', 'knifeblock', 'drawing', 'longboard', 'floor', 'ceiling', 'desk', 'cleaning_solution', 'computer', 'window', 'oil', 'clothes_socks', 'couch', 'pillow', 'wall', 'bed', 'newspaper', 'novel', 'toilet_paper', 'food_donut', 'curtain', 'rag', 'doorjamb', 'maindoor', 'napkin', 'bathroom_cabinet'] Task:Dust response: | { Gather wood cleaner and cleaning rag. Wipe baseboards and window sills with dry cloth, then spray with cleaner and buff } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'orchid', 'cpuscreen', 'floor', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'couch', 'candle', 'clothes_hat', 'pillow', 'wall', 'oven', 'coffe_maker', 'television', 'curtain', 'diary', 'towel_rack', 'mouse', 'dishrack', 'home_office', 'table'] Task:Relax on sofa response: { thoughts : I walk to the living room. I see the couch. I sit down on the couch, then lie down and put my feet up., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['sheets', 'pot', 'food_pizza', 'dry_pasta', 'walllamp', 'trashcan', 'food_carrot', 'dough', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'wall', 'wall_clock', 'oven', 'food_cheese', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher'] Task:Keep an eye on stove as something is cooking response: | { Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'cat', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'television', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'sink', 'bathroom_cabinet', 'table'] Task:Turn on computer response: { thoughts : Press the power button on the computer to turn it on, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['fork', 'dry_pasta', 'microwave', 'knifeblock', 'knife', 'longboard', 'ceiling', 'purse', 'face', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'towel', 'pillow', 'nightstand', 'powersocket', 'photoframe', 'bed', 'clothes_gloves', 'mouthwash', 'after_shave', 'shoes', 'dishrack', 'dresser', 'hair', 'home_office', 'table', 'dishwasher'] Task:Rain welcome response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'band-aids', 'walllamp', 'drawing', 'wallshelf', 'floor', 'character', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'bench', 'photoframe', 'television', 'tray', 'curtain', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'home_office', 'table', 'clothes_shirt'] Task:Relax on sofa response: { thoughts : Sitting down and relaxing on the sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['scissors', 'tea', 'walllamp', 'knife', 'orchid', 'cpuscreen', 'hanger', 'character', 'desk', 'clothes_jacket', 'toaster', 'mat', 'tvstand', 'shower', 'clothes_hat', 'food_orange', 'bowl', 'bench', 'powersocket', 'oven', 'bed', 'light_bulb', 'coffe_maker', 'curtain', 'kitchen_counter', 'comb', 'pajamas', 'controller', 'sink', 'tooth_paste'] Task:Grab things response: | { The robot will need some kind of hands or grabbing device to transport objects. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'rag', 'doorjamb', 'cards', 'dresser', 'sink', 'dishwasher'] Task:Watch TV response: { thoughts : Sit on my couch directly opposite my tv , switch on my tv with the remote control and watch, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['sheets', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'bathroom', 'ceilingfan', 'clothes_underwear', 'bathroom_counter', 'character', 'thread', 'piano_bench', 'toaster', 'deck_of_cards', 'homework', 'couch', 'dustpan', 'powersocket', 'newspaper', 'clothes_gloves', 'novel', 'coffe_maker', 'doorjamb', 'chessboard', 'cd', 'napkin', 'home_office', 'instrument_guitar', 'clothes_skirt', 'light'] Task:Close door response: | { Push the door shut until it latches. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'freezer', 'woman', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'man', 'bookshelf', 'keyboard', 'piano_bench', 'stovefan', 'tvstand', 'shower', 'faucet', 'oil', 'dining_room', 'food_kiwi', 'nightstand', 'bench', 'oven', 'powersocket', 'coffe_maker', 'tray', 'curtain', 'towel_rack', 'cupboard', 'door', 'sink', 'light'] Task:Greet guests response: { thoughts : Stand next to the door. When the door opens from the outside, greet the guests., actions : ['[RUN] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[FIND] <man>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>'] } Scene_Objects:['juice', 'measuring_cup', 'toilet', 'nail_polish', 'trashcan', 'dough', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'bookmark', 'ceilinglamp', 'deck_of_cards', 'shoe-shine_kit', 'window', 'couch', 'wall', 'nightstand', 'check', 'mouthwash', 'television', 'hairbrush', 'sink', 'home_office', 'table', 'dishwasher', 'soap', 'teeth'] Task:Do homework response: | { Sit on the couch in the Living room and pick u some papers } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'television', 'curtain', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'table'] Task:Watch TV response: { thoughts : Walk to Living room. Find Television. Walk to sofa. Sit on sofa. Find Remote. Grab remote. Turn to television. Look at television. Switch on Television., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>'] } Scene_Objects:['dry_pasta', 'pot', 'walllamp', 'detergent', 'milk', 'hanger', 'phone', 'toaster', 'tvstand', 'balanceball', 'electric_shaver', 'food_noodles', 'garbage_can', 'mousepad', 'clothes_hat', 'pillow', 'broom', 'food_kiwi', 'bench', 'food_vegetable', 'food_cheese', 'food_food', 'ice', 'wine', 'rag', 'shaving_cream', 'dresser', 'cupboard', 'napkin', 'pantry'] Task:Organize pantry response: | { Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : Go to the kitchen and drink some water., actions : ['[RUN] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <cup> <sink>', '[FIND] <water>', '[GRAB] <cup>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>', '[PUTBACK] <cup> <sink>'] } Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'beer', 'chair', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'cleaning_solution', 'bookmark', 'iron', 'mousepad', 'couch', 'dustpan', 'food_jam', 'tape', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'hairbrush', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'vase', 'colander', 'teeth'] Task:Clean mirror response: | { Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'iron', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'video_game_controller', 'television', 'doorjamb', 'kettle', 'mouse', 'door', 'table'] Task:Browse internet response: { thoughts : Walk to home office. Walk to computer. Switch on Computer., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'detergent', 'milk', 'drawing', 'orchid', 'cpuscreen', 'longboard', 'floor', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'laptop', 'window', 'mousepad', 'clothes_socks', 'couch', 'wall', 'nightstand', 'powersocket', 'television', 'console', 'mouse', 'pajamas', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Use laptop response: | { Sit down on a couch and perform tasks such as navigating the internet on a laptop } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'freezer', 'bathroom', 'detergent', 'food_butter', 'longboard', 'bookshelf', 'stovefan', 'shower', 'pillow', 'towel', 'dining_room', 'nightstand', 'powersocket', 'toy', 'basket_for_clothes', 'newspaper', 'light_bulb', 'photoframe', 'food_food', 'coin', 'doorjamb', 'headset', 'shoes', 'hairbrush', 'cupboard', 'napkin', 'home_office'] Task:Listen to music response: { thoughts : I walk into my room and turn the radio on so that I can listen to music., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['tablelamp', 'food_ice_cream', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'knife', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'balanceball', 'homework', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'light'] Task:Vacuum response: | { Keep my keyboard vacuumed and free of debris. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'glue', 'microwave', 'bathroom', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'purse', 'food_bacon', 'ceilinglamp', 'plate', 'laptop', 'deck_of_cards', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'spoon', 'home_office', 'table', 'teeth'] Task:Relax on sofa response: { thoughts : I walk to the sofa, and lie down on the sofa., actions : ['[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['glue', 'tablelamp', 'beer', 'mop', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'balanceball', 'electric_shaver', 'mousepad', 'wall', 'nightstand', 'bed', 'doorjamb', 'towel_rack', 'mouse', 'hairdryer', 'maindoor', 'light'] Task:Clean screen response: | { Use a soft rag to wipe the screen until there are no marks on it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'walllamp', 'dough', 'drawing', 'needle', 'food_egg', 'wallshelf', 'cpuscreen', 'orchid', 'floor', 'ceiling', 'computer', 'mail', 'mat', 'tvstand', 'shoe-shine_kit', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'food_food', 'television', 'coin', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'clothes_dress', 'tooth_paste'] Task:Relax on sofa response: { thoughts : Walk to the living room, turn to the sofa. Sit on the sofa and relax., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>'] } Scene_Objects:['pot', 'microwave', 'toilet', 'walllamp', 'woman', 'drawing', 'hanger', 'longboard', 'bathroom_counter', 'phone', 'character', 'man', 'food_cake', 'alcohol', 'stovefan', 'window', 'mousepad', 'microphone', 'powersocket', 'cup', 'food_cheese', 'check', 'food_food', 'after_shave', 'controller', 'maindoor', 'food_steak', 'hairdryer', 'bathroom_cabinet', 'dirt'] Task:Greet guests response: | { Stand next to the door. When the door opens from the outside, greet the guests. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'walllamp', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'sink', 'light', 'coffee'] Task:Watch TV response: { thoughts : walk to living room ,find television , switch on remote control, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[SWITCHON] <remote_control>'] } Scene_Objects:['sheets', 'spectacles', 'food_pizza', 'beer', 'ground_coffee', 'bathroom', 'walllamp', 'ceilingfan', 'orchid', 'character', 'desk', 'cleaning_solution', 'bookshelf', 'food_bacon', 'mat', 'mousepad', 'wall', 'pasta', 'oven', 'powersocket', 'novel', 'food_rice', 'wooden_spoon', 'curtain', 'rag', 'console', 'chessboard', 'headset', 'dresser', 'cupboard'] Task:Clean response: | { Spray counter tops with all purpose cleaner. Using towel, wipe counter, removing all dirt and grime until clean. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'tea', 'band-aids', 'walllamp', 'nail_polish', 'knifeblock', 'bills', 'cpuscreen', 'hanger', 'shampoo', 'phone', 'floor', 'bedroom', 'desk', 'toaster', 'stereo', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bowl', 'dining_room', 'bench', 'newspaper', 'clothes_gloves', 'coffe_maker', 'curtain', 'diary', 'hairbrush', 'bathroom_cabinet'] Task:Listen to music response: { thoughts : I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['mop', 'walllamp', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'bookshelf', 'keyboard', 'mat', 'shower', 'faucet', 'couch', 'pillow', 'dining_room', 'photoframe', 'newspaper', 'novel', 'check', 'toilet_paper', 'coin', 'mirror', 'food_rice', 'rag', 'doorjamb', 'shoes', 'chessboard', 'dresser', 'hair', 'maindoor', 'table', 'clothes_shirt'] Task:Clean mirror response: | { Spray glass cleaner on mirror. Wipe with a clean cloth. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'beer', 'microwave', 'ceilingfan', 'food_carrot', 'drawing', 'floor', 'ceiling', 'phone', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'mat', 'oil', 'couch', 'dining_room', 'wall', 'bed', 'light_bulb', 'coffe_maker', 'television', 'curtain', 'kettle', 'door', 'napkin', 'table'] Task:Relax on sofa response: { thoughts : I walk to my living room and switch on the television, and lay on the sofa., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'food_carrot', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'purse', 'computer', 'table_cloth', 'brush', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'mouse', 'napkin', 'light', 'vase'] Task:Wash monitor response: | { Clean the grime off of my monitor screen when not in use } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'food_food', 'television', 'doorjamb', 'mouse', 'cupboard', 'conditioner', 'door', 'bathroom_cabinet', 'light', 'table'] Task:Look at painting response: { thoughts : Walk to the painting. Look up at the painting. Admire it on the wall., actions : ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>'] } Scene_Objects:['microwave', 'detergent', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'bookshelf', 'purse', 'food_cake', 'computer', 'ceilinglamp', 'mat', 'electric_shaver', 'pillow', 'dining_room', 'wall', 'toy', 'cup', 'television', 'vacuum_cleaner', 'shoes', 'comb', 'dresser', 'cupboard', 'food_steak', 'hairdryer', 'sink', 'bathroom_cabinet', 'dishwasher'] Task:Clean room response: | { Pick up his toys, vacuum the garbage off the floor. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['ironing_board', 'sheets', 'tablelamp', 'detergent', 'knifeblock', 'bathroom_counter', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'window', 'couch', 'pillow', 'bowl', 'nightstand', 'food_cheese', 'video_game_controller', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'pajamas', 'bag', 'dishwasher', 'board_game', 'clothes_shirt'] Task:Iron shirt response: { thoughts : Set up an ironing board and an iron. Lay a shirt on board. Run iron over shirt until it is free of wrinkles., actions : ['[WALK] <bedroom>', '[WALK] <ironing_board>', '[FIND] <ironing_board>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <ironing_board>', '[FIND] <iron>', '[GRAB] <iron>', '[PLUGIN] <iron>', '[PLUGOUT] <iron>', '[PUTOBJBACK] <iron>'] } Scene_Objects:['filing_cabinet', 'blender', 'crayon', 'toilet', 'chair', 'freezer', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'window', 'pillow', 'wall', 'pasta', 'powersocket', 'toy', 'box', 'cup', 'check', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'dresser', 'door', 'light', 'scrabble'] Task:Pick up toys response: | { Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'crayon', 'microwave', 'dog', 'band-aids', 'walllamp', 'trashcan', 'knifeblock', 'orchid', 'floor', 'desk', 'bookshelf', 'computer', 'piano_bench', 'plate', 'faucet', 'dish_soap', 'food_jam', 'form', 'wall', 'photoframe', 'doorjamb', 'kettle', 'kitchen_counter', 'dishrack', 'cupboard', 'pajamas', 'sink', 'table'] Task:Wash dishes by hand response: { thoughts : Walk to the kitchen and turn to the sink. Put the plate into the sink. Grab and squeeze the dish soap. Scrub the plate then rinse it. Put the plate into the dish rack., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <sink>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[SQUEEZE] <dish_soap>', '[SCRUB] <plate>', '[RINSE] <plate>', '[GRAB] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>'] } 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: | { Read a book out loud to a child } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'coffe_maker', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'cupboard', 'controller', 'table'] Task:Browse internet response: { thoughts : I go to my desk. I turn on the computer. I open a web page and look at it., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['bathroom', 'detergent', 'cat', 'knife', 'food_egg', 'character', 'stamp', 'bedroom', 'desk', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'window', 'oil', 'mousepad', 'clothes_hat', 'towel', 'pillow', 'dining_room', 'powersocket', 'coin', 'console', 'towel_rack', 'dishrack', 'cupboard', 'maindoor', 'sink', 'bag'] Task:Keep cats out of room response: | { Stand in the doorway and create a loud noise so the cats will stay out. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'stereo', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'powersocket', 'cup', 'toilet_paper', 'television', 'after_shave', 'rag', 'doorjamb', 'coffee_pot', 'dishrack', 'instrument_guitar', 'table', 'soap', 'laser_pointer'] Task:Relax on sofa response: { thoughts : walk to living room, walk to sofa, sit in sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['glue', 'filing_cabinet', 'food_pizza', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'brush', 'toaster', 'tvstand', 'balanceball', 'window', 'food_noodles', 'mousepad', 'food_peanut_butter', 'clothes_hat', 'dining_room', 'pasta', 'bench', 'photoframe', 'oven_mitts', 'ice', 'rag', 'dresser', 'cupboard', 'food_steak', 'maindoor', 'table'] Task:Clean mirror response: | { GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'broom', 'wall', 'pasta', 'powersocket', 'shelf', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'light', 'table'] Task:Work response: { thoughts : I walk to the living room. I find the computer and turn it on. I look at the computer screen. I move and click the mouse to select buttons on the screen., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[PUSH] <mouse>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['sheets', 'tablelamp', 'toilet', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'pillow', 'broom', 'wall', 'nightstand', 'television', 'ice', 'curtain', 'mouse', 'maindoor', 'table'] Task:Straighten paintings on wall response: | { Go up to the painting and tilt it which ever way it is uneven until it looks straight. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'floor_lamp', 'mousepad', 'wall', 'nightstand', 'novel', 'video_game_controller', 'television', 'mouse', 'door', 'napkin'] Task:Study response: { thoughts : Study norwegian, actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['toilet', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'cleaning_solution', 'faucet', 'balanceball', 'window', 'clothes_socks', 'food_orange', 'wall', 'powersocket', 'bench', 'cutting_board', 'photoframe', 'novel', 'check', 'rag', 'lighter', 'mouse', 'kitchen_counter', 'hair', 'sink', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'scrabble', 'dirt'] Task:Wash sink response: | { Turn on faucet. Rub down sink. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'chair', 'walllamp', 'wallshelf', 'ceiling', 'phone', 'keyboard', 'thread', 'piano_bench', 'brush', 'mat', 'ceilinglamp', 'window', 'oil', 'closetdrawer', 'mousepad', 'food_peanut_butter', 'candle', 'nightstand', 'powersocket', 'newspaper', 'novel', 'television', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'home_office', 'table', 'instrument_violin'] Task:Turn on light response: { thoughts : Twist the lamp switch until the light goes on., actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['tablelamp', 'microwave', 'dog', 'blow_dryer', 'trashcan', 'orchid', 'bathroom_counter', 'longboard', 'ceiling', 'character', 'bedroom', 'computer', 'mop_bucket', 'stereo', 'shower', 'window', 'food_peanut_butter', 'food_orange', 'bench', 'oven', 'bed', 'toilet_paper', 'television', 'razor', 'curtain', 'towel_rack', 'cupboard', 'door', 'dishwasher', 'soap'] Task:Put umbrella away response: | { Place the umbrella in the umbrella bucket point first. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'pot', 'tablelamp', 'microwave', 'detergent', 'clothes_underwear', 'ceiling', 'character', 'desk', 'mail', 'table_cloth', 'bookmark', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'mousepad', 'candle', 'food_jam', 'food_orange', 'nightstand', 'powersocket', 'newspaper', 'coin', 'food_onion', 'pencil', 'dresser', 'home_office', 'dishwasher', 'tooth_paste', 'coffee'] Task:Browse internet response: { thoughts : The task is browse and surf on the internet regarding a particular topic, actions : ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>'] } Scene_Objects:['walllamp', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'bedroom', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'pillow', 'dining_room', 'wall', 'bench', 'toy', 'box', 'photoframe', 'clothes_gloves', 'novel', 'video_game_controller', 'cards', 'vacuum_cleaner', 'dresser', 'controller', 'maindoor', 'napkin', 'dishwasher', 'instrument_violin'] Task:Pick up toys response: | { Bend down and pick up the toys off of the floor. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'scissors', 'crayon', 'toilet', 'jelly', 'walllamp', 'nail_polish', 'detergent', 'food_cake', 'alcohol', 'piano_bench', 'toaster', 'food_noodles', 'garbage_can', 'pillow', 'broom', 'oven', 'toy', 'food_vegetable', 'food_food', 'television', 'oven_mitts', 'doorjamb', 'pencil', 'headset', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'pantry'] Task:Organize pantry response: { thoughts : Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly., actions : ['[WALK] <dining_room>', '[WALK] <pantry>', '[FIND] <food_food>', '[GRAB] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[FIND] <garbage_can>', '[PUTBACK] <food_food> <garbage_can>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <dry_pasta>', '[GRAB] <dry_pasta>', '[TURNTO] <dry_pasta>', '[LOOKAT] <dry_pasta>', '[PUTOBJBACK] <dry_pasta>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[PUSH] <food_food>', '[FIND] <food_noodles>', '[GRAB] <food_noodles>', '[TURNTO] <food_noodles>', '[LOOKAT] <food_noodles>', '[PUTOBJBACK] <food_noodles>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'bathroom', 'detergent', 'ceilingfan', 'milk', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'food_rice', 'mouse', 'pencil', 'pajamas', 'maindoor', 'board_game', 'teeth', 'shoe_rack'] Task:Wipe down baseboards please response: | { Use a rag to get all the dust off the baseboards please. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'ground_coffee', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'button', 'mat', 'shower', 'mousepad', 'oil', 'closetdrawer', 'microphone', 'oven', 'cutting_board', 'check', 'centerpiece', 'diary', 'clothes_dress', 'clothes_scarf', 'napkin', 'tooth_paste'] Task:Pet cat response: { thoughts : Walk into the living room. Walk up to the cat. Pet the cat with your hand., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['tablelamp', 'measuring_cup', 'freezer', 'walllamp', 'bathroom', 'hanger', 'phone', 'desk', 'bookshelf', 'ceilinglamp', 'shoe-shine_kit', 'balanceball', 'faucet', 'couch', 'nightstand', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'check', 'television', 'food_onion', 'after_shave', 'curtain', 'shaving_cream', 'mouse', 'maindoor', 'sink', 'bag', 'home_office'] Task:Open front door response: | { Walk over to the front door, turn the knob, and open the door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'tea', 'microwave', 'chair', 'drawing', 'orchid', 'floor', 'computer', 'food_bacon', 'table_cloth', 'stovefan', 'toaster', 'homework', 'mousepad', 'couch', 'powersocket', 'oven', 'bench', 'check', 'oven_mitts', 'coffee_filter', 'curtain', 'rag', 'doorjamb', 'kitchen_counter', 'shoes', 'bathtub', 'dishwasher'] Task:Pet cat response: { thoughts : I walk into the living room and I pet the cat, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['pot', 'filing_cabinet', 'ground_coffee', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'shampoo', 'character', 'computer', 'ceilinglamp', 'mat', 'iron', 'plate', 'window', 'couch', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'photoframe', 'newspaper', 'video_game_controller', 'television', 'centerpiece', 'doorjamb', 'towel_rack', 'door', 'bathroom_cabinet', 'table'] Task:Read book response: | { Sit on a couch, grab a book, open it, and scan the pages } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'scissors', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'knifeblock', 'orchid', 'hanger', 'floor', 'bedroom', 'tea_bag', 'envelope', 'clothes_jacket', 'toaster', 'balanceball', 'faucet', 'iron', 'bed', 'coffe_maker', 'wooden_spoon', 'cards', 'headset', 'dresser', 'napkin', 'spoon', 'vase', 'instrument_violin', 'laser_pointer', 'creditcard'] Task:Receive credit card response: { thoughts : hear the dooble, go to door, take de envelope, open it with a scissor, take the creditcard, actions : ['[WALK] <home_office>', '[WALK] <envelope>', '[FIND] <envelope>', '[GRAB] <envelope>', '[WALK] <home_office>', '[WALK] <scissors>', '[FIND] <scissors>', '[OPEN] <envelope>', '[FIND] <creditcard>', '[GRAB] <creditcard>'] } Scene_Objects:['filing_cabinet', 'mop', 'chair', 'band-aids', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'laptop', 'toaster', 'foundation', 'pillow', 'wall', 'powersocket', 'bench', 'novel', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'napkin', 'light', 'soap', 'instrument_violin'] Task:Turn off light response: | { Grasp light switch, flip light switch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'button', 'brush', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'standingmirror', 'coffe_maker', 'television', 'food_rice', 'wine', 'curtain', 'doorjamb', 'diary', 'pencil', 'door', 'bathroom_cabinet', 'table'] Task:Change TV channel response: { thoughts : walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[GRAB] <button>'] } Scene_Objects:['microwave', 'chair', 'detergent', 'trashcan', 'dough', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'thread', 'clothes_jacket', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'brush', 'wall', 'toilet_paper', 'television', 'wooden_spoon', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'cupboard', 'laundry_detergent', 'light', 'dishwasher', 'board_game', 'clothes_shirt', 'teeth'] Task:Sweep hallway please response: | { Vacuum all the way up and down the hallway. Get all the dirt and crumbs out of carpet please. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Work response: { thoughts : I need to complete work on my computer, so I will be pulling out my chair, turning on my computer and begin my task., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['blender', 'walllamp', 'bathroom', 'trashcan', 'food_carrot', 'drawing', 'floor', 'phone', 'bedroom', 'stamp', 'keyboard', 'table_cloth', 'stovefan', 'ceilinglamp', 'window', 'couch', 'towel', 'wall', 'oven', 'bed', 'photoframe', 'clothes_gloves', 'television', 'doorjamb', 'laundry_detergent', 'door', 'maindoor', 'home_office', 'table', 'clothes_shirt'] Task:Read magazine response: | { Please sit on the couch and read a magazine } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'newspaper', 'television', 'curtain', 'rag', 'doorjamb', 'mouse', 'door', 'bathtub', 'table'] Task:Use computer response: { thoughts : Browse reddit, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'orchid', 'drawing', 'knifeblock', 'floor', 'folder', 'envelope', 'table_cloth', 'mop_bucket', 'stovefan', 'brush', 'ceilinglamp', 'window', 'foundation', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'newspaper', 'light_bulb', 'food_donut', 'wooden_spoon', 'doorjamb', 'door', 'maindoor', 'napkin', 'light'] Task:Put toys away response: | { Pick up all the toys on the floor and put them in their correct storage bin or shelf. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'spectacles', 'scissors', 'knife', 'hanger', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'keyboard', 'piano_bench', 'stovefan', 'stereo', 'window', 'wall', 'powersocket', 'cutting_board', 'cup', 'bed', 'console', 'pencil', 'shoes', 'door', 'bathtub', 'bag', 'instrument_guitar', 'table', 'home_office', 'light', 'board_game'] Task:Listen to music response: { thoughts : I walk into my room and turn the radio on so that I can listen to music., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'cat', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'food_bacon', 'stovefan', 'ceilinglamp', 'iron', 'dustpan', 'pillow', 'wall', 'toy', 'box', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cd', 'dresser', 'cupboard', 'light', 'table'] Task:Vacuum response: | { Plug in the vacuum. Turn it on. Push it back and forth across the floor until all the debris is gone. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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', 'food_bread', 'food_pizza', 'dog', 'freezer', 'bathroom', 'trashcan', 'milk', 'knife', 'orchid', 'floor', 'ceiling', 'bedroom', 'purse', 'toaster', 'ceilinglamp', 'faucet', 'balanceball', 'garbage_can', 'food_dessert', 'wall', 'nightstand', 'oven', 'tape', 'food_cheese', 'food_vegetable', 'novel', 'toothbrush_holder', 'ice', 'colander'] Task:Rotate stock in refrigerator response: | { Throw out expired items, put older items in front. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'freezer', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'shampoo', 'bedroom', 'bookshelf', 'thread', 'mop_bucket', 'tvstand', 'faucet', 'mousepad', 'towel', 'powersocket', 'bed', 'coffe_maker', 'television', 'oven_mitts', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'maindoor', 'home_office', 'bathroom_cabinet', 'table'] Task:Pick up phone response: { thoughts : Enter living room. Walk to telephone. Pick up from hook., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'beer', 'measuring_cup', 'chair', 'ground_coffee', 'knifeblock', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mail', 'toaster', 'picture', 'dustpan', 'wall', 'bench', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'after_shave', 'dresser', 'maindoor', 'dishwasher'] Task:Make coffee response: | { Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'toilet', 'chair', 'walllamp', 'bathroom', 'ground_coffee', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'bookshelf', 'toaster', 'tvstand', 'faucet', 'shower', 'foundation', 'mousepad', 'wall', 'cup', 'newspaper', 'bed', 'coffe_maker', 'doorjamb', 'dresser', 'conditioner', 'door', 'light', 'dishwasher', 'tooth_paste'] Task:Change TV channel response: { thoughts : take remote control, push change channel button, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>'] } Scene_Objects:['pot', 'juice', 'food_ice_cream', 'beer', 'food_oatmeal', 'microwave', 'freezer', 'walllamp', 'ground_coffee', 'milk', 'knifeblock', 'drawing', 'food_egg', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'toaster', 'food_peanut_butter', 'candle', 'pillow', 'bowl', 'wall', 'bench', 'cup', 'newspaper', 'food_food', 'coffe_maker', 'check', 'food_onion', 'cards', 'kitchen_counter', 'cupboard', 'sink', 'table', 'dishwasher', 'laser_pointer'] Task:Cook some food response: | { Put oatmeal into a bowl. Add milk. Heat in a microwave. Put pod of coffee into a coffee maker. Activate. Pour juice into a 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:['scissors', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'thread', 'stovefan', 'mat', 'faucet', 'towel', 'dining_room', 'wall', 'wall_clock', 'oven', 'bench', 'nightstand', 'check', 'coffee_filter', 'tray', 'shaving_cream', 'towel_rack', 'pencil', 'mouse', 'sink', 'bathroom_cabinet', 'soap'] Task:Wash hands response: { thoughts : I walk into the bathroom. Walk to the sink. Turn on tap. Get soap. Wash and rinse hands. Turn off tap. Dry hands., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[LOOKAT] <sink>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[RINSE] <soap>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>'] } Scene_Objects:['glue', 'pot', 'tablelamp', 'detergent', 'cat', 'knife', 'drawing', 'hanger', 'bathroom_counter', 'desk', 'food_cake', 'purse', 'envelope', 'piano_bench', 'stovefan', 'toaster', 'stereo', 'balanceball', 'floor_lamp', 'powersocket', 'love_seat', 'newspaper', 'bed', 'photoframe', 'video_game_controller', 'diary', 'maindoor', 'light', 'soap', 'board_game'] Task:Read response: | { Sit on an easy chair. Turn on music. Take a book and read. Turn on lamp at night. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'window', 'mousepad', 'form', 'dining_room', 'wall', 'cutting_board', 'bed', 'clothes_gloves', 'check', 'television', 'oven_mitts', 'curtain', 'mouse', 'hair', 'napkin', 'vase', 'instrument_violin', 'laser_pointer'] Task:Gaze out window response: { thoughts : Look at the yard from the window, actions : ['[WALK] <home_office>', '[WALK] <window>', '[FIND] <window>', '[TURNTO] <window>', '[LOOKAT] <window>'] } Scene_Objects:['mop', 'bathroom', 'detergent', 'trashcan', 'food_carrot', 'knifeblock', 'floor', 'bedroom', 'thread', 'computer', 'brush', 'plate', 'picture', 'window', 'mousepad', 'clothes_hat', 'pillow', 'wall', 'box', 'bed', 'television', 'curtain', 'food_onion', 'kitchen_counter', 'maindoor', 'table', 'light', 'clothes_shirt', 'dirt', 'teeth'] Task:Read book response: | { Climb into bed, then read the novel } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'trashcan', 'drawing', 'orchid', 'ceiling', 'bedroom', 'mail', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'wall_clock', 'basket_for_clothes', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'door', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'washing_machine'] Task:Wash clothes response: { thoughts : Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on., actions : ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'mousepad', 'couch', 'wall', 'bed', 'food_food', 'tray', 'after_shave', 'rag', 'doorjamb', 'maindoor', 'bathroom_cabinet', 'dishwasher', 'vase'] Task:Put away groceries response: | { Place groceries in refrigerator from shopping at the grocery store. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'fork', 'tablelamp', 'tea', 'band-aids', 'bathroom', 'drawing', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'remote_control', 'computer', 'food_bacon', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_pants', 'pillow', 'wall', 'standingmirror', 'television', 'curtain', 'doorjamb', 'table', 'soap'] Task:Change TV channel response: { thoughts : I push my body to be near to the table in front of me, without stand up. I move my right hand to near the TV remote control on the table. I take the TV remote control. I look the number on the remote control. I touch number 3 button. I put back the remote control to the table. I put my body back to the sofa, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[GRAB] <remote_control>', '[TOUCH] <remote_control>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'phone', 'desk', 'stamp', 'keyboard', 'bookshelf', 'computer', 'table_cloth', 'ceilinglamp', 'balanceball', 'faucet', 'mousepad', 'wall', 'nightstand', 'bench', 'check', 'doorjamb', 'mouse', 'controller', 'maindoor', 'light', 'dishwasher'] Task:Research response: | { I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['freezer', 'walllamp', 'bathroom', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'shampoo', 'tvstand', 'faucet', 'stereo', 'clothes_socks', 'couch', 'clothes_pants', 'cutting_board', 'basket_for_clothes', 'photoframe', 'food_food', 'video_game_controller', 'coffe_maker', 'coffee_filter', 'television', 'tray', 'curtain', 'shaving_cream', 'laundry_detergent', 'maindoor', 'spoon', 'home_office', '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:['measuring_cup', 'microwave', 'toilet', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'phone', 'food_cake', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'stereo', 'electric_shaver', 'homework', 'balanceball', 'picture', 'window', 'dining_room', 'powersocket', 'cup', 'photoframe', 'mirror', 'tray', 'pencil', 'shoes', 'conditioner', 'sink', 'creditcard'] Task:Shave response: | { Pick up razor. Push the button to turn it on. Move it in a linear motion against the beard growth. Make sure to get the bottom of your chin, your cheeks, and mustache area. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'juice', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'picture', 'homework', 'mousepad', 'wall', 'oven', 'toy', 'newspaper', 'check', 'television', 'mouse', 'laundry_detergent', 'conditioner', 'laser_pointer'] Task:Push in desk chair response: { thoughts : Push the desk chair until it is under the desk., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[TOUCH] <chair>', '[PUSH] <chair>'] } Scene_Objects:['fork', 'pot', 'food_bread', 'scissors', 'microwave', 'freezer', 'milk', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'food_bacon', 'ceilinglamp', 'shower', 'faucet', 'bowl', 'food_kiwi', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'diary', 'dishrack', 'controller', 'conditioner', 'home_office'] Task:Get glass of milk response: | { Get an empty glass. Take milk from refrigerator and open it. Pour milk into glass. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'freezer', 'detergent', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'shower', 'faucet', 'window', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'check', 'television', 'food_food', 'ice', 'rag', 'towel_rack', 'kitchen_counter', 'cupboard'] Task:Turn on light response: { thoughts : I go home and it's dark so I can not see anything, actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'walllamp', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'bills', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'fax_machine', 'doorjamb', 'mouse', 'light', 'dishwasher', 'printing_paper'] Task:Print out papers response: | { Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'dresser', 'sink', 'instrument_violin'] Task:Watch TV response: { thoughts : I go to the the living room, sit down on the sofa, and then I switch on the TV with the TV remote, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['pot', 'tablelamp', 'toilet', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'shoe-shine_kit', 'couch', 'wall', 'video_game_controller', 'television', 'coin', 'curtain', 'kitchen_counter', 'headset', 'dresser', 'controller', 'table', 'dishwasher', 'soap'] Task:Watch TV response: | { I sit down on sofa, get the remote, turn on tv, change channel to show I want to watch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : I walk to room. I enter room. I find where the lightswitch is. I turn on the lights with the lightswitch., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[LOOKAT] <light>', '[SWITCHON] <light>'] } Scene_Objects:['ironing_board', 'dry_pasta', 'food_salt', 'toilet', 'freezer', 'band-aids', 'nail_polish', 'detergent', 'food_carrot', 'knifeblock', 'longboard', 'clothes_jacket', 'mat', 'iron', 'mousepad', 'form', 'towel', 'dining_room', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'television', 'ice', 'doorjamb', 'towel_rack', 'home_office', 'light', 'vase', 'clothes_shirt'] Task:Iron shirt response: | { Set up an ironing board and an iron. Lay a shirt on board. Run iron over shirt until it is free of wrinkles. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'mop', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'toaster', 'stereo', 'window', 'wall', 'bed', 'novel', 'coffe_maker', 'coffee_filter', 'water', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'spoon', 'light', 'dishwasher', 'table', 'coffee'] Task:Make coffee response: { thoughts : Go to the kitchen and make coffee., actions : ['[RUN] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[PUTOBJBACK] <coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'freezer', 'detergent', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'wall', 'bench', 'love_seat', 'food_food', 'check', 'television', 'coffe_maker', 'curtain', 'table', 'dishwasher'] Task:Watch TV response: | { Sit and watch the television } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'walllamp', 'ground_coffee', 'detergent', 'trashcan', 'orchid', 'drawing', 'bedroom', 'tea_bag', 'bookshelf', 'envelope', 'alcohol', 'computer', 'ceilinglamp', 'mat', 'shower', 'deck_of_cards', 'food_noodles', 'microphone', 'bowl', 'wall', 'bench', 'powersocket', 'photoframe', 'television', 'dresser', 'napkin', 'table', 'clothes_shirt'] Task:Pet cat response: { thoughts : First I need to find the cat in the living room. Then I walk over to the cat and pet it gently., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'food_salt', 'toilet', 'freezer', 'detergent', 'bills', 'orchid', 'hanger', 'ceiling', 'envelope', 'table_cloth', 'brush', 'mat', 'ceilinglamp', 'shower', 'stovefan', 'nightstand', 'powersocket', 'bench', 'photoframe', 'check', 'food_food', 'wooden_spoon', 'sink', 'napkin', 'instrument_guitar', 'table', 'coffee'] Task:Pull up carpet response: | { Pry up a corner of your old dirty carpet. Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'measuring_cup', 'walllamp', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'broom', 'wall', 'newspaper', 'light_bulb', 'novel', 'television', 'curtain', 'doorjamb', 'lighter', 'cupboard', 'table', 'light'] Task:Change TV channel response: { thoughts : Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>'] } Scene_Objects:['ceilingfan', 'toothbrush', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'longboard', 'mop_bucket', 'mat', 'tvstand', 'faucet', 'couch', 'clothes_pants', 'towel', 'wall', 'basket_for_clothes', 'photoframe', 'light_bulb', 'wooden_spoon', 'after_shave', 'coffee', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'laser_pointer', 'hands_both', 'shoe_rack'] Task:Wash hands response: | { Turn faucet clockwise to turn on water. Place hands under stream of water, pick up soap, rub hands with soap. Put soap back down. Rub hands together with soap on them. Rinse hands under water from faucet. Turn faucet counterclockwise to turn water off. Dry hands by rubbing them on a towel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['water_glass', 'blender', 'food_salt', 'chair', 'walllamp', 'nail_polish', 'bathroom', 'milk', 'drawing', 'wallshelf', 'clothes_underwear', 'bathroom_counter', 'floor', 'character', 'stamp', 'envelope', 'button', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'closetdrawer', 'form', 'coffe_maker', 'water', 'mouse', 'dresser', 'hairbrush', 'cupboard', 'table'] Task:Drink response: { thoughts : walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass, actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[FIND] <water>', '[GRAB] <water>', '[WALK] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['food_bread', 'scissors', 'crayon', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'window', 'homework', 'couch', 'wall', 'child', 'bench', 'photoframe', 'newspaper', 'coffe_maker', 'razor', 'television', 'kitchen_counter', 'cupboard', 'table', 'coffee'] Task:Let baby learn how to walk response: | { The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'chair', 'dog', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'form', 'wall', 'powersocket', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'mouse', 'cupboard', 'bathtub', 'sink', 'table'] Task:Work response: { thoughts : go to home office. turn the computer on. begin working, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['measuring_cup', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'ceilinglamp', 'faucet', 'teeth', 'towel', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'light_bulb', 'toilet_paper', 'television', 'food_donut', 'tray', 'cards', 'towel_rack', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Hand washing response: | { Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'remote_control', 'thread', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'toaster', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'doorjamb', 'pencil', 'dresser', 'door', 'home_office', 'table', 'light'] Task:Change TV channel response: { thoughts : Change the channel on the TV in the living room, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>'] } Scene_Objects:['filing_cabinet', 'microwave', 'blow_dryer', 'cat', 'trashcan', 'toothbrush', 'drawing', 'floor', 'character', 'desk', 'wine_glass', 'ceilinglamp', 'plate', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'food_cheese', 'bed', 'food_food', 'check', 'television', 'coffee_filter', 'curtain', 'door', 'spoon', 'table'] Task:Entertain response: | { Give guests wine, cheese, crackers and sit and talk } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_bread', 'toilet', 'bathroom', 'milk', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'towel', 'wall', 'bench', 'cup', 'photoframe', 'toothbrush_holder', 'water', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'clothes_skirt', 'soap'] Task:Take shower response: { thoughts : Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel., actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[TURNTO] <shower>', '[FIND] <water>', '[RINSE] <water>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <water>', '[FIND] <towel>', '[GRAB] <towel>', '[SCRUB] <towel>'] } Scene_Objects:['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: | { A person brings a book into the living room and sits down in a comfortable chair. If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read. The person begins reading the book until they need to stop for some reason. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'novel', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Browse internet response: { thoughts : I walk to the home office. I sit on the chair. I switch on the computer. I look at my monitor. I open the browsing application by click the application using mouse. I type the book that I need to searching for (using keyboard). I found the book that I need. I read the book. I switch on the printer. I print the information that I get. I read carefully the book information that I got. I switch off the printer. I switch of the computer., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[SWITCHOFF] <fax_machine>', '[SWITCHOFF] <computer>'] } Scene_Objects:['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: | { I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat 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:['sheets', 'water_glass', 'pot', 'spectacles', 'chair', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'ceiling', 'character', 'stovefan', 'mat', 'faucet', 'food_orange', 'wall', 'oven', 'cutting_board', 'food_food', 'water', 'tray', 'food_onion', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'instrument_guitar', 'home_office'] 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:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'ground_coffee', 'trashcan', 'knifeblock', 'orchid', 'floor', 'ceiling', 'folder', 'plate', 'faucet', 'tvstand', 'mousepad', 'candle', 'wall', 'pasta', 'oven', 'colander', 'wine', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'hair', 'sink', 'vase', 'soap'] Task:Wipe down counter response: | { Clean counter } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light'] Task:Greet guests response: { thoughts : Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek., actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>'] } Scene_Objects:['glue', 'food_bread', 'chair', 'freezer', 'band-aids', 'walllamp', 'food_butter', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'button', 'clothes_jacket', 'toaster', 'ceilinglamp', 'microphone', 'wall', 'oven', 'powersocket', 'bed', 'food_food', 'coffe_maker', 'oven_mitts', 'ice', 'tray', 'curtain', 'pencil', 'clothes_dress', 'dishwasher'] Task:Make toast response: | { Place slices of bread in a toaster ,wait for the bread to pop up .Set aside. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : Find book, grab book, fin bookmark, sit down somewhere comfortable, open book, read book, close book after reading., actions : ['[WALK] <desk>', '[FIND] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[FIND] <couch>', '[SIT] <couch>', '[GRAB] <novel>', '[READ] <novel>', '[PUTBACK] <bookmark> <novel>'] } Scene_Objects:['filing_cabinet', 'food_salt', 'crayon', 'measuring_cup', 'tea', 'mop', 'chair', 'nail_polish', 'bathroom', 'hanger', 'shampoo', 'phone', 'character', 'thread', 'tvstand', 'food_peanut_butter', 'bench', 'tape', 'food_food', 'mouthwash', 'razor', 'wooden_spoon', 'curtain', 'lighter', 'controller', 'laundry_detergent', 'door', 'bag', 'dishwasher', 'teeth'] Task:Watch fly response: | { Look around for a fly, often on a wall or ceiling. Follow it's movements. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_bread', 'crayon', 'tea', 'freezer', 'walllamp', 'bathroom', 'detergent', 'blow_dryer', 'drawing', 'floor', 'desk', 'thread', 'mop_bucket', 'tvstand', 'towel', 'wall', 'toy', 'cup', 'check', 'razor', 'food_donut', 'wine', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'laundry_detergent', 'light', 'soap'] Task:Vacuum response: { thoughts : Robot has a vacuum underneath its feat/body that will allow it to clean the surface of the floor., actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[WALK] <dining_room>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[WALK] <home_office>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <filing_cabinet>', '[PUTBACK] <vacuum_cleaner> <filing_cabinet>', '[CLOSE] <filing_cabinet>'] } Scene_Objects:['trashcan', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'toaster', 'mat', 'stereo', 'window', 'food_jam', 'pillow', 'dining_room', 'wall', 'powersocket', 'bed', 'check', 'mouthwash', 'television', 'tray', 'curtain', 'dishrack', 'dresser', 'laundry_detergent', 'hairdryer', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'shoe_rack'] Task:Read book response: | { I lie on my bed and read a book. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'filing_cabinet', 'crayon', 'toilet', 'bathroom', 'nail_polish', 'trashcan', 'food_carrot', 'hanger', 'floor', 'computer', 'toaster', 'window', 'food_jam', 'nightstand', 'oven', 'bench', 'tape', 'photoframe', 'food_food', 'coffe_maker', 'television', 'toilet_paper', 'doorjamb', 'dresser', 'pajamas', 'cupboard', 'door', 'sink', 'home_office'] Task:Listen to music response: { thoughts : I walk into the living room. I find the stereo and turn it on, and I listen to the music., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['chair', 'bathroom', 'drawing', 'clothes_underwear', 'bathroom_counter', 'floor', 'character', 'computer', 'mop_bucket', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'window', 'couch', 'towel', 'dining_room', 'wall', 'newspaper', 'bed', 'television', 'wine', 'rag', 'mouse', 'napkin', 'bathroom_cabinet', 'table', 'dishwasher', 'light', 'soap'] Task:Read book response: | { Pick up a book and open to the last page you were on. Read the book. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'desk', 'food_cake', 'stovefan', 'toaster', 'deck_of_cards', 'faucet', 'candle', 'pillow', 'dining_room', 'oven', 'photoframe', 'check', 'food_food', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'soap', 'board_game', 'clothes_shirt'] Task:Pet cat response: { thoughts : Walk to living room. Find cat. Walk to cat. Pull cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[PULL] <cat>'] } Scene_Objects:['fork', 'dry_pasta', 'food_salt', 'chair', 'drawing', 'bills', 'hanger', 'floor', 'phone', 'ceiling', 'toaster', 'plate', 'wall', 'bench', 'powersocket', 'tape', 'cup', 'bed', 'check', 'food_food', 'tray', 'doorjamb', 'pencil', 'dishrack', 'dresser', 'cupboard', 'door', 'table', 'light', 'laser_pointer'] Task:Eat response: | { Serve food on dinning table in appropriate utensils, sit on the chair, eat } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_pizza', 'toilet', 'detergent', 'toothbrush', 'orchid', 'wallshelf', 'hanger', 'bedroom', 'bookshelf', 'computer', 'shower', 'window', 'cutting_board', 'food_cheese', 'novel', 'check', 'mouthwash', 'toothbrush_holder', 'wine', 'doorjamb', 'pajamas', 'hairdryer', 'maindoor', 'bathtub', 'home_office', 'door', 'clothes_skirt', 'tooth_paste', 'teeth'] Task:Wash teeth response: { thoughts : walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the teeth, actions : ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>'] } Scene_Objects:['microwave', 'bathroom', 'cat', 'ceilingfan', 'woman', 'drawing', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'wall', 'child', 'oven', 'toy', 'bed', 'clothes_gloves', 'television', 'curtain', 'centerpiece', 'kitchen_counter', 'spoon', 'table', 'vase'] Task:Watch movie response: | { Sitting and watching a movie with family } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'scissors', 'tea', 'freezer', 'walllamp', 'knifeblock', 'knife', 'bills', 'floor', 'toaster', 'mat', 'plate', 'stereo', 'picture', 'tvstand', 'dish_soap', 'microphone', 'wall', 'oven', 'cup', 'light_bulb', 'coffe_maker', 'drinking_glass', 'tray', 'mouse', 'cupboard', 'controller', 'maindoor', 'spoon', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into the dishwasher. Turn on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[TURNTO] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['microwave', 'freezer', 'trashcan', 'knifeblock', 'drawing', 'food_egg', 'clothes_underwear', 'orchid', 'bathroom_counter', 'ceiling', 'folder', 'cleaning_solution', 'mat', 'faucet', 'broom', 'wall', 'toy', 'box', 'photoframe', 'bed', 'food_food', 'mirror', 'paper_towel', 'dresser', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'vase'] Task:Clean mirror response: | { First spray the mirrors with Windex or window type spray. Take paper towels and wipe until sparkly clean. If they have streaks, repeat the process. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mop_bucket', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'mouse', 'pencil', 'controller', 'door', 'table', 'teeth'] Task:Work response: { thoughts : walk to home office ,find computer ,switch on computer and work, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['pot', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'video_game_console', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'cup', 'video_game_controller', 'television', 'curtain', 'dishrack', 'napkin', 'table', 'vase', 'scrabble', 'shoe_rack'] Task:Play games response: | { Turn on game. Use controller } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'mousepad', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'curtain', 'mouse', 'door', 'hairdryer', 'sink', 'food_steak', 'light', 'dishwasher', 'spoon', 'table', 'board_game'] Task:Write school paper response: { thoughts : Writing and drafting a paper for class work, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>'] } Scene_Objects:['pot', 'scissors', 'food_salt', 'toilet', 'band-aids', 'drawing', 'orchid', 'clothes_underwear', 'hanger', 'longboard', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'ceilinglamp', 'mat', 'stereo', 'tvstand', 'towel', 'pillow', 'bowl', 'wall', 'nightstand', 'mouthwash', 'dresser', 'clothes_dress', 'maindoor', 'bathroom_cabinet', 'clothes_skirt', 'creditcard'] Task:Hang up jacket response: | { I put clothes on hangers and hang them in the closet } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'spectacles', 'microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'character', 'desk', 'alcohol', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'photoframe', 'light_bulb', 'television', 'curtain', 'kettle', 'napkin', 'bathroom_cabinet', 'table', 'creditcard'] Task:Relax on sofa response: { thoughts : walk to living room, walk to sofa, sit on sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['sponge', 'toilet', 'bathroom', 'trashcan', 'milk', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'clothes_jacket', 'toaster', 'stovefan', 'tvstand', 'picture', 'window', 'dustpan', 'pillow', 'dining_room', 'wall', 'box', 'bed', 'wine', 'curtain', 'kettle', 'home_office', 'light', 'dishwasher'] Task:Look out window response: | { I head into my child's room and look out the window to view the neighborhood from a different area in the house. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'measuring_cup', 'toilet', 'chair', 'drawing', 'food_egg', 'clothes_underwear', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'button', 'shoe-shine_kit', 'shower', 'window', 'broom', 'wall', 'wall_clock', 'powersocket', 'bench', 'standingmirror', 'novel', 'coin', 'doorjamb', 'door', 'light', 'table', 'creditcard'] Task:Read response: { thoughts : We pick out a book from the bookshelf and read it., actions : ['[WALK] <novel>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['fork', 'crayon', 'dog', 'toothbrush', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'faucet', 'shower', 'balanceball', 'mousepad', 'wall', 'pasta', 'powersocket', 'oven', 'nightstand', 'photoframe', 'video_game_controller', 'coffee_filter', 'wooden_spoon', 'console', 'shoes', 'sink', 'bathroom_cabinet', 'tooth_paste', 'teeth'] Task:Brush teeth response: | { Put toothpaste on toothbrush, brush teeth, rinse mouth } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'food_bread', 'walllamp', 'bathroom', 'cpuscreen', 'kitchen_cabinet', 'floor', 'tea_bag', 'toaster', 'mat', 'stereo', 'balanceball', 'dish_soap', 'towel', 'wall', 'oven', 'bed', 'light_bulb', 'novel', 'coffe_maker', 'check', 'coin', 'food_donut', 'tray', 'doorjamb', 'towel_rack', 'sink', 'dishwasher', 'vase', 'clothes_shirt'] Task:Wash dishes with dishwasher response: { thoughts : I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTIN] <dish_soap> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'candle', 'wall', 'nightstand', 'powersocket', 'television', 'doorjamb', 'mouse', 'cupboard', 'sink', 'light', 'colander'] Task:Work response: | { Sit at my computer desk, Turn on Computer. Get online. Work. } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.