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:['tea', 'cat', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'mail', 'alcohol', 'mat', 'faucet', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'bench', 'coffee_filter', 'ice', 'paper_towel', 'conditioner', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'soap', 'hands_both', 'shoe_rack'] Task:Wash hands response: { thoughts : I walk to the bathroom and find the sink. I grab the soap and rub some on my hands. I turn the faucet on and put my hands in the water. I rinse my hands and then turn off the faucet. Then I dry my hands on a paper towel., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <hands_both>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[WIPE] <hands_both>'] } Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'keyboard', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'cupboard', 'door', 'light', 'table'] Task:Gaze out window response: | { Look at the yard from the window } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'tablelamp', 'microwave', 'freezer', 'drawing', 'phone', 'bookshelf', 'toaster', 'stovefan', 'tvstand', 'mousepad', 'couch', 'clothes_hat', 'food_orange', 'wall', 'photoframe', 'clothes_gloves', 'bed', 'check', 'television', 'food_rice', 'tray', 'doorjamb', 'dresser', 'hairdryer', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'door'] Task:Listen to music response: { thoughts : I go to my bedroom, and then I switch on the radio, actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'milk', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'mat', 'window', 'mousepad', 'closetdrawer', 'couch', 'wall', 'nightstand', 'bed', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'home_office', 'light'] Task:Watch movie response: | { Lay on pillows in bed. Turn on laptop. Go to internet on laptop and go to Netflix. Pick a television show on Netflix and hit play. Watch Netflix. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'mat', 'shower', 'window', 'food_kiwi', 'wall', 'bench', 'newspaper', 'food_food', 'coffe_maker', 'food_onion', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'home_office'] Task:Put groceries in Fridge response: { thoughts : walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in fridge., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'cat', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'wall', 'nightstand', 'child', 'oven', 'bench', 'bed', 'novel', 'check', 'curtain', 'doorjamb', 'coffee_pot', 'towel_rack', 'door'] Task:Read book response: | { Read story to children } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'mat', 'tvstand', 'faucet', 'couch', 'pillow', 'wall', 'powersocket', 'bed', 'clothes_gloves', 'novel', 'toilet_paper', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'door', 'napkin', 'bathroom_cabinet', 'light'] Task:Turn off light response: { thoughts : Hit the switch., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHOFF] <light>'] } Scene_Objects:['toilet', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'face', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'wall_clock', 'face_soap', 'food_food', 'coffe_maker', 'tray', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'shoe_rack'] Task:Wash face response: | { Run warm water. Cleanse my face with soap. Rinse my face with water. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'bills', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'television', 'toothbrush_holder', 'wine', 'doorjamb', 'mouse', 'dresser', 'hairbrush', 'controller', 'clothes_dress', 'home_office', 'light', '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:['tablelamp', 'microwave', 'walllamp', 'trashcan', 'drawing', 'needle', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'bed', 'newspaper', 'television', 'curtain', 'kitchen_counter', 'headset', 'table', 'light'] Task:Watch TV response: | { I sit on the couch and watch TV. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['jelly', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'brush', 'stovefan', 'faucet', 'iron', 'couch', 'towel', 'wall', 'powersocket', 'cutting_board', 'photoframe', 'bed', 'television', 'lighter', 'console', 'dresser', 'pajamas', 'door', 'sink', 'bathroom_cabinet', 'table', 'clothes_skirt', 'vase', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands., actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'bathroom', 'hanger', 'bathroom_counter', 'man', 'bookshelf', 'keyboard', 'piano_bench', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'window', 'closetdrawer', 'dining_room', 'photoframe', 'tray', 'curtain', 'food_onion', 'mouse', 'dresser', 'cupboard', 'door', 'sink', 'home_office', 'light', 'clothes_skirt', 'bathroom_cabinet'] Task:Greet guests response: | { When someone knocks I n the door walk through the hallway and greet them. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'crayon', 'tea', 'mop', 'microwave', 'toilet', 'toothbrush', 'drawing', 'knifeblock', 'orchid', 'phone', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'window', 'floor_lamp', 'couch', 'clothes_hat', 'photoframe', 'after_shave', 'food_onion', 'headset', 'chessboard', 'cupboard', 'controller', 'door', 'bathroom_cabinet', 'clothes_skirt'] Task:Switch on lamp response: { thoughts : Press the button so the light comes on., actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'microwave', 'chair', 'walllamp', 'trashcan', 'milk', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'folder', 'desk', 'bedroom', 'alcohol', 'computer', 'mat', 'window', 'closetdrawer', 'candle', 'wall_clock', 'powersocket', 'oven_mitts', 'food_onion', 'shoes', 'door', 'sink', 'table'] 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:['tablelamp', 'microwave', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'piano_bench', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'powersocket', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'light', 'instrument_violin', 'shoe_rack'] Task:Write an email response: { thoughts : Compose an email in the home office., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['spectacles', 'filing_cabinet', 'chair', 'walllamp', 'bathroom', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'oven', 'newspaper', 'bed', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'bathroom_cabinet', 'table'] Task:Use computer response: | { Sit at desk, use the computer mouse } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'measuring_cup', 'microwave', 'freezer', 'ceilingfan', 'milk', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'button', 'toaster', 'faucet', 'picture', 'wall', 'nightstand', 'oven', 'photoframe', 'clothes_gloves', 'coffe_maker', 'food_food', 'curtain', 'centerpiece', 'food_sugar', 'vacuum_cleaner', 'chessboard', 'coffee_cup', 'dishwasher', 'light'] Task:Make coffee response: { thoughts : walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[LOOKAT] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <milk>', '[GRAB] <milk>', '[PUTBACK] <milk> <coffe_maker>', '[FIND] <food_sugar>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>'] } Scene_Objects:['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: | { 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:['glue', 'microwave', 'freezer', 'ground_coffee', 'hanger', 'floor', 'ceiling', 'stamp', 'keyboard', 'toaster', 'plate', 'faucet', 'shower', 'mousepad', 'food_kiwi', 'wall', 'wall_clock', 'oven', 'cutting_board', 'standingmirror', 'photoframe', 'coffe_maker', 'video_game_controller', 'razor', 'coffee_filter', 'water', 'coffee_pot', 'kitchen_counter', 'sink', 'home_office'] Task:Make coffee response: { thoughts : Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['microwave', 'freezer', 'orchid', 'dvd_player', 'desk', 'bedroom', 'food_cake', 'face', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'bed', 'check', 'food_food', 'coffe_maker', 'mirror', 'kitchen_counter', 'dishrack', 'hair', 'clothes_dress', 'sink', 'table'] 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:['dry_pasta', 'food_bread', 'freezer', 'food_carrot', 'milk', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'mousepad', 'garbage_can', 'clothes_hat', 'food_orange', 'food_dessert', 'wall', 'powersocket', 'food_vegetable', 'food_cheese', 'doorjamb', 'lighter', 'mouse', 'coffee', 'door', 'light', 'colander', 'teeth'] Task:Rotate stock in refrigerator response: { thoughts : Throw out expired items, put older items in front., actions : ['[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[TURNTO] <food_bread>', '[LOOKAT] <food_bread>', '[PUTOBJBACK] <food_bread>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[TURNTO] <food_cheese>', '[LOOKAT] <food_cheese>', '[FIND] <garbage_can>', '[PUTBACK] <food_cheese> <garbage_can>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[TURNTO] <food_cheese>', '[LOOKAT] <food_cheese>', '[PUTOBJBACK] <food_cheese>', '[FIND] <food_dessert>', '[TURNTO] <food_dessert>', '[LOOKAT] <food_dessert>', '[PUSH] <food_dessert>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <milk>', '[GRAB] <milk>', '[TURNTO] <milk>', '[LOOKAT] <milk>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>'] } Scene_Objects:['tablelamp', 'microwave', 'toilet', 'ground_coffee', 'trashcan', 'drawing', 'floor', 'character', 'bedroom', 'stovefan', 'mat', 'shower', 'faucet', 'floor_lamp', 'window', 'clothes_hat', 'wall', 'nightstand', 'powersocket', 'wall_clock', 'cup', 'bed', 'curtain', 'console', 'mouse', 'kitchen_counter', 'cupboard', 'bathtub', 'home_office', 'light'] 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:['pot', 'jelly', 'chair', 'freezer', 'bathroom', 'food_carrot', 'knifeblock', 'bathroom_counter', 'keyboard', 'alcohol', 'clothes_jacket', 'stovefan', 'mat', 'toaster', 'stereo', 'picture', 'ceilinglamp', 'dining_room', 'bowl', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'check', 'video_game_controller', 'razor', 'food_food', 'curtain', 'shoes'] Task:Listen to music response: { thoughts : turn radio on, listen to music, actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['tea', 'toilet', 'walllamp', 'bathroom', 'detergent', 'drawing', 'bills', 'floor', 'character', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'stereo', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'powersocket', 'cup', 'bed', 'tray', 'mouse', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'home_office', 'dirt', 'electrical_outlet'] 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:['food_pizza', 'filing_cabinet', 'tablelamp', 'chair', 'freezer', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'purse', 'computer', 'mail', 'toaster', 'tvstand', 'mousepad', 'wall', 'check', 'ice', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'cards', 'dresser', 'cupboard', 'door', 'napkin', 'light', 'scrabble'] Task:Pick up phone response: { thoughts : I walk over to the phone. .I reach my arm out. I open my hand. I place my hand on the phone. I close my fingers around the phone. I pick up the phone., actions : ['[WALK] <phone>', '[TOUCH] <phone>', '[GRAB] <phone>'] } Scene_Objects:['sheets', 'filing_cabinet', 'food_pizza', 'tablelamp', 'blender', 'food_salt', 'blow_dryer', 'trashcan', 'toothbrush', 'cpuscreen', 'hanger', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'purse', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'microphone', 'oven', 'food_food', 'check', 'tray', 'dresser', 'napkin', 'bathroom_cabinet', 'clothes_shirt'] 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:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'wall', 'photoframe', 'newspaper', 'television', 'food_donut', 'food_rice', 'doorjamb', 'mouse', 'cd', 'dresser'] Task:Watch TV response: { thoughts : turn on the tv, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>'] } Scene_Objects:['filing_cabinet', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'faucet', 'closetdrawer', 'pillow', 'nightstand', 'bench', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'after_shave', 'mouse', 'cupboard', 'door', 'bathtub', 'sink', 'light', 'clothes_shirt'] 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:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'walllamp', 'food_butter', 'drawing', 'cpuscreen', 'hanger', 'floor', 'phone', 'desk', 'stamp', 'keyboard', 'computer', 'alcohol', 'toaster', 'laptop', 'mat', 'mousepad', 'wall', 'oven', 'bed', 'mouthwash', 'doorjamb', 'mouse', 'chessboard', 'door', 'clothes_scarf'] Task:Write an email response: { thoughts : walk to home office and switch on laptop and with the useof mouse and keyboard send mail, actions : ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } 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: | { 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:['dry_pasta', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'table_cloth', 'stovefan', 'mat', 'faucet', 'foundation', 'mousepad', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'toy', 'hands_both', 'tray', 'doorjamb', 'towel_rack', 'shaving_cream', 'door', 'sink', 'spoon', 'bathroom_cabinet', 'light', 'teeth'] Task:Wash teeth response: { thoughts : I need to rinse my dentures off and put them back in my mouth., actions : ['[WALK] <bathroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <teeth>', '[GRAB] <teeth>', '[WASH] <teeth>', '[PUTOBJBACK] <teeth>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <towel>', '[SWITCHOFF] <light>'] } Scene_Objects:['food_bread', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'ceiling', 'computer', 'toaster', 'mat', 'stovefan', 'shower', 'faucet', 'couch', 'wall', 'nightstand', 'oven', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'food_onion', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', '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:['pot', 'food_salt', 'microwave', 'toilet', 'chair', 'blow_dryer', 'hanger', 'bathroom_counter', 'ceiling', 'phone', 'desk', 'mail', 'shoe-shine_kit', 'mousepad', 'food_noodles', 'cutting_board', 'cup', 'photoframe', 'bed', 'coffe_maker', 'television', 'curtain', 'centerpiece', 'comb', 'pajamas', 'clothes_dress', 'door', 'home_office', 'light', 'table'] Task:Pet cat response: { thoughts : Walk into the living room, sit down by the cat, put out hand, stroke the cat from head to tail, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['tablelamp', 'freezer', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'bookshelf', 'ceilinglamp', 'tvstand', 'shower', 'mat', 'closetdrawer', 'dining_room', 'wall', 'powersocket', 'oven', 'coffe_maker', 'tray', 'curtain', 'coffee_pot', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'hairdryer'] 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:['sheets', 'tablelamp', 'bathroom', 'cat', 'knifeblock', 'drawing', 'wallshelf', 'phone', 'ceiling', 'character', 'keyboard', 'toaster', 'mat', 'tvstand', 'electric_shaver', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'photoframe', 'novel', 'food_food', 'curtain', 'doorjamb', 'dishrack', 'pajamas', 'door', 'bathtub', 'spoon', 'table'] Task:Pick up phone response: { thoughts : walk to phone, grab phone, pick up phone, put to ear, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'food_bacon', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'toilet_paper', 'check', 'razor', 'curtain', 'doorjamb', 'towel_rack', 'chessboard', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet'] 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:['fork', 'walllamp', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'shampoo', 'dvd_player', 'character', 'keyboard', 'mop_bucket', 'toaster', 'dining_room', 'wall', 'oven', 'cutting_board', 'light_bulb', 'coffe_maker', 'food_food', 'razor', 'tray', 'wooden_spoon', 'pencil', 'dishrack', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'colander', 'laser_pointer'] Task:Wash dishes by hand response: { thoughts : walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <dishrack>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <dishrack> <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['fork', 'tablelamp', 'microwave', 'toilet', 'freezer', 'trashcan', 'food_carrot', 'drawing', 'floor', 'ceiling', 'mat', 'ceilinglamp', 'shower', 'couch', 'wall', 'novel', 'food_food', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'home_office', 'instrument_guitar', 'bathroom_cabinet', 'table', 'dirt'] 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:['food_pizza', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table'] Task:Write an email response: { thoughts : I go to the home office to find the computer. I turn switch computer on , i open the email. i write the email and send it., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['fork', 'pot', 'tea', 'walllamp', 'cat', 'trashcan', 'food_butter', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'shower', 'closetdrawer', 'couch', 'dining_room', 'oven', 'bench', 'bed', 'food_food', 'television', 'food_onion', 'doorjamb', 'cupboard', 'sink', 'bathtub', 'soap', 'laser_pointer'] Task:Walk to room response: | { 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:['filing_cabinet', 'food_salt', 'cat', 'cpuscreen', 'desk', 'bookshelf', 'computer', 'alcohol', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'stereo', 'shower', 'closetdrawer', 'candle', 'basket_for_clothes', 'photoframe', 'food_food', 'check', 'television', 'water', 'curtain', 'lighter', 'doorjamb', 'vacuum_cleaner', 'cupboard', 'home_office', 'table', 'bathroom_cabinet'] Task:Drink response: { thoughts : Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass., actions : ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['toilet', 'chair', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'bills', 'cpuscreen', 'bathroom_counter', 'bedroom', 'computer', 'mail', 'bookmark', 'shower', 'couch', 'towel', 'pillow', 'wall_clock', 'oven', 'powersocket', 'bench', 'bed', 'photoframe', 'television', 'mirror', 'curtain', 'towel_rack', 'kitchen_counter', 'home_office', 'dirt'] 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:['chair', 'ground_coffee', 'bathroom', 'detergent', 'dough', 'knifeblock', 'drawing', 'food_egg', 'floor', 'bedroom', 'keyboard', 'purse', 'mop_bucket', 'stovefan', 'mousepad', 'food_orange', 'bed', 'check', 'toilet_paper', 'food_rice', 'tray', 'shaving_cream', 'mouse', 'cd', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'clothes_skirt', 'creditcard'] 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:['microwave', 'freezer', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'toaster', 'window', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'wall_clock', 'television', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'clothes_shirt'] Task:Organize closet response: | { Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'freezer', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'toaster', 'tvstand', 'faucet', 'mousepad', 'towel', 'wall', 'wall_clock', 'bench', 'powersocket', 'nightstand', 'bed', 'toilet_paper', 'television', 'wine', 'curtain', 'doorjamb', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'clothes_skirt', '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:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'phone', 'mat', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'food_food', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'bathtub'] 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:['chair', 'band-aids', 'trashcan', 'dough', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'mousepad', 'food_orange', 'wall', 'oven', 'keys', 'mouse', 'shoes', 'hair', 'dishwasher', 'vase', 'coffee'] Task:Read book response: { thoughts : find a book to read. sit down. read the book., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['filing_cabinet', 'food_pizza', 'toilet', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'toaster', 'shower', 'faucet', 'closetdrawer', 'clothes_hat', 'pillow', 'wall', 'wall_clock', 'nightstand', 'food_food', 'curtain', 'towel_rack', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'sink', 'home_office', 'light', 'bathroom_cabinet'] Task:Vacuum response: | { Get the vacuum and use it to clean my floors } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'freezer', 'ground_coffee', 'floor', 'ceiling', 'mail', 'food_bacon', 'toaster', 'deck_of_cards', 'faucet', 'window', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toy', 'light_bulb', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'after_shave', 'pencil', 'kitchen_counter', 'pajamas', 'sink', 'light'] Task:Make coffee response: { thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[FIND] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['pot', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'stovefan', 'toaster', 'mat', 'faucet', 'ceilinglamp', 'shower', 'pillow', 'wall', 'wall_clock', 'oven', 'bench', 'powersocket', 'tape', 'coffe_maker', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light'] 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:['sheets', 'toilet', 'freezer', 'cat', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'oil', 'couch', 'clothes_hat', 'wall', 'basket_for_clothes', 'food_food', 'coffe_maker', 'curtain', 'doorjamb', 'towel_rack', 'comb', 'dresser', 'maindoor', 'soap'] Task:Put groceries in Fridge response: { thoughts : I put my groceries into the fridge., actions : ['[WALK] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'knife', 'cpuscreen', 'bathroom_counter', 'floor', 'keyboard', 'face', 'ceilinglamp', 'mat', 'faucet', 'shower', 'mousepad', 'closetdrawer', 'towel', 'bench', 'oven', 'bed', 'coffe_maker', 'television', 'wine', 'tray', 'towel_rack', 'kitchen_counter', 'chessboard', 'hair', 'controller', 'bathtub', 'bathroom_cabinet'] Task:Rain welcome response: | { 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:['scissors', 'food_ice_cream', 'chair', 'bathroom', 'trashcan', 'food_carrot', 'shampoo', 'phone', 'floor', 'stamp', 'bookshelf', 'ceilinglamp', 'window', 'homework', 'couch', 'clothes_pants', 'pillow', 'nightstand', 'cup', 'bed', 'check', 'food_food', 'ice', 'headset', 'cupboard', 'door', 'home_office', 'light', 'dishwasher', 'clothes_shirt'] Task:Pick up phone response: { thoughts : walk to phone, grab phone, pick up phone, put to ear, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['microwave', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'phone', 'ceiling', 'keyboard', 'computer', 'mat', 'tvstand', 'faucet', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'photoframe', 'tray', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table'] 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:['pot', 'microwave', 'walllamp', 'ground_coffee', 'orchid', 'drawing', 'cpuscreen', 'floor', 'phone', 'ceiling', 'toaster', 'ceilinglamp', 'plate', 'tvstand', 'window', 'dish_soap', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'razor', 'tray', 'mouse', 'kitchen_counter', 'cupboard', 'bathtub', 'dishwasher', 'instrument_violin'] Task:Wash dishes with dishwasher response: { thoughts : Go to the kitchen. Find the dishwasher. Open the dishwasher. Find the plates. Load the plates into the dishwasher. Find the soap. Load the soap into the dishwasher. Close the dishwasher. Turn on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['toilet', 'chair', 'walllamp', 'milk', 'drawing', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'check', 'television', 'curtain', 'mouse', 'door', 'home_office', 'table', 'bathroom_cabinet', 'light'] 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:['pot', 'food_salt', 'chair', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'toothbrush', 'needle', 'desk', 'keyboard', 'alcohol', 'tvstand', 'faucet', 'window', 'food_noodles', 'couch', 'form', 'pillow', 'wall', 'wall_clock', 'bench', 'bed', 'curtain', 'cupboard', 'instrument_violin', 'bathtub', 'home_office', 'light', 'board_game'] Task:Pick up phone response: { thoughts : i go find the phone. i pick up the phone, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } 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: | { 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:['tablelamp', 'bathroom', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'purse', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'couch', 'dining_room', 'wall', 'bench', 'food_food', 'coffe_maker', 'television', 'toilet_paper', 'wooden_spoon', 'curtain', 'pencil', 'shoes', 'table', 'light', 'vase'] Task:Change TV channel response: { thoughts : I go the living room, look for my tv remote control, take the control and then sit down on the couch and turn on the TV and push the buttons on the remote control to change the channel., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['sheets', 'filing_cabinet', 'food_butter', 'drawing', 'needle', 'bathroom_counter', 'floor', 'character', 'bedroom', 'bookshelf', 'alcohol', 'computer', 'brush', 'tvstand', 'faucet', 'shower', 'foundation', 'window', 'mousepad', 'bench', 'photoframe', 'television', 'mirror', 'rag', 'towel_rack', 'mouse', 'bathtub', 'light', 'table', 'scrabble'] 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:['sponge', 'chair', 'detergent', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'toaster', 'mat', 'plate', 'faucet', 'ceilinglamp', 'dish_soap', 'wall', 'food_cheese', 'light_bulb', 'novel', 'coffe_maker', 'food_food', 'television', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'shoes', 'dishrack', 'dresser', 'cupboard', 'sink', 'home_office'] Task:Wash dishes response: { thoughts : Put all dirty dishes on one side. Take sponge and cover it in soap. Soap each dish. Rinse each dish with water. Put on drying rack., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[RINSE] <sponge>', '[SQUEEZE] <sponge>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>'] } Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'wall', 'powersocket', 'bench', 'photoframe', 'bed', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'pencil', 'door', 'bathtub', 'napkin', 'home_office', 'table'] 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:['filing_cabinet', 'tablelamp', 'crayon', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'desk', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_orange', 'pillow', 'form', 'dining_room', 'wall', 'bench', 'coffe_maker', 'television', 'rag', 'pencil', 'comb', 'table', 'tooth_paste', 'clothes_shirt', 'scrabble', 'creditcard'] Task:Relax on sofa response: { thoughts : I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>'] } Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'cat', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'clothes_underwear', 'phone', 'ceiling', 'dvd_player', 'desk', 'stovefan', 'faucet', 'shower', 'closetdrawer', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'bed', 'tray', 'mouse', 'dresser', 'home_office'] 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:['scissors', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'ceilinglamp', 'food_noodles', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'headset', 'dresser', 'food_steak', 'sink'] Task:Change TV channel response: { thoughts : change the tv channel, actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['pot', 'filing_cabinet', 'trashcan', 'drawing', 'duster', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'mat', 'tvstand', 'picture', 'window', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'powersocket', 'photoframe', 'food_food', 'curtain', 'doorjamb', 'sink', 'bathroom_cabinet', 'light', 'home_office', 'scrabble'] Task:Dust response: | { Using the duster, lightly dust all hanging pictures on walls in living room. Dust all around surface of picture frame and front of pictures, moving duster back and forth, side to side, until all dust 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:['chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'stovefan', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'tape', 'newspaper', 'bed', 'television', 'doorjamb', 'mouse', 'sink', 'home_office', 'table', 'light'] Task:Work response: { thoughts : Walk to home office. Sit on chair. Switch on computer. type in keyboard., actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'toaster', 'window', 'closetdrawer', 'couch', 'pillow', 'food_kiwi', 'wall', 'photoframe', 'light_bulb', 'check', 'television', 'curtain', 'doorjamb', 'dresser', 'bathtub', 'table', 'light'] 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:['pot', 'food_salt', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'phone', 'bookshelf', 'computer', 'toaster', 'tvstand', 'stereo', 'closetdrawer', 'food_peanut_butter', 'clothes_pants', 'form', 'wall', 'oven', 'cup', 'bed', 'mouthwash', 'rag', 'towel_rack', 'kitchen_counter', 'pajamas', 'food_steak', 'door', 'napkin', 'bathroom_cabinet'] Task:Listen to music response: { thoughts : Find the playback device you want to listen to. turn on. press play. enjoyu music., actions : ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>'] } Scene_Objects:['filing_cabinet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'bed', 'coin', 'curtain', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'light'] Task:Wipe down baseboards please response: | { 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:['chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'picture', 'window', 'mousepad', 'oil', 'clothes_hat', 'wall', 'keys', 'food_food', 'coin', 'food_onion', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'table'] Task:Write an email response: { thoughts : I walk into the home office and walk to the desk. I pull out the chair and sit down. I turn on the computer. After the computer is turned on I click on my email program. When the program is loaded I write an email., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['microwave', 'chair', 'trashcan', 'bills', 'knife', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'keyboard', 'bookmark', 'faucet', 'window', 'closetdrawer', 'towel', 'dining_room', 'wall_clock', 'check', 'mouthwash', 'television', 'coffe_maker', 'rag', 'doorjamb', 'mouse', 'pencil', 'dishrack', 'sink', 'bathroom_cabinet', 'table', 'light'] 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:['spectacles', 'sponge', 'filing_cabinet', 'tea', 'chair', 'walllamp', 'bathroom', 'ceilingfan', 'character', 'computer', 'food_bacon', 'mop_bucket', 'balanceball', 'foundation', 'form', 'bowl', 'wall', 'pasta', 'basket_for_clothes', 'bed', 'check', 'doorjamb', 'diary', 'hairbrush', 'cupboard', 'dresser', 'laundry_detergent', 'food_steak', 'light', 'scrabble'] Task:Listen to music response: { thoughts : Listen to music, actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['filing_cabinet', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'purse', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'wall', 'powersocket', 'bench', 'cup', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'door', 'sink', 'bathroom_cabinet', 'light', 'home_office'] Task:Turn off light response: | { 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:['dry_pasta', 'tea', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'pasta', 'powersocket', 'coffe_maker', 'doorjamb', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'home_office', 'table', 'tooth_paste'] Task:Turn on computer response: { thoughts : Push power button., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'desk', 'bookshelf', 'keyboard', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'shower', 'electric_shaver', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'bed', 'television', 'oven_mitts', 'curtain', 'cupboard', 'bathtub', 'home_office', 'table', 'bathroom_cabinet', 'light'] 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:['pot', 'food_bread', 'chair', 'freezer', 'drawing', 'orchid', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'ceilinglamp', 'plate', 'mat', 'stereo', 'shower', 'couch', 'pillow', 'food_kiwi', 'wall', 'pasta', 'bed', 'novel', 'food_food', 'check', 'television', 'console', 'pencil', 'kitchen_counter', 'cupboard', 'table'] Task:Cut bread response: { thoughts : I get a slice of bread, grab a knife, and then cut the piece of bread in half., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <kitchen_cabinet>', '[FIND] <table>', '[PUTBACK] <plate> <table>', '[PUTBACK] <knife> <table>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[CLOSE] <freezer>', '[PUTBACK] <food_bread> <plate>', '[GRAB] <knife>', '[CUT] <food_bread>', '[PUTOBJBACK] <knife>'] } Scene_Objects:['filing_cabinet', 'freezer', 'ground_coffee', 'detergent', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'floor', 'bookshelf', 'computer', 'button', 'mat', 'ceilinglamp', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'wall_clock', 'basket_for_clothes', 'photoframe', 'toothbrush_holder', 'tray', 'doorjamb', 'towel_rack', 'vacuum_cleaner', 'dresser', 'home_office', 'light'] Task:Vacuum response: | { Robot has a vacuum underneath its feat/body that will allow it to clean the surface 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:['filing_cabinet', 'tea', 'microwave', 'cd_player', 'freezer', 'band-aids', 'bathroom', 'food_carrot', 'orchid', 'music_stand', 'phone', 'bookshelf', 'thread', 'mail', 'stereo', 'homework', 'mousepad', 'closetdrawer', 'clothes_hat', 'form', 'broom', 'newspaper', 'photoframe', 'check', 'food_rice', 'food_donut', 'dresser', 'sink', 'napkin', 'light'] Task:Listen to music response: { thoughts : Walk to the living and turn to the music stand. Switch on the CD player to listen to music., actions : ['[WALK] <home_office>', '[WALK] <music_stand>', '[FIND] <music_stand>', '[TURNTO] <music_stand>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>'] } Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'brush', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'bench', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'light'] Task:Turn on computer response: | { Find the power button. Press. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'crayon', 'microwave', 'walllamp', 'knifeblock', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'purse', 'toaster', 'faucet', 'shower', 'homework', 'pillow', 'wall', 'oven', 'water', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'soap', 'teeth'] Task:Wash hands response: { thoughts : walk to kitchen, turn on water, find soap, apply to hand, lather, rinse, dry hands, actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[FIND] <water>', '[RINSE] <water>'] } Scene_Objects:['food_bread', 'microwave', 'toilet', 'freezer', 'trashcan', 'milk', 'drawing', 'floor', 'ceiling', 'phone', 'keyboard', 'mat', 'tvstand', 'shower', 'oil', 'garbage_can', 'form', 'food_dessert', 'food_kiwi', 'wall', 'food_cheese', 'food_vegetable', 'doorjamb', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathroom_cabinet'] 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:['glue', 'sheets', 'filing_cabinet', 'food_bread', 'food_salt', 'microwave', 'chair', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'mail', 'stovefan', 'ceilinglamp', 'mat', 'stereo', 'couch', 'wall', 'powersocket', 'cup', 'check', 'mouthwash', 'food_donut', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'table', 'teeth'] Task:Play games response: { thoughts : I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours., actions : ['[WALK] <home_office>', '[WALK] <board_game>', '[FIND] <board_game>', '[GRAB] <board_game>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <board_game> <table>'] } Scene_Objects:['chair', 'ground_coffee', 'walllamp', 'drawing', 'floor', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'faucet', 'shower', 'closetdrawer', 'wall', 'oven', 'bench', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'curtain', 'doorjamb', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub', 'napkin'] 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:['glue', 'dry_pasta', 'crayon', 'band-aids', 'detergent', 'drawing', 'clothes_underwear', 'table_cloth', 'stovefan', 'laptop', 'toaster', 'faucet', 'ceilinglamp', 'closetdrawer', 'wall', 'nightstand', 'oven', 'keys', 'food_food', 'tray', 'coffee_pot', 'pencil', 'headset', 'door', 'hairdryer', 'sink', 'table', 'dishwasher', 'clothes_shirt', 'creditcard'] Task:Pet cat response: { thoughts : You walk to the living room and find the cat. You look at the cat and touch it to pet it., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['filing_cabinet', 'juice', 'toilet', 'chair', 'bathroom', 'drawing', 'orchid', 'bathroom_counter', 'phone', 'character', 'bedroom', 'toaster', 'mat', 'stereo', 'faucet', 'floor_lamp', 'shower', 'couch', 'dining_room', 'pasta', 'oven', 'powersocket', 'love_seat', 'newspaper', 'photoframe', 'coffe_maker', 'tray', 'dresser', 'bathtub', 'soap'] 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:['filing_cabinet', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'computer', 'mat', 'shoe-shine_kit', 'oil', 'pillow', 'wall', 'pasta', 'powersocket', 'cup', 'food_food', 'video_game_controller', 'toothbrush_holder', 'television', 'doorjamb', 'kettle', 'door', 'light', 'clothes_skirt', 'coffee'] Task:Turn on light response: { thoughts : switching on light in an area, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['fork', 'sheets', 'microwave', 'toilet', 'freezer', 'trashcan', 'food_carrot', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'ceilinglamp', 'shower', 'oil', 'pillow', 'wall', 'novel', 'food_food', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'home_office', 'light'] 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:['walllamp', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'food_noodles', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'pencil', 'hair', 'door', 'table', 'instrument_violin'] Task:Watch TV response: { thoughts : Go to the living room and sit on the couch. Turn on television using remote control. Use remote control buttons to navigate to desired channel. Watch television., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mop_bucket', 'mat', 'laptop', 'window', 'homework', 'mousepad', 'food_orange', 'dining_room', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'bed', 'tray', 'curtain', 'mouse', 'pencil', 'light'] Task:Watch movie response: | { Bring laptop to bed and watch a movie } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'stovefan', 'faucet', 'window', 'mousepad', 'closetdrawer', 'couch', 'towel', 'wall', 'nightstand', 'curtain', 'towel_rack', 'mouse', 'coffee_pot', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : I go to the bathroom and locate the sink. I turn the faucet so that water is running, and rinse my hands briefly. Then I grab the soap and squeeze some onto my hands. I spend a few minutes rubbing my hands together, then I rinse them again. Finally, I turn the faucet off and wipe my hands on a towel., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SQUEEZE] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>'] } Scene_Objects:['pot', 'filing_cabinet', 'chair', 'walllamp', 'bathroom', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'newspaper', 'bed', 'check', 'television', 'doorjamb', 'towel_rack', 'mouse', 'bathtub', 'table'] 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:['toilet', 'walllamp', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'purse', 'stovefan', 'ceilinglamp', 'stereo', 'faucet', 'window', 'balanceball', 'electric_shaver', 'couch', 'wall', 'bench', 'food_food', 'television', 'curtain', 'diary', 'mouse', 'dresser', 'hair', 'bathroom_cabinet', 'table', 'home_office', 'vase', 'teeth', 'shoe_rack'] Task:Relax on sofa response: { thoughts : Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['sheets', 'microwave', 'chair', 'walllamp', 'bills', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'food_food', 'television', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table', 'home_office'] Task:Work response: | { Sit at a desk. Turn on computer. Sign onto mTurk. Perform tasks. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'mop', 'walllamp', 'trashcan', 'wallshelf', 'floor', 'ceiling', 'folder', 'bedroom', 'tvstand', 'shower', 'foundation', 'window', 'mousepad', 'wall', 'powersocket', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'television', 'food_donut', 'curtain', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher'] Task:Take shower response: { thoughts : Walk to the bathroom and wash with the shower., actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[WASH] <shower>'] } Scene_Objects:['juice', 'microwave', 'toilet', 'freezer', 'trashcan', 'food_carrot', 'milk', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'computer', 'mail', 'mat', 'shower', 'pillow', 'dining_room', 'wall', 'nightstand', 'doorjamb', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'table', 'tooth_paste'] 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:['chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'door', 'light', 'table'] Task:Vacuum response: { thoughts : Keep my keyboard vacuumed and free of debris., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'walllamp', 'trashcan', 'drawing', 'knife', 'floor', 'ceiling', 'bedroom', 'keyboard', 'mat', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'food_food', 'television', 'tray', 'curtain', 'console', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'table', 'board_game'] 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:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink'] Task:Use computer response: { thoughts : Browse the internet, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'trashcan', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'purse', 'mail', 'toaster', 'tvstand', 'faucet', 'towel', 'wall', 'nightstand', 'powersocket', 'food_food', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] 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:['dry_pasta', 'pot', 'food_pizza', 'toilet', 'freezer', 'nail_polish', 'detergent', 'longboard', 'floor', 'ceiling', 'bedroom', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'food_peanut_butter', 'form', 'wall', 'nightstand', 'oven', 'food_food', 'ice', 'after_shave', 'doorjamb', 'lighter', 'coffee_pot', 'mouse', 'spoon'] Task:Put groceries in Fridge response: { thoughts : Put groceries into the fridge, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'shampoo', 'character', 'wine_glass', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'couch', 'pillow', 'wall', 'bench', 'powersocket', 'food_cheese', 'food_food', 'coffe_maker', 'television', 'wine', 'curtain', '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:['sheets', 'tablelamp', 'microwave', 'bathroom', 'detergent', 'wallshelf', 'hanger', 'floor', 'character', 'keyboard', 'envelope', 'clothes_jacket', 'stovefan', 'stereo', 'window', 'food_peanut_butter', 'nightstand', 'clothes_gloves', 'food_food', 'food_donut', 'after_shave', 'centerpiece', 'towel_rack', 'cupboard', 'door', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'table', 'home_office'] Task:Put on coat response: { thoughts : I remove my scarf from a coat peg in the entrance hall. I wrap the scarf around my neck, actions : ['[WALK] <home_office>', '[WALK] <hanger>', '[TURNTO] <hanger>', '[LOOKAT] <hanger>', '[FIND] <clothes_scarf>', '[GRAB] <clothes_scarf>', '[PUTON] <clothes_scarf>'] } Scene_Objects:['food_bread', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'toaster', 'mat', 'stovefan', 'shower', 'faucet', 'window', 'couch', 'pillow', 'wall', 'oven', 'coffe_maker', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'food_steak', 'door', 'sink', 'table'] 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', 'microwave', 'toilet', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'tea_bag', 'mat', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'pasta', 'nightstand', 'photoframe', 'novel', 'food_food', 'tray', 'curtain', 'doorjamb', 'door', 'table', 'light', 'board_game'] Task:Read book response: { thoughts : Bring book, lie on the sofa, read book, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[LIE] <couch>', '[READ] <novel>'] } Scene_Objects:['jelly', 'bathroom', 'trashcan', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall_clock', 'newspaper', 'coffe_maker', 'television', 'curtain', 'centerpiece', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathtub', 'sink', 'clothes_scarf', 'light'] 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:['water_glass', 'food_bread', 'bathroom', 'trashcan', 'food_carrot', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'phone', 'folder', 'bedroom', 'desk', 'keyboard', 'toaster', 'bench', 'tray', 'doorjamb', 'diary', 'console', 'mouse', 'towel_rack', 'cd', 'dresser', 'cupboard', 'controller', 'conditioner', 'table', 'vase'] Task:Drink response: { thoughts : walk to kitchen, walk to table, grab water glass and drink water, actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>', '[PUTBACK] <water_glass> <table>'] } Scene_Objects:['tablelamp', 'bathroom', 'drawing', 'floor', 'phone', 'stamp', 'keyboard', 'computer', 'toaster', 'mat', 'tvstand', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'powersocket', 'bed', 'clothes_gloves', 'novel', 'coffe_maker', 'food_donut', 'tray', 'curtain', 'doorjamb', 'cupboard', 'door', 'sink', 'bathtub', 'home_office'] 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', 'microwave', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'bills', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'folder', 'stovefan', 'tvstand', 'window', 'homework', 'wall', 'oven', 'powersocket', 'cutting_board', 'basket_for_clothes', 'food_cheese', 'clothes_gloves', 'check', 'television', 'toothbrush_holder', 'curtain', 'bathroom_cabinet', 'laser_pointer'] Task:Open window response: { thoughts : Unlock the latch at the top. Push the bottom half of the window upwards., actions : ['[WALK] <home_office>', '[WALK] <window>', '[OPEN] <window>'] } Scene_Objects:['filing_cabinet', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'character', 'bookshelf', 'keyboard', 'tvstand', 'shower', 'window', 'closetdrawer', 'wall', 'wall_clock', 'food_cheese', 'photoframe', 'check', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'shredder', 'bathtub', 'sink', 'light', 'table', 'dirt', 'electrical_outlet'] Task:Shred receipts response: | { Take old receipts and put through the shredder } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'food_ice_cream', 'walllamp', 'nail_polish', 'detergent', 'knife', 'needle', 'cpuscreen', 'bathroom_counter', 'character', 'bedroom', 'remote_control', 'envelope', 'alcohol', 'button', 'deck_of_cards', 'iron', 'nightstand', 'pasta', 'television', 'wine', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher', 'vase'] 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:['filing_cabinet', 'toilet', 'chair', 'freezer', 'trashcan', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'window', 'closetdrawer', 'clothes_pants', 'wall', 'bed', 'coffe_maker', 'television', 'tray', 'towel_rack', 'dresser', 'cupboard', 'hair', 'bathtub', 'sink', 'home_office', 'table', 'bathroom_cabinet', 'clothes_shirt'] Task:Get dressed response: | { Get some clothes together that make an appropriate outfit. Put them on } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'bedroom', 'computer', 'alcohol', 'mat', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'bench', 'cutting_board', 'standingmirror', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'chessboard', 'dresser', 'table', 'clothes_skirt'] Task:Watch TV response: { thoughts : Walk into the living room. Sit on the couch. Turn on TV., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['toilet', 'chair', 'jelly', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'homework', 'closetdrawer', 'couch', 'pillow', 'wall', 'newspaper', 'coffe_maker', 'television', 'tray', 'curtain', 'towel_rack', 'cupboard', 'home_office', 'table'] Task:Read newspaper response: | { Read the newspaper on the couch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dog', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'faucet', 'clothes_socks', 'microphone', 'wall', 'bench', 'powersocket', 'photoframe', 'food_rice', 'food_onion', 'towel_rack', 'cd', 'hairbrush', 'controller', 'maindoor', 'sink', 'bathroom_cabinet', 'home_office', 'clothes_skirt', 'vase', 'soap', 'instrument_violin', 'laser_pointer', 'hands_both'] Task:Wash hands response: { thoughts : I go to bathroom, go to sink, turn the water on via faucet, grab soap, use the soap to scrub my hands, put the soap back and wash my hands. Then I stop the water with faucet., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[WASH] <hands_both>'] } Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'food_carrot', 'woman', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'child', 'bed', 'television', 'curtain', 'towel_rack', 'dresser', 'table'] Task:Watch movie response: | { 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', 'pot', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'food_egg', 'wallshelf', 'floor', 'stamp', 'computer', 'alcohol', 'toaster', 'plate', 'shower', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'water', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'spoon', 'instrument_guitar', 'light', 'dishwasher', 'soap', 'scrabble'] Task:Wash dishes with dishwasher response: { thoughts : first i will take all the dishes to the dish washer and with the help of dishwasher and water i will clean all the dishes, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <water>', '[TURNTO] <water>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['crayon', 'chair', 'walllamp', 'drawing', 'floor', 'ceiling', 'video_game_console', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'shower', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'video_game_controller', 'television', 'curtain', 'after_shave', 'mouse', 'kitchen_counter', 'bathtub', 'table', 'soap'] 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:['filing_cabinet', 'measuring_cup', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'oven', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office'] Task:Make coffee response: { thoughts : Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'toy', 'television', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'table'] Task:Pay bills response: | { Check my bills, on the computer, open the appropriate sites, pay my due bills } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'walllamp', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'remote_control', 'mop_bucket', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'cup', 'newspaper', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'shoes', 'dresser', 'door', 'home_office', 'table'] Task:Watch TV response: { thoughts : I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch., actions : ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>'] } Scene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'ceiling', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'child', 'bench', 'coffe_maker', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'home_office', 'table', 'bathroom_cabinet'] Task:Watch TV response: | { Turn on tv. Sit with kids. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'chair', 'bathroom', 'orchid', 'knifeblock', 'floor', 'phone', 'desk', 'keyboard', 'food_cake', 'foundation', 'floor_lamp', 'pillow', 'nightstand', 'powersocket', 'box', 'basket_for_clothes', 'razor', 'tray', 'doorjamb', 'cupboard', 'bathtub', 'spoon', 'home_office', 'table', 'bathroom_cabinet', 'light', 'dishwasher'] Task:Turn on light response: { thoughts : walk to living room, find lamp, switch on., actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>'] } Scene_Objects:['microwave', 'bathroom', 'detergent', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'video_game_console', 'keyboard', 'stovefan', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall_clock', 'oven', 'bed', 'coffe_maker', 'video_game_controller', 'television', 'doorjamb', 'cd', 'cupboard', 'door', 'bathtub', 'bathroom_cabinet', 'light', 'home_office', 'table'] Task:Playing video game response: | { Playing video games on various video game systems such as wii u and xbox } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'stereo', 'picture', 'mat', 'closetdrawer', 'couch', 'dining_room', 'wall_clock', 'bench', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'home_office', 'instrument_guitar'] Task:Turn on light response: { thoughts : I walk into the living room and then I walk to the light switch in there and turn the lights on, actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['juice', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'ceiling', 'desk', 'mop_bucket', 'toaster', 'mat', 'stovefan', 'shower', 'faucet', 'wall', 'wall_clock', 'oven', 'nightstand', 'coffe_maker', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'food_snack', 'door', 'sink', 'bathtub'] Task:Have snack response: | { Pour soda into a glass. Get pretzels out of bag. Eat and drink } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'dough', 'wallshelf', 'hanger', 'floor', 'phone', 'folder', 'desk', 'tea_bag', 'mousepad', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'bed', 'television', 'toothbrush_holder', 'food_onion', 'curtain', 'lighter', 'diary', 'cd', 'dresser', 'controller', 'sink', 'table', 'light', 'dishwasher'] Task:Pick up phone response: { thoughts : Walk to home office 1. Walk over to phone 1 on table 1. Grab phone 1. lift phone 1., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['fork', 'filing_cabinet', 'microwave', 'toilet', 'freezer', 'orchid', 'wallshelf', 'hanger', 'floor', 'stovefan', 'toaster', 'faucet', 'mousepad', 'closetdrawer', 'form', 'dining_room', 'toilet_paper', 'television', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'bathtub', 'spoon', 'bathroom_cabinet', 'table', 'light', 'instrument_violin', 'laser_pointer', 'teeth'] Task:Open door response: | { I walk up to the door. I use my hand to turn the door knob to the left. I pull the door open with the same hand I used to turn the door knob } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'dog', 'toothbrush', 'knifeblock', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'character', 'desk', 'mat', 'tvstand', 'shower', 'homework', 'dining_room', 'wall', 'bed', 'clothes_gloves', 'toothbrush_holder', 'after_shave', 'doorjamb', 'mouse', 'pencil', 'cd', 'tooth_paste', 'shoe_rack'] 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:['sponge', 'filing_cabinet', 'tablelamp', 'bathroom', 'trashcan', 'food_butter', 'cpuscreen', 'desk', 'bookshelf', 'computer', 'mop_bucket', 'mat', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'bench', 'oven', 'powersocket', 'toy', 'photoframe', 'coffe_maker', 'television', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'sink', 'home_office'] Task:Pick up toys response: | { Grab toys off floor. Put it in a container. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'tablelamp', 'mop', 'toilet', 'chair', 'walllamp', 'bathroom', 'food_carrot', 'hanger', 'floor', 'shampoo', 'bookshelf', 'purse', 'computer', 'stovefan', 'toaster', 'shower', 'mousepad', 'dustpan', 'clothes_pants', 'wall', 'cutting_board', 'standingmirror', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'hairbrush', 'door', 'bathtub'] Task:Go to toilet response: { thoughts : Walk to the bathroom. Pull down pants. Use the toilet., actions : ['[WALK] <bathroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[PULL] <clothes_pants>', '[FIND] <toilet>', '[SIT] <toilet>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'freezer', 'walllamp', 'trashcan', 'woman', 'toothbrush', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'desk', 'thread', 'stovefan', 'mat', 'faucet', 'window', 'mousepad', 'couch', 'bench', 'bed', 'tray', 'door', 'bathtub', 'bathroom_cabinet', 'table'] Task:Greet guests response: | { Greet people into my home } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['jelly', 'freezer', 'walllamp', 'bathroom', 'bills', 'needle', 'drawing', 'character', 'table_cloth', 'toaster', 'picture', 'floor_lamp', 'window', 'mousepad', 'microphone', 'food_kiwi', 'wall', 'wall_clock', 'newspaper', 'bed', 'television', 'tray', 'cupboard', 'controller', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office'] Task:Turn on light response: { thoughts : I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it., actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TOUCH] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'food_butter', 'cpuscreen', 'bedroom', 'bookshelf', 'toaster', 'mat', 'deck_of_cards', 'shower', 'brush', 'window', 'clothes_hat', 'pillow', 'dining_room', 'wall_clock', 'bench', 'toy', 'rag', 'doorjamb', 'mouse', 'pencil', 'door', 'bathroom_cabinet', 'home_office', 'light'] Task:Clean response: | { Enter inside kid's room, begin picking up toys from the floor and putting them in a toy box, leave once once. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'conditioner', 'door', 'table'] Task:Check email response: { thoughts : I log onto my computer and then go to the e-mail app, I click on each new email and read them, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>'] } Scene_Objects:['tablelamp', 'microwave', 'toilet', 'cat', 'drawing', 'floor', 'dvd_player', 'bookshelf', 'food_cake', 'keyboard', 'computer', 'bookmark', 'mat', 'shower', 'faucet', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'television', 'curtain', 'towel_rack', 'mouse', 'door', 'sink', 'bathtub', 'light'] Task:Breakfast response: | { I have breakfast in bed, watching tv. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'pot', 'tablelamp', 'chair', 'dog', 'walllamp', 'ceilingfan', 'knifeblock', 'needle', 'bathroom_counter', 'floor', 'computer', 'shoe-shine_kit', 'dustpan', 'box', 'cup', 'bed', 'keys', 'television', 'food_donut', 'tray', 'curtain', 'doorjamb', 'kettle', 'kitchen_counter', 'shoes', 'comb', 'sink', 'bathroom_cabinet', 'board_game'] Task:Brush teeth response: { thoughts : go to the bathroom and brush your teeth, actions : ['[WALK] <bathroom>', '[WALK] <toothbrush>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>'] } Scene_Objects:['tablelamp', 'chair', 'dog', 'trashcan', 'drawing', 'cpuscreen', 'character', 'keyboard', 'bookshelf', 'toaster', 'mat', 'tvstand', 'faucet', 'window', 'mousepad', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'wooden_spoon', 'kettle', 'shaving_cream', 'towel_rack', 'cupboard', 'conditioner', 'bathtub', 'dirt'] Task:Lock door response: | { Turn the lock. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'chair', 'wallshelf', 'hanger', 'floor', 'phone', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'powersocket', 'television', 'coin', 'food_donut', 'ice', 'rag', 'pencil', 'shoes', 'dresser', 'clothes_dress', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'light', 'home_office'] Task:Hang up jacket response: { thoughts : I put clothes on hangers and hang them in the closet, actions : ['[WALK] <bedroom>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[FIND] <hanger>', '[OPEN] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'keyboard', 'computer', 'toaster', 'tvstand', 'floor_lamp', 'window', 'closetdrawer', 'couch', 'towel', 'wall', 'wall_clock', 'food_food', 'doorjamb', 'mouse', 'headset', 'shoes', 'dresser', 'controller', 'bathtub', 'sink', 'home_office', 'light'] Task:Turn night light on response: | { I walk to the dresser and in the middle Io to small battery operated lamp and switch it on } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'drawing', 'wallshelf', 'character', 'remote_control', 'button', 'shower', 'faucet', 'window', 'pillow', 'wall', 'bench', 'newspaper', 'coffee_table', 'photoframe', 'coffe_maker', 'television', 'food_donut', 'tray', 'sink', 'napkin', 'bathroom_cabinet', 'home_office', 'instrument_guitar', 'light'] 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:['spectacles', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'button', 'clothes_jacket', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'bed', 'check', 'food_food', 'food_onion', 'dresser', 'light'] Task:Put on glasses response: | { Put on glasses. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'freezer', 'drawing', 'floor', 'ceiling', 'character', 'toaster', 'plate', 'shower', 'floor_lamp', 'window', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'oven', 'toilet_paper', 'curtain', 'doorjamb', 'towel_rack', 'shoes', 'cd', 'laundry_detergent', 'door', 'light', 'table'] Task:Turn on light response: { thoughts : walk to wall, find light switch, turn on lights, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[WALK] <bedroom>', '[WALK] <light>', '[SWITCHON] <light>'] } Scene_Objects:['tablelamp', 'blender', 'microwave', 'freezer', 'walllamp', 'bathroom', 'orchid', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'mat', 'tvstand', 'faucet', 'window', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'food_cheese', 'bed', 'novel', 'curtain', 'diary', 'dresser', 'bathroom_cabinet'] Task:Read book response: | { Put child in bed, sit down,read book. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['beer', 'microwave', 'toilet', 'chair', 'freezer', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'window', 'pillow', 'wall', 'powersocket', 'oven', 'bench', 'food_cheese', 'bed', 'photoframe', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'lighter', 'kitchen_counter', 'cupboard', 'home_office'] Task:Eat cheese response: { thoughts : Open fridge. Get cheese. Eat it., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[EAT] <food_cheese>'] } Scene_Objects:['filing_cabinet', 'orchid', 'bills', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'desk', 'bookshelf', 'keyboard', 'table_cloth', 'piano_bench', 'ceilinglamp', 'tvstand', 'shower', 'window', 'couch', 'dining_room', 'wall', 'bench', 'photoframe', 'check', 'coffe_maker', 'food_food', 'doorjamb', 'dresser', 'bathtub', 'sink', 'light'] Task:File documents response: | { I file all of my paperwork (including bills, receipts, documents, device instructions, etc.) in my black paperwork case that has many different files in order to organize. I place each piece of paper in its' corresponding subject (as indicated by printed words on each tab). } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'cup', 'photoframe', 'television', 'tray', 'after_shave', 'doorjamb', 'coffee_pot', 'dresser', 'door', 'scrabble'] Task:Watch TV response: { thoughts : watching TV from sofa, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[DROP] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'tea_bag', 'computer', 'food_bacon', 'tvstand', 'iron', 'window', 'electric_shaver', 'mousepad', 'dining_room', 'wall', 'nightstand', 'wall_clock', 'photoframe', 'towel_rack', 'mouse', 'table'] Task:Check email response: | { Sit in teak deck chair, have wooden drawing board on lap, laptop on wooden drawing board, log in to my two email accounts, go through new emails and respond. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'beer', 'walllamp', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'purse', 'food_bacon', 'piano_bench', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'window', 'foundation', 'couch', 'pillow', 'wall', 'bench', 'check', 'wine', 'curtain', 'hairbrush', 'controller', 'door', 'bathroom_cabinet', 'table', 'creditcard'] Task:Relax on sofa response: { thoughts : Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['filing_cabinet', 'toilet', 'bathroom', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'bedroom', 'bookshelf', 'keyboard', 'computer', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'novel', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'light', 'table'] Task:Read response: | { Read a book in the living room } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'scissors', 'tablelamp', 'crayon', 'microwave', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'longboard', 'shampoo', 'dvd_player', 'folder', 'mail', 'bookmark', 'toaster', 'shower', 'homework', 'couch', 'bed', 'clothes_gloves', 'towel_rack', 'mouse', 'pencil', 'cupboard', 'maindoor', 'table', 'laser_pointer'] 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:['microwave', 'toilet', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'television', 'coin', 'doorjamb', 'mouse', 'chessboard', 'bathtub', 'table'] Task:Write school paper response: | { Writing and drafting a paper for class work } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'phone', 'dvd_player', 'character', 'bedroom', 'ceilinglamp', 'balanceball', 'iron', 'window', 'couch', 'food_orange', 'wall', 'tape', 'cup', 'basket_for_clothes', 'check', 'wooden_spoon', 'console', 'mouse', 'kitchen_counter', 'hairbrush', 'food_steak', 'sink', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Wash hands with soap, actions : ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>'] } Scene_Objects:['microwave', 'walllamp', 'drawing', 'bills', 'cpuscreen', 'wallshelf', 'floor', 'desk', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'bench', 'bed', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'door', 'home_office', 'table', 'light'] Task:Relax response: | { Lie down on the couch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'food_ice_cream', 'walllamp', 'nail_polish', 'cat', 'orchid', 'drawing', 'floor', 'ceiling', 'purse', 'alcohol', 'mail', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'towel', 'wall', 'oven', 'cup', 'food_cheese', 'television', 'curtain', 'doorjamb', 'door', 'table', 'clothes_shirt'] Task:Straighten paintings on wall response: { thoughts : Go up to the painting and tilt it which ever way it is uneven until it looks straight., actions : ['[WALK] <home_office>', '[WALK] <wall>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>'] } Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'dining_room', 'wall', 'powersocket', 'oven', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table'] Task:Turn on computer response: | { Push 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:['sheets', 'tablelamp', 'bathroom', 'drawing', 'floor', 'character', 'bedroom', 'stamp', 'computer', 'mat', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'closetdrawer', 'clothes_hat', 'pillow', 'dining_room', 'broom', 'wall', 'bed', 'doorjamb', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'home_office', 'board_game', 'dirt'] Task:Turn on light response: { thoughts : walk to living room ,find electrical outlet , switch on eletrical outlet, actions : ['[WALK] <home_office>', '[WALK] <electrical_outlet>', '[FIND] <electrical_outlet>', '[SWITCHON] <electrical_outlet>'] } Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'walllamp', 'nail_polish', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'character', 'bookshelf', 'alcohol', 'toaster', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'food_food', 'rag', 'mouse', 'kitchen_counter', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'instrument_guitar'] Task:Wash sink response: | { I spray some cleaner and wait a minte or so then wipe it 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:['pot', 'filing_cabinet', 'beer', 'freezer', 'walllamp', 'bathroom', 'bathroom_counter', 'character', 'bedroom', 'desk', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'clothes_pants', 'towel', 'bench', 'basket_for_clothes', 'bed', 'coin', 'food_donut', 'curtain', 'towel_rack', 'mouse', 'cd', 'comb', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', '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', 'juice', 'microwave', 'toilet', 'freezer', 'ceiling', 'clothes_jacket', 'table_cloth', 'toaster', 'stovefan', 'plate', 'faucet', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'table'] Task:Get out dish response: | { Open cupboard. Get out the dish. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tea', 'bathroom', 'ceilingfan', 'milk', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'shoe-shine_kit', 'couch', 'food_jam', 'microphone', 'wall', 'nightstand', 'oven', 'cutting_board', 'television', 'curtain', 'pencil', 'table'] Task:Watch TV response: { thoughts : We sit all around the television and watch a program., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[WATCH] <television>'] } Scene_Objects:['crayon', 'trashcan', 'orchid', 'cpuscreen', 'ceiling', 'bedroom', 'table_cloth', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bench', 'bed', 'novel', 'food_food', 'mouthwash', 'coffe_maker', 'oven_mitts', 'curtain', 'doorjamb', 'cards', 'dresser', 'cupboard', 'bathtub', 'home_office', 'light'] Task:Read book response: | { Go to the book shelf, get a book, open the book and read the book. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'food_pizza', 'chair', 'cat', 'drawing', 'floor', 'tea_bag', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'stovefan', 'window', 'couch', 'food_orange', 'wall', 'food_food', 'television', 'oven_mitts', 'food_onion', 'curtain', 'after_shave', 'comb', 'napkin', 'home_office', 'table', 'dishwasher', 'bathroom_cabinet', 'laser_pointer', 'scrabble'] Task:Relax on sofa response: { thoughts : go to the living room,find the sofa,sat down in the sofa,take some relaxation., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'wallshelf', 'floor', 'phone', 'character', 'bedroom', 'alcohol', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'foundation', 'food_noodles', 'wall', 'nightstand', 'bench', 'oven', 'food_food', 'television', 'curtain', 'rag', 'pencil', 'door', 'clothes_scarf', 'home_office', 'table'] Task:Play games response: | { I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'chair', 'walllamp', 'detergent', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'napkin'] Task:Watch TV response: { thoughts : Find the remote, turn on the TV, watch., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['microwave', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'television', 'doorjamb', 'mouse', 'hairdryer', 'door', 'sink', 'home_office', 'table'] Task:Work response: | { Using desktop computer in home office } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'wall', 'photoframe', 'newspaper', 'television', 'food_donut', 'food_rice', 'doorjamb', 'mouse', 'cd', 'dresser'] Task:Watch TV response: { thoughts : turn on the tv, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>'] } Scene_Objects:['filing_cabinet', 'microwave', 'cd_player', 'chair', 'food_carrot', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'remote_control', 'bookshelf', 'computer', 'mat', 'shower', 'mousepad', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'coffe_maker', 'tray', 'towel_rack', 'mouse', 'coffee_pot', 'dresser', 'cupboard', 'bathtub', 'light'] Task:Listen to music response: | { Walk to CD player and turn it on then go and sit in a chair and turn the remote control on and then listen to some music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'scissors', 'tablelamp', 'freezer', 'trashcan', 'drawing', 'floor', 'shampoo', 'folder', 'bookshelf', 'purse', 'computer', 'window', 'wall', 'powersocket', 'cutting_board', 'cup', 'bed', 'photoframe', 'television', 'curtain', 'food_onion', 'shaving_cream', 'mouse', 'pencil', 'hair', 'maindoor', 'clothes_scarf', 'home_office', 'colander'] Task:Go to sleep response: { thoughts : go t the bedroom and go to sleep, actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>'] } Scene_Objects:['tablelamp', 'microwave', 'freezer', 'walllamp', 'trashcan', 'dough', 'drawing', 'wallshelf', 'floor', 'phone', 'character', 'alcohol', 'mat', 'tvstand', 'ceilinglamp', 'laptop', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'wall_clock', 'powersocket', 'cup', 'photoframe', 'television', 'curtain', 'mouse', 'table'] Task:Relax on sofa response: | { Walk to living room. Find couch. Sit on couch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'filing_cabinet', 'mop', 'toilet', 'dog', 'freezer', 'longboard', 'floor', 'ceiling', 'purse', 'ceilinglamp', 'balanceball', 'faucet', 'foundation', 'food_jam', 'wall', 'oven', 'cup', 'bed', 'novel', 'food_food', 'coffe_maker', 'coffee_filter', 'curtain', 'console', 'pencil', 'maindoor', 'table', 'light', 'dirt'] Task:Put groceries in Fridge response: { thoughts : put away groceries in fridge. open the door, put on shelf, close the door., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'bookmark', 'toaster', 'mat', 'tvstand', 'faucet', 'shower', 'laptop', 'mousepad', 'wall', 'oven', 'powersocket', 'towel_rack', 'kitchen_counter', 'headset', 'door', 'sink', 'bathtub', 'home_office', 'bathroom_cabinet', 'light'] Task:Go to toilet response: | { I go to the bathroom. I locate the toilet. I walk to the toilet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'milk', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'mat', 'window', 'mousepad', 'closetdrawer', 'couch', 'wall', 'nightstand', 'bed', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'home_office', 'light'] Task:Watch movie response: { thoughts : Lay on pillows in bed. Turn on laptop. Go to internet on laptop and go to Netflix. Pick a television show on Netflix and hit play. Watch Netflix., actions : ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <bed>', '[SIT] <bed>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[PUTBACK] <laptop> <bed>', '[LIE] <bed>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>'] } Scene_Objects:['microwave', 'nail_polish', 'detergent', 'orchid', 'drawing', 'hanger', 'floor', 'phone', 'desk', 'button', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'dining_room', 'nightstand', 'wall_clock', 'oven', 'cup', 'photoframe', 'bed', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office'] Task:Listen to music response: | { I go into the living room and turn on the radio. Then, I select the station I want, which is usually a preset. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'faucet', 'picture', 'window', 'dustpan', 'towel', 'wall', 'nightstand', 'photoframe', 'keys', 'toothbrush_holder', 'food_donut', 'mouse', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'vase', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Cleaning hands, actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['tablelamp', 'dog', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'piano_bench', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'towel', 'wall', 'oven', 'coffe_maker', 'television', 'coffee_filter', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub', 'coffee'] 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', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'foundation', 'couch', 'microphone', 'wall', 'powersocket', 'oven', 'bed', 'television', 'wooden_spoon', 'doorjamb', 'lighter', 'dresser', 'door', 'table'] Task:Change TV channel response: { thoughts : I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['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: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'piano_bench', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'powersocket', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'light', 'instrument_violin', 'shoe_rack'] Task:Write an email response: { thoughts : Compose an email in the home office., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'electric_shaver', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'coffe_maker', 'television', 'tray', 'doorjamb', 'mouse', 'bathtub', 'sink', 'home_office', 'table'] Task:Work response: | { Walk to home office, walk to desk, sit in chair, turn on computer, look at computer, click mouse and type on keyboard. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'shoe_rack', 'food_salt', 'mop', 'microwave', 'dog', 'jelly', 'walllamp', 'drawing', 'needle', 'food_egg', 'desk', 'stamp', 'computer', 'ceilinglamp', 'window', 'mousepad', 'food_orange', 'pillow', 'bench', 'cup', 'oven_mitts', 'wooden_spoon', 'pencil', 'dresser', 'maindoor', 'bag', 'table', 'instrument_violin', 'creditcard'] Task:Listen to music response: { thoughts : go to radio. run on radio., actions : ['[WALK] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'stereo', 'window', 'shower', 'mousepad', 'wall', 'powersocket', 'bench', 'clothes_gloves', 'television', 'tray', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'bathtub', 'table'] Task:Work response: | { I walk into home office. I walk to desk. I sit at chair. I turn on computer. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table'] Task:Change TV channel response: { thoughts : Walk into living room. Find television remote control. Pick up remote control. Press button., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'shoe-shine_kit', 'faucet', 'couch', 'form', 'wall', 'bench', 'toy', 'cup', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap'] Task:Wash hands response: | { walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse hands, } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'measuring_cup', 'toilet', 'drawing', 'needle', 'hanger', 'floor', 'computer', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'bed', 'novel', 'food_food', 'video_game_controller', 'coffe_maker', 'tray', 'food_onion', 'doorjamb', 'lighter', 'cd', 'clothes_dress', 'bathroom_cabinet', 'light', 'soap'] Task:Read book response: { thoughts : I would go lie down in my bed and open the book and start reading., actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['filing_cabinet', 'crayon', 'microwave', 'toilet', 'chair', 'trashcan', 'drawing', 'wallshelf', 'bedroom', 'desk', 'keyboard', 'stovefan', 'laptop', 'toaster', 'window', 'closetdrawer', 'couch', 'broom', 'wall', 'powersocket', 'bench', 'photoframe', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'cupboard', 'door'] Task:Read book response: | { go to bedroom, sit down, pick up book, read } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'tea', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'vacuum_cleaner', 'dresser', 'door', 'home_office'] Task:Vacuum response: { thoughts : Keep my keyboard vacuumed and free of debris., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>'] } Scene_Objects:['chair', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'wall_clock', 'television', 'curtain', 'towel_rack', 'mouse', 'dresser', 'bathtub', 'bathroom_cabinet', 'table', 'coffee'] Task:Change TV channel response: | { change the tv channel } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blow_dryer', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'remote_control', 'thread', 'computer', 'alcohol', 'bookmark', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'tape', 'standingmirror', 'bed', 'television', 'curtain', 'doorjamb', 'instrument_guitar', 'table'] Task:Change TV channel response: { thoughts : Changing channel, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[DROP] <remote_control>'] } Scene_Objects:['tablelamp', 'toilet', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'toaster', 'ceilinglamp', 'faucet', 'pillow', 'wall', 'bench', 'bed', 'coffe_maker', 'food_food', 'television', 'mouse', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'soap', 'clothes_shirt', 'hands_both'] Task:Wash hands response: | { Wash Hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'toilet', 'ceilingfan', 'food_egg', 'hanger', 'ceiling', 'dvd_player', 'character', 'thread', 'clothes_jacket', 'toaster', 'deck_of_cards', 'foundation', 'mousepad', 'oil', 'pillow', 'oven', 'toy', 'food_food', 'check', 'lighter', 'centerpiece', 'dishrack', 'coffee', 'hair', 'laundry_detergent', 'maindoor', 'sink', 'door', 'teeth'] Task:Turn on light response: { thoughts : I walk into my bedroom, go to the lamp and use the switch to turn it on., actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TURNTO] <floor_lamp>', '[LOOKAT] <floor_lamp>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['microwave', 'toilet', 'chair', 'bathroom', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'toaster', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'nightstand', 'television', 'toothbrush_holder', 'curtain', 'mouse', 'shoes', 'clothes_dress', 'sink', 'bathroom_cabinet', 'tooth_paste'] Task:Brush teeth response: | { go to bathroom. grab toothbrush. put toothpaste on toothbrush. brush teeth. turn on faucet. rinse toothbrush and mouth. put toothbrush away. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'jelly', 'bathroom', 'detergent', 'dough', 'orchid', 'floor', 'bedroom', 'mat', 'dish_soap', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'ice', 'tray', 'kitchen_counter', 'headset', 'dishrack', 'dresser', 'cupboard', 'door', 'home_office', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I go to the dishwasher and put dish soap. I close the dishwasher and turn it on., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['pot', 'bathroom', 'trashcan', 'food_butter', 'drawing', 'floor', 'ceiling', 'phone', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'sink', 'spoon', 'home_office', 'light'] Task:Turn on light response: | { walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Do homework response: { thoughts : I do my online homework on the computer. I use Pearson My Math Lab for math class and excel for my engineering class., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['blow_dryer', 'cat', 'needle', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'computer', 'mop_bucket', 'mat', 'faucet', 'mousepad', 'teeth', 'towel', 'wall', 'nightstand', 'bench', 'novel', 'doorjamb', 'towel_rack', 'kitchen_counter', 'laundry_detergent', 'door', 'sink', 'bathroom_cabinet', 'light', 'instrument_violin', 'hands_both'] Task:Wash teeth response: | { I need to rinse my dentures off and put them back in my 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:['spectacles', 'juice', 'nail_polish', 'wallshelf', 'floor', 'ceiling', 'face', 'mat', 'iron', 'shower', 'stereo', 'clothes_socks', 'food_jam', 'wall_clock', 'light_bulb', 'food_food', 'razor', 'mirror', 'food_rice', 'curtain', 'centerpiece', 'towel_rack', 'hair', 'clothes_dress', 'napkin', 'bathroom_cabinet', 'home_office', 'table', 'soap', 'shoe_rack'] Task:Check appearance in mirror response: { thoughts : Walk to full-length mirror. Look in mirror. Make sure everything about your appearance is adequate. Adjust clothes as needed., actions : ['[WALK] <bedroom>', '[WALK] <mirror>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[LOOKAT] <mirror>', '[FIND] <face>', '[TURNTO] <face>', '[LOOKAT] <face>', '[FIND] <hair>', '[TURNTO] <hair>', '[LOOKAT] <hair>', '[FIND] <clothes_dress>', '[TURNTO] <clothes_dress>', '[LOOKAT] <clothes_dress>'] } Scene_Objects:['tablelamp', 'toilet', 'bathroom', 'orchid', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'stovefan', 'wall_clock', 'powersocket', 'bed', 'food_food', 'television', 'wooden_spoon', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'hairdryer', 'home_office', 'light', 'clothes_skirt', 'bathtub', 'bathroom_cabinet'] Task:Read book response: | { pick up your book and read it } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'cards', 'dresser', 'door', 'colander'] Task:Change TV channel response: { thoughts : I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['pot', 'microwave', 'detergent', 'toothbrush', 'orchid', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'toaster', 'ceilinglamp', 'window', 'teeth', 'couch', 'pillow', 'nightstand', 'wall_clock', 'wall', 'powersocket', 'cup', 'photoframe', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'home_office', 'table', 'tooth_paste', 'coffee'] Task:Wash teeth response: | { 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 } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.