input
stringlengths 1.39k
2.78k
| thoughts
stringlengths 11
442
|
|---|---|
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'detergent', 'drawing', 'knifeblock', 'food_egg', 'floor', 'computer', 'toaster', 'stovefan', 'tvstand', 'stereo', 'window', 'food_noodles', 'mousepad', 'couch', 'pillow', 'dining_room', 'nightstand', 'pasta', 'bed', 'oven_mitts', 'tray', 'curtain', 'lighter', 'towel_rack', 'shoes', 'cd', 'pajamas'] Task:Put clothes away response: { thoughts : I take clean clothes and either place them in dresser drawers or hang them in a closet., actions : ['[WALK] <bedroom>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[CLOSE] <filing_cabinet>'] } Scene_Objects:['tablelamp', 'tea', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'mop_bucket', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'clothes_pants', 'wall', 'wall_clock', 'oven', 'toy', 'cup', 'water', 'colander', 'tray', 'centerpiece', 'cd', 'maindoor', 'sink', 'bathroom_cabinet', 'home_office', 'vase', 'soap', 'hands_both'] Task:Wash hands response: | { Walk to bathroom. Walk to sink and turn on the water. Grab the soap and wash the hands. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'ground_coffee', 'food_butter', 'toothbrush', 'knifeblock', 'drawing', 'phone', 'keyboard', 'bookshelf', 'table_cloth', 'mat', 'plate', 'electric_shaver', 'window', 'pillow', 'nightstand', 'oven', 'newspaper', 'clothes_gloves', 'photoframe', 'toilet_paper', 'water', 'centerpiece', 'towel_rack', 'kettle', 'pencil', 'clothes_scarf', 'tooth_paste', 'teeth'] Task:Wash teeth response: { thoughts : Walk to bathroom. Find tooth paste, tooth brush and water. Squeeze tooth paste on tooth brush. Wash teeth., actions : ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[FIND] <toothbrush>', '[FIND] <water>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>'] } Scene_Objects:['tablelamp', 'chair', 'freezer', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'bookmark', 'toaster', 'laptop', 'stovefan', 'electric_shaver', 'food_peanut_butter', 'dining_room', 'nightstand', 'oven', 'standingmirror', 'oven_mitts', 'food_onion', 'doorjamb', 'paper_towel', 'shoes', 'maindoor', 'vase', 'hands_both'] Task:Go to toilet response: | { Walking towards Toilet room, And dispose of human waste. Cleaning your hands with tissue paper or water. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_bread', 'microwave', 'chair', 'band-aids', 'woman', 'needle', 'longboard', 'man', 'keyboard', 'envelope', 'toaster', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'nightstand', 'box', 'light_bulb', 'coffe_maker', 'curtain', 'towel_rack', 'shoes', 'dresser', 'hairbrush', 'door', 'vase', 'instrument_violin', 'creditcard'] Task:Greet guests response: { thoughts : Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek., actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>'] } Scene_Objects:['tablelamp', 'juice', 'band-aids', 'freezer', 'bathroom', 'orchid', 'needle', 'wallshelf', 'knife', 'hanger', 'floor', 'ceiling', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'wall', 'oven', 'food_food', 'oven_mitts', 'doorjamb', 'pencil', 'cd', 'dresser', 'door', 'maindoor', 'bathroom_cabinet', 'light', 'clothes_skirt'] Task:Turn on light response: | { Walk to the bedroom and use the button on the wall, next to the door to turn on the lights. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'mop', 'microwave', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'newspaper', 'television', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Browse internet response: { thoughts : Walk to the Home Office. Find the computer. Turn on the computer., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['sheets', 'filing_cabinet', 'measuring_cup', 'chair', 'nail_polish', 'cat', 'drawing', 'hanger', 'floor', 'phone', 'desk', 'keyboard', 'food_bacon', 'table_cloth', 'bookmark', 'stovefan', 'plate', 'shower', 'dish_soap', 'couch', 'wall', 'powersocket', 'basket_for_clothes', 'toilet_paper', 'pencil', 'hair', 'home_office', 'light', 'dishwasher', 'shoe_rack'] Task:Wash dishes with dishwasher response: | { I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'towel', 'wall', 'wall_clock', 'oven', 'television', 'tray', 'rag', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'laser_pointer'] Task:Take shower response: { thoughts : Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower., actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <bathroom_cabinet>', '[FIND] <shower>', '[RINSE] <shower>'] } Scene_Objects:['pot', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'button', 'brush', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'standingmirror', 'coffe_maker', 'television', 'food_rice', 'wine', 'curtain', 'doorjamb', 'diary', 'pencil', 'door', 'bathroom_cabinet', 'table'] Task:Change TV channel response: | { walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'freezer', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'microphone', 'pillow', 'wall', 'wall_clock', 'nightstand', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'home_office', 'table', 'soap'] Task:Relax on sofa response: { thoughts : go to the living room and sit on the couch, ease into the sofa and relax., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['filing_cabinet', 'juice', 'dog', 'orchid', 'floor', 'desk', 'button', 'clothes_jacket', 'mat', 'stereo', 'shower', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toilet_paper', 'mouthwash', 'television', 'curtain', 'after_shave', 'doorjamb', 'hair', 'food_steak', 'napkin', 'home_office', 'table', 'vase'] Task:Listen to music response: | { sitting down to listen to music on the radio } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'trashcan', 'ceilingfan', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'laptop', 'balanceball', 'mousepad', 'pillow', 'wall', 'cup', 'bed', 'television', 'razor', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'spoon', 'light', 'vase'] Task:Turn on light response: { thoughts : push any ligth button to turn it on, for example in the living room, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['dry_pasta', 'filing_cabinet', 'beer', 'chair', 'bills', 'knife', 'hanger', 'bathroom_counter', 'floor', 'computer', 'stovefan', 'mat', 'tvstand', 'window', 'couch', 'pillow', 'towel', 'dining_room', 'food_kiwi', 'wall', 'toy', 'photoframe', 'novel', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'bag', 'table'] Task:Read book response: | { Sit on couch. Grab book. Open book. Read book. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'bathroom', 'ceilingfan', 'knife', 'drawing', 'needle', 'knifeblock', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'phone', 'piano_bench', 'faucet', 'window', 'teeth', 'clothes_pants', 'wall', 'photoframe', 'check', 'oven_mitts', 'tray', 'pencil', 'clothes_dress', 'sink', 'bathroom_cabinet', 'home_office', 'clothes_skirt', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Go to the bathroom and to the sink, turn the faucet on, push the bottle of soap onto your hands and scrub them. Then rinse your hands out and turn the faucet off., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[PUSH] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['pot', 'filing_cabinet', 'chair', 'freezer', 'toothbrush', 'hanger', 'floor', 'ceiling', 'bedroom', 'table_cloth', 'stovefan', 'toaster', 'tvstand', 'mousepad', 'couch', 'pillow', 'nightstand', 'toothbrush_holder', 'tray', 'towel_rack', 'kettle', 'vacuum_cleaner', 'conditioner', 'door', 'bathtub', 'sink', 'food_steak', 'maindoor', 'soap', 'tooth_paste'] Task:Brush teeth response: | { walk to bathroom, look at the toothbrush holder, take toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now brush teeth } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'chair', 'drawing', 'hanger', 'floor', 'phone', 'food_bacon', 'stovefan', 'plate', 'tvstand', 'faucet', 'couch', 'food_jam', 'wall', 'bench', 'powersocket', 'photoframe', 'food_food', 'oven_mitts', 'doorjamb', 'mouse', 'kitchen_counter', 'headset', 'cd', 'dresser', 'cupboard', 'clothes_dress', 'door', 'table', 'light'] Task:Eat dinner response: { thoughts : Sit down at the dinning table with my family and eat dinner., actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[GRAB] <food_food>', '[FIND] <plate>', '[PUTBACK] <food_food> <plate>', '[GRAB] <food_food>', '[PUTOBJBACK] <food_food>', '[FIND] <fork>', '[GRAB] <fork>', '[EAT] <plate>'] } Scene_Objects:['sponge', 'pot', 'filing_cabinet', 'sheets', 'detergent', 'milk', 'hanger', 'phone', 'desk', 'clothes_jacket', 'plate', 'dish_soap', 'mousepad', 'couch', 'candle', 'pillow', 'bowl', 'basket_for_clothes', 'standingmirror', 'keys', 'food_food', 'check', 'razor', 'coffee_filter', 'mouse', 'kitchen_counter', 'controller', 'door', 'bathtub', 'dishwasher'] Task:Wash dishes with dishwasher response: | { Put dishes in the dishwasher and start the dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'scissors', 'milk', 'wallshelf', 'cpuscreen', 'hanger', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'table_cloth', 'stovefan', 'tvstand', 'window', 'closetdrawer', 'candle', 'dining_room', 'wall_clock', 'oven', 'bench', 'photoframe', 'television', 'tray', 'kitchen_counter', 'door', 'bathtub', 'sink', 'table', 'soap', 'creditcard'] Task:Listen to music response: { thoughts : Listen to music, actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['dry_pasta', 'filing_cabinet', 'food_pizza', 'blow_dryer', 'bathroom', 'dough', 'computer', 'ceilinglamp', 'stereo', 'foundation', 'couch', 'pasta', 'powersocket', 'toy', 'cutting_board', 'food_food', 'check', 'coffe_maker', 'after_shave', 'rag', 'curtain', 'shaving_cream', 'shoes', 'controller', 'door', 'bathtub', 'sink', 'bathroom_cabinet', 'laser_pointer', 'creditcard'] Task:Turn on light response: | { Walk over to light switch, flip the switch to the on position } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'walllamp', 'detergent', 'cat', 'milk', 'phone', 'ceiling', 'desk', 'mop_bucket', 'brush', 'ceilinglamp', 'tvstand', 'faucet', 'toaster', 'mat', 'closetdrawer', 'microphone', 'nightstand', 'wall_clock', 'toy', 'cup', 'food_food', 'after_shave', 'lighter', 'towel_rack', 'mouse', 'pajamas', 'controller', 'laundry_detergent', 'soap'] Task:Pet cat response: { thoughts : Go to the living room where the cat sleeps. Find cat. Proceed to petting cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['juice', 'blow_dryer', 'cat', 'toothbrush', 'orchid', 'floor', 'keyboard', 'mat', 'ceilinglamp', 'shoe-shine_kit', 'picture', 'window', 'mousepad', 'couch', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'shelf', 'photoframe', 'television', 'ice', 'curtain', 'after_shave', 'doorjamb', 'diary', 'vacuum_cleaner', 'conditioner', 'home_office', 'table'] Task:Pet cat response: | { I would walk into the living room. Then sit on the couch and pet the cat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'walllamp', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'foundation', 'dustpan', 'pillow', 'broom', 'wall', 'powersocket', 'cup', 'video_game_controller', 'television', 'doorjamb', 'hairbrush', 'door', 'sink', 'bag', 'table'] Task:Watch TV response: { thoughts : Walk to living room. Find remote control. Find television. Point remote at television. Press on button. Watch., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['filing_cabinet', 'toothbrush', 'knife', 'drawing', 'desk', 'bookshelf', 'purse', 'computer', 'table_cloth', 'brush', 'tvstand', 'shoe-shine_kit', 'picture', 'faucet', 'wall', 'bench', 'cutting_board', 'shelf', 'light_bulb', 'razor', 'after_shave', 'doorjamb', 'diary', 'kitchen_counter', 'dishrack', 'dresser', 'home_office', 'table', 'vase', 'dirt'] Task:Wash dishes with dishwasher response: | { Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'pot', 'cd_player', 'toilet', 'blow_dryer', 'floor', 'desk', 'tea_bag', 'remote_control', 'button', 'toaster', 'plate', 'tvstand', 'couch', 'nightstand', 'cup', 'photoframe', 'keys', 'novel', 'check', 'diary', 'vacuum_cleaner', 'cd', 'comb', 'hair', 'clothes_scarf', 'home_office', 'light', 'table', 'creditcard'] Task:Listen to music response: { thoughts : I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton, actions : ['[WALK] <home_office>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[PLUGIN] <cd_player>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'food_butter', 'floor', 'food_cake', 'thread', 'mat', 'shower', 'faucet', 'window', 'oil', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'television', 'curtain', 'doorjamb', 'lighter', 'towel_rack', 'dresser', 'hairbrush', 'laundry_detergent', 'door', 'bathroom_cabinet', 'table', 'light'] Task:Relax on sofa response: | { I get home from work and walk into the living room. I see the couch and go to sit on it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'jelly', 'bathroom', 'knife', 'dvd_player', 'character', 'bedroom', 'thread', 'computer', 'toaster', 'shoe-shine_kit', 'deck_of_cards', 'shower', 'electric_shaver', 'homework', 'food_peanut_butter', 'form', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'novel', 'light_bulb', 'food_food', 'curtain', 'coffee_pot', 'food_steak', 'door', 'light'] Task:Listen to music response: { thoughts : Go to the living room. Find the radio. Turn on the radio., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['food_salt', 'chair', 'ground_coffee', 'food_butter', 'dough', 'drawing', 'floor', 'desk', 'bookmark', 'mat', 'faucet', 'floor_lamp', 'window', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'novel', 'television', 'curtain', 'doorjamb', 'chessboard', 'controller', 'maindoor', 'home_office', 'table'] Task:Read book response: | { First I walk into the living room, I find the lamp and switch it on. Then I find a book, grab it, sit in the sofa, open the book and read it. When I'm finished, I find a bookmark, grab it and put it in the book. Then I close the book, put it back, and switch off the lamp. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'mop', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office'] Task:Social media checks response: { thoughts : Logging on to things like facebook and twitter, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>'] } Scene_Objects:['juice', 'toilet', 'chair', 'bathroom', 'drawing', 'knife', 'wallshelf', 'floor', 'ceiling', 'stamp', 'bookshelf', 'envelope', 'computer', 'shower', 'window', 'wall', 'nightstand', 'oven', 'toy', 'shelf', 'cup', 'standingmirror', 'coffe_maker', 'toothbrush_holder', 'food_donut', 'after_shave', 'dresser', 'bathtub', 'home_office', 'light'] Task:Go to toilet response: | { Walk to bathroom, find 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:['sponge', 'filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'ground_coffee', 'knifeblock', 'hanger', 'floor', 'ceiling', 'purse', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'wall', 'cup', 'razor', 'coin', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher'] Task:Drink response: { thoughts : To go kitchen and find a cup. open the faucet and fill water in the cup and drink., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <cup>', '[GRAB] <cup>', '[TURNTO] <faucet>', '[POINTAT] <faucet>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>'] } Scene_Objects:['food_salt', 'toilet', 'walllamp', 'food_carrot', 'knife', 'wallshelf', 'thread', 'envelope', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'couch', 'pillow', 'broom', 'wall', 'bench', 'powersocket', 'tape', 'shelf', 'basket_for_clothes', 'photoframe', 'bed', 'oven_mitts', 'towel_rack', 'shaving_cream', 'kitchen_counter', 'shoes', 'table', 'shoe_rack'] Task:Listen to music response: | { I walk to the living room. I find a radio there and switch it on to listen to music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'pot', 'food_pizza', 'dry_pasta', 'walllamp', 'trashcan', 'food_carrot', 'dough', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'wall', 'wall_clock', 'oven', 'food_cheese', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher'] Task:Keep an eye on stove as something is cooking response: { thoughts : Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done, actions : ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <pot>', '[TURNTO] <pot>', '[LOOKAT] <pot>', '[FIND] <wall_clock>', '[TURNTO] <wall_clock>', '[LOOKAT] <wall_clock>', '[SWITCHOFF] <oven>'] } Scene_Objects:['mop', 'microwave', 'freezer', 'ground_coffee', 'dough', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'bedroom', 'tea_bag', 'toaster', 'faucet', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toy', 'coffe_maker', 'television', 'coffee_filter', 'water', 'mouse', 'kitchen_counter', 'sink', 'table'] 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:['filing_cabinet', 'trashcan', 'desk', 'keyboard', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'stereo', 'window', 'couch', 'dining_room', 'nightstand', 'wall', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'hairdryer', 'bathtub', 'bathroom_cabinet', 'home_office', 'dishwasher', 'table'] Task:Pick up phone response: { thoughts : walk into room, grab phone, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['food_bread', 'food_pizza', 'microwave', 'dog', 'band-aids', 'orchid', 'wallshelf', 'floor', 'desk', 'mat', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'tape', 'cutting_board', 'bed', 'standingmirror', 'television', 'curtain', 'doorjamb', 'conditioner', 'sink', 'home_office', 'table', 'light', 'bathroom_cabinet', 'soap'] Task:Relax on sofa response: | { I walk to the living room. I see the couch. I sit down on the couch, then lie down and put my feet up. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'clothes_jacket', 'table_cloth', 'mat', 'floor_lamp', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'light_bulb', 'novel', 'mouthwash', 'television', 'ice', 'curtain', 'after_shave', 'doorjamb', 'console', 'kettle', 'conditioner', 'bathtub', 'sink', 'table', 'vase'] Task:Read book response: { thoughts : A person brings a book into the living room and sits down in a comfortable chair. If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read. The person begins reading the book until they need to stop for some reason., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <novel>'] } Scene_Objects:['mop', 'toilet', 'chair', 'walllamp', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'envelope', 'computer', 'clothes_jacket', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'pasta', 'powersocket', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'home_office', 'light', 'table', 'vase'] Task:Work response: | { Type on a computer in the 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:['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:['toilet', 'freezer', 'food_butter', 'floor', 'ceiling', 'desk', 'purse', 'mop_bucket', 'stovefan', 'deck_of_cards', 'iron', 'shower', 'stereo', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'cutting_board', 'bed', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'door', 'hairdryer', 'light', 'table', 'laser_pointer', 'scrabble'] Task:Turn on light response: | { I go into my room, find the light, then turn on the lights. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'beer', 'freezer', 'trashcan', 'orchid', 'floor', 'ceiling', 'bedroom', 'computer', 'toaster', 'window', 'couch', 'candle', 'dining_room', 'broom', 'oven', 'toy', 'check', 'video_game_controller', 'tray', 'kettle', 'coffee_pot', 'mouse', 'cd', 'cupboard', 'controller', 'bathroom_cabinet', 'light', 'dishwasher', 'laser_pointer'] Task:Browse internet response: { thoughts : I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[TOUCH] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>'] } Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'walllamp', 'bathroom', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'stovefan', 'ceilinglamp', 'plate', 'shower', 'tvstand', 'food_noodles', 'bowl', 'wall', 'tape', 'shelf', 'bed', 'check', 'doorjamb', 'kitchen_counter', 'shoes', 'sink', 'light', 'laser_pointer'] Task:Take shower response: | { walk to bathroom , find shower , take a shower } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'trashcan', 'bills', 'knife', 'floor', 'desk', 'mail', 'button', 'toaster', 'plate', 'faucet', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'nightstand', 'oven', 'bed', 'clothes_gloves', 'novel', 'coffe_maker', 'check', 'tray', 'sink', 'table', 'dishwasher', 'shoe_rack'] Task:Wash dishes with dishwasher response: { thoughts : In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['blender', 'toilet', 'chair', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'window', 'mousepad', 'broom', 'wall', 'wall_clock', 'nightstand', 'novel', 'coin', 'lighter', 'centerpiece', 'mouse', 'dresser'] Task:Read book response: | { find a book to read. sit down. 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:['spectacles', 'sheets', 'filing_cabinet', 'food_salt', 'toilet', 'band-aids', 'walllamp', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'phone', 'computer', 'mop_bucket', 'stovefan', 'tvstand', 'deck_of_cards', 'closetdrawer', 'newspaper', 'coffe_maker', 'doorjamb', 'dresser', 'cupboard', 'door', 'food_steak', 'bag', 'sink', 'table', 'dishwasher', 'bathroom_cabinet'] Task:Put umbrella away response: { thoughts : Place the umbrella in the umbrella bucket point first., actions : ['[WALK] <home_office>', '[WALK] <mop_bucket>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'blow_dryer', 'hanger', 'floor', 'phone', 'desk', 'bookshelf', 'food_cake', 'computer', 'ceilinglamp', 'tvstand', 'shower', 'window', 'dining_room', 'wall', 'bench', 'shelf', 'coffe_maker', 'food_food', 'rag', 'kettle', 'pencil', 'cd', 'home_office', 'light', 'bathroom_cabinet', 'instrument_violin'] Task:Go to toilet response: | { I walk into the bathroom. I walk over to the toilet. I sit on 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:['fork', 'water_glass', 'pot', 'walllamp', 'bathroom', 'milk', 'knife', 'knifeblock', 'drawing', 'floor', 'ceiling', 'bedroom', 'toaster', 'stovefan', 'plate', 'shower', 'faucet', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'coffee_cup', 'dishwasher', 'table'] Task:Wash dishes with dishwasher response: { thoughts : I go to the kitchen and put plates, cutlery and glasses into the dishwasher, put the soap, close the machine and switch it on., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <dishwasher>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <dishwasher>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <dishwasher>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[PUTBACK] <water_glass> <dishwasher>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[PUTBACK] <water_glass> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['microwave', 'walllamp', 'detergent', 'floor', 'ceiling', 'toaster', 'faucet', 'stereo', 'electric_shaver', 'window', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'cutting_board', 'coffe_maker', 'television', 'drinking_glass', 'after_shave', 'shaving_cream', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'sink', 'bathroom_cabinet', 'vase', 'clothes_shirt'] Task:Drink response: | { First I go into the kitchen, open the cupboard and find a glass.Then I close the cupboard. Then I go to the sink, turn the faucet on fill the glass under the faucet. I turn off the faucet and then I 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:['tea', 'chair', 'ground_coffee', 'food_butter', 'floor', 'ceiling', 'computer', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'brush', 'stereo', 'mat', 'electric_shaver', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'towel_rack', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher'] 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>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['fork', 'filing_cabinet', 'blow_dryer', 'cat', 'wallshelf', 'ceiling', 'desk', 'bedroom', 'keyboard', 'stovefan', 'mousepad', 'powersocket', 'oven', 'bed', 'food_food', 'check', 'wooden_spoon', 'towel_rack', 'mouse', 'dishrack', 'comb', 'maindoor', 'bathtub', 'napkin', 'home_office', 'light', 'table', 'soap', 'laser_pointer', 'scrabble'] Task:Read book 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:['sheets', 'food_salt', 'chair', 'ground_coffee', 'bathroom', 'floor', 'ceiling', 'button', 'mop_bucket', 'homework', 'window', 'clothes_hat', 'clothes_pants', 'wall', 'toy', 'novel', 'coffe_maker', 'food_food', 'razor', 'wooden_spoon', 'doorjamb', 'diary', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'coffee_cup', 'dishwasher', 'clothes_skirt', 'coffee'] Task:Make coffee response: { thoughts : Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[OPEN] <coffe_maker>', '[POUR] <coffee> <coffe_maker>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>'] } Scene_Objects:['pot', 'food_ice_cream', 'bathroom', 'detergent', 'cat', 'food_butter', 'toothbrush', 'orchid', 'cpuscreen', 'desk', 'bedroom', 'purse', 'envelope', 'mail', 'mop_bucket', 'toaster', 'shower', 'faucet', 'oil', 'food_orange', 'powersocket', 'cutting_board', 'shelf', 'curtain', 'after_shave', 'diary', 'kitchen_counter', 'door', 'napkin', 'tooth_paste'] Task:Wash teeth response: | { before going to bed or when wake up earily morning brush teeth } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'freezer', 'walllamp', 'food_butter', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'stereo', 'faucet', 'window', 'mousepad', 'pillow', 'wall', 'powersocket', 'bed', 'coffee_table', 'television', 'doorjamb', 'pencil', 'dresser', 'clothes_dress', 'door', 'table', 'dishwasher'] Task:Change TV channel response: { thoughts : Walk to the living room and look at the coffee table. Grab the remote control and turn to the television and point the remote control. Put back the remote control., actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <coffee_table>', '[TURNTO] <coffee_table>', '[LOOKAT] <coffee_table>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUTOBJBACK] <remote_control>'] } Scene_Objects:['filing_cabinet', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'purse', 'stovefan', 'mat', 'toaster', 'faucet', 'shower', 'plate', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'oven', 'toy', 'hands_both', 'coin', 'tray', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'home_office', 'soap', 'teeth'] Task:Wash hands response: | { Go to the bathroom. Turn on the sink. Rinse hands. Apply soap and scrub your hands together. Rinse hands again. Turn off faucet. Dry hands 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:['pot', 'filing_cabinet', 'chair', 'bathroom', 'trashcan', 'knifeblock', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'food_cake', 'computer', 'table_cloth', 'tvstand', 'faucet', 'couch', 'oven', 'powersocket', 'cup', 'photoframe', 'check', 'tray', 'curtain', 'wooden_spoon', 'doorjamb', 'door', 'bathtub', 'soap'] Task:Pick up phone response: { thoughts : Walk into the home office. Pick up the phone., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['pot', 'microwave', 'jelly', 'freezer', 'walllamp', 'drawing', 'character', 'tea_bag', 'stovefan', 'mat', 'tvstand', 'stereo', 'shoe-shine_kit', 'window', 'ceilinglamp', 'dustpan', 'food_jam', 'pillow', 'wall', 'wall_clock', 'newspaper', 'coffe_maker', 'food_donut', 'doorjamb', 'coffee_pot', 'cards', 'door', 'bathroom_cabinet', 'colander', 'scrabble'] Task:Listen to music response: | { I reach out arm. I put hand on radio. I turn on radio. I pick a station. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'jelly', 'walllamp', 'bathroom', 'knife', 'wallshelf', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'television', 'toothbrush_holder', 'wooden_spoon', 'kettle', 'shoes', 'cupboard', 'conditioner', 'clothes_dress', 'door', 'napkin', 'light'] Task:Read book response: { thoughts : Pick up a book and open to the last page you were on. Read the book., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <bookmark>', '[READ] <novel>'] } Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'blow_dryer', 'food_carrot', 'drawing', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'toaster', 'shoe-shine_kit', 'window', 'oil', 'food_orange', 'wall', 'wall_clock', 'food_food', 'curtain', 'after_shave', 'doorjamb', 'chessboard', 'door', 'bathtub', 'napkin', 'bathroom_cabinet', 'light', 'vase'] Task:Pick up phone response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'pot', 'sheets', 'food_ice_cream', 'food_salt', 'measuring_cup', 'microwave', 'toilet', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'floor', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'plate', 'window', 'floor_lamp', 'mousepad', 'couch', 'pillow', 'wall', 'clothes_gloves', 'novel', 'check', 'television', 'food_rice', 'doorjamb', 'table'] Task:Read book response: { thoughts : A person brings a book into the living room and sits down in a comfortable chair. If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read. The person begins reading the book until they need to stop for some reason., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <novel>'] } Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'chair', 'freezer', 'food_butter', 'drawing', 'bills', 'desk', 'tea_bag', 'keyboard', 'purse', 'food_cake', 'envelope', 'plate', 'dish_soap', 'mousepad', 'pillow', 'wall_clock', 'powersocket', 'shelf', 'standingmirror', 'check', 'coffe_maker', 'doorjamb', 'towel_rack', 'shaving_cream', 'kitchen_counter', 'dresser', 'sink'] Task:Wash dishes by hand response: | { Pick up dish. Put in soapy water. Wash 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:['scissors', 'crayon', 'chair', 'nail_polish', 'cat', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'computer', 'food_bacon', 'clothes_jacket', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'toy', 'doorjamb', 'kettle', 'mouse', 'dresser', 'hairdryer', 'sink', 'bathroom_cabinet', 'light'] Task:Turn on light response: { thoughts : Coming home turning on lights., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['sheets', 'tablelamp', 'food_salt', 'milk', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'photoframe', 'check', 'mouthwash', 'razor', 'television', 'coin', 'coffe_maker', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'table'] Task:Relax on sofa response: | { I walk into the living room and I lie down on the sofa. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'walllamp', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'longboard', 'character', 'bedroom', 'computer', 'faucet', 'homework', 'clothes_socks', 'food_noodles', 'dining_room', 'photoframe', 'check', 'television', 'after_shave', 'rag', 'lighter', 'towel_rack', 'kitchen_counter', 'dresser', 'clothes_dress', 'home_office', 'light', 'laser_pointer', 'scrabble'] Task:Pick up phone response: { thoughts : I walk to the home office. I find the telephone. I pick up the telephone handset., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>'] } Scene_Objects:['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: | { Walk into the living room. Sit on the couch. Turn on TV. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'measuring_cup', 'freezer', 'walllamp', 'bathroom', 'hanger', 'phone', 'desk', 'bookshelf', 'ceilinglamp', 'shoe-shine_kit', 'balanceball', 'faucet', 'couch', 'nightstand', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'check', 'television', 'food_onion', 'after_shave', 'curtain', 'shaving_cream', 'mouse', 'maindoor', 'sink', 'bag', 'home_office'] Task:Open front door response: { thoughts : Walk over to the front door, turn the knob, and open the door., actions : ['[WALK] <home_office>'] } Scene_Objects:['food_pizza', 'microwave', 'freezer', 'walllamp', 'ground_coffee', 'food_carrot', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'stovefan', 'mat', 'faucet', 'iron', 'oil', 'closetdrawer', 'wall', 'wall_clock', 'oven', 'powersocket', 'cutting_board', 'food_cheese', 'standingmirror', 'coffe_maker', 'food_food', 'wine', 'tray', 'kitchen_counter', 'sink', 'bathroom_cabinet'] Task:Cook some food response: | { go to the kitchen and cook some thing to eat } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'thread', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'photoframe', 'toilet_paper', 'television', 'razor', 'coin', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table'] Task:Turn on computer response: { thoughts : Push power button., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['dry_pasta', 'filing_cabinet', 'food_pizza', 'measuring_cup', 'microwave', 'nail_polish', 'bathroom', 'dough', 'bills', 'bathroom_counter', 'food_bacon', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'stereo', 'window', 'pillow', 'nightstand', 'bench', 'bed', 'clothes_gloves', 'keys', 'television', 'food_rice', 'lighter', 'cd', 'chessboard', 'table', 'light'] Task:Listen to music response: | { Walk into living room. Turn on radio. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', '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: { thoughts : walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse hands,, actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <soap>'] } Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'brush', 'ceilinglamp', 'stereo', 'electric_shaver', 'mousepad', 'closetdrawer', 'food_orange', 'wall', 'powersocket', 'photoframe', 'television', 'wine', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'light', 'table'] Task:Browse internet response: | { walk into Living room, look for computer, walk to computer, turn on computer, grab mouse, click 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:['fork', 'filing_cabinet', 'beer', 'tea', 'freezer', 'shampoo', 'character', 'desk', 'piano_bench', 'ceilinglamp', 'iron', 'picture', 'mousepad', 'couch', 'bowl', 'nightstand', 'wall_clock', 'toy', 'bed', 'coffe_maker', 'television', 'coin', 'after_shave', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'shoes', 'bathroom_cabinet'] Task:Change TV channel response: { thoughts : take remote control, push change channel button, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>'] } Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'crayon', 'drawing', 'hanger', 'floor', 'character', 'bedroom', 'mat', 'window', 'towel', 'pillow', 'wall', 'nightstand', 'cutting_board', 'cup', 'bed', 'toilet_paper', 'food_donut', 'curtain', 'doorjamb', 'mouse', 'shoes', 'chessboard', 'controller', 'laundry_detergent', 'door', 'table', 'vase'] Task:Go to sleep response: | { go t the bedroom and go to sleep } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'jelly', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'toaster', 'mat', 'faucet', 'window', 'couch', 'bowl', 'wall', 'oven', 'cup', 'food_food', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'instrument_violin', 'hands_both'] Task:Wash hands response: { thoughts : Washing hands, actions : ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <cleaning_solution>', '[SQUEEZE] <cleaning_solution>', '[SCRUB] <hands_both>', '[SWITCHON] <faucet>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['filing_cabinet', 'beer', 'toilet', 'cat', 'orchid', 'wallshelf', 'floor', 'desk', 'mat', 'deck_of_cards', 'window', 'couch', 'candle', 'pillow', 'towel', 'wall', 'wall_clock', 'powersocket', 'check', 'coffe_maker', 'television', 'food_food', 'curtain', 'doorjamb', 'vacuum_cleaner', 'controller', 'instrument_guitar', 'table', 'light', 'creditcard'] Task:Relax on sofa response: | { go to living room and lie down on the sofa. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'band-aids', 'bathroom', 'cat', 'orchid', 'wallshelf', 'hanger', 'floor', 'phone', 'character', 'bedroom', 'purse', 'computer', 'table_cloth', 'tvstand', 'powersocket', 'toy', 'clothes_gloves', 'coffe_maker', 'razor', 'food_onion', 'centerpiece', 'headset', 'chessboard', 'cupboard', 'door', 'home_office', 'table', 'laser_pointer'] Task:Open door response: { thoughts : 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, actions : ['[RUN] <home_office>'] } Scene_Objects:['fork', 'tablelamp', 'food_ice_cream', 'toothbrush', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'purse', 'faucet', 'window', 'towel', 'wall', 'toy', 'bed', 'light_bulb', 'novel', 'coffe_maker', 'television', 'water', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'dresser', 'maindoor', 'sink', 'tooth_paste', 'clothes_shirt', 'teeth'] Task:Wash teeth response: | { Walk to bathroom. Find tooth paste, tooth brush and water. Squeeze tooth paste on tooth brush. Wash teeth. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'ceilinglamp', 'floor_lamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'oven', 'photoframe', 'novel', 'television', 'doorjamb', 'dresser', 'cupboard', 'light'] Task:Read book response: { thoughts : A person brings a book into the living room and sits down in a comfortable chair. If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read. The person begins reading the book until they need to stop for some reason., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <novel>'] } Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'food_butter', 'knife', 'wallshelf', 'bathroom_counter', 'phone', 'character', 'bedroom', 'keyboard', 'computer', 'faucet', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'oven', 'shelf', 'cup', 'bed', 'food_rice', 'tray', 'mouse', 'headset', 'comb', 'dresser', 'conditioner', 'home_office', 'table'] Task:Brush teeth response: | { go to the bathroom and brush your teeth } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'bookshelf', 'clothes_jacket', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'shower', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'table'] Task:Relax on sofa response: { thoughts : I walk to the living room and find the sofa. I sit on the sofa and get comfortable., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['tablelamp', 'microwave', 'chair', 'freezer', 'detergent', 'tea_bag', 'food_bacon', 'mop_bucket', 'stereo', 'iron', 'couch', 'pasta', 'powersocket', 'oven', 'wall_clock', 'photoframe', 'coffe_maker', 'mouthwash', 'television', 'food_rice', 'tray', 'after_shave', 'towel_rack', 'kitchen_counter', 'cd', 'dishrack', 'comb', 'dresser', 'clothes_skirt', 'creditcard'] Task:Listen to music response: | { I walk to the radio. I switch on the radio and listen } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['fork', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'food_carrot', 'wallshelf', 'floor', 'ceiling', 'dvd_player', 'stovefan', 'shoe-shine_kit', 'shower', 'couch', 'wall', 'oven', 'powersocket', 'cutting_board', 'food_cheese', 'standingmirror', 'coffe_maker', 'food_food', 'water', 'drinking_glass', 'tray', 'after_shave', 'kitchen_counter', 'home_office', 'teeth'] Task:Drink response: | { im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'beer', 'measuring_cup', 'toilet', 'drawing', 'knife', 'hanger', 'floor', 'desk', 'tea_bag', 'keyboard', 'piano_bench', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'foundation', 'clothes_pants', 'towel', 'wall', 'nightstand', 'novel', 'television', 'tray', 'curtain', 'bag', 'table', 'vase', 'soap'] Task:Wash hands response: { thoughts : BEFORE EATING, actions : ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <towel>', '[WIPE] <towel>'] } Scene_Objects:['tablelamp', 'bathroom', 'knife', 'bathroom_counter', 'floor', 'shampoo', 'ceiling', 'stovefan', 'mat', 'faucet', 'mousepad', 'couch', 'food_peanut_butter', 'dustpan', 'towel', 'wall', 'wall_clock', 'oven', 'novel', 'ice', 'tray', 'rag', 'shoes', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'tooth_paste', 'hands_both'] Task:Wash hands response: | { I go to the sink, turn on the water, put soap on my hands, rub them together, then rinse them off and turn off the water. I then towel off my hands. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'juice', 'dog', 'freezer', 'walllamp', 'ground_coffee', 'knifeblock', 'floor', 'ceiling', 'tea_bag', 'envelope', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'couch', 'food_kiwi', 'wall', 'bed', 'newspaper', 'check', 'coffe_maker', 'food_food', 'curtain', 'kitchen_counter', 'cupboard', 'pajamas', 'food_snack', 'sink', 'coffee'] Task:Have snack response: { thoughts : Pour soda into a glass. Get pretzels out of bag. Eat and drink, actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <juice>', '[GRAB] <juice>', '[POUR] <juice> <cup>', '[PUTIN] <juice> <freezer>', '[CLOSE] <freezer>', '[WALK] <cupboard>', '[OPEN] <cupboard>', '[FIND] <food_snack>', '[GRAB] <food_snack>', '[CLOSE] <cupboard>', '[DRINK] <cup>', '[EAT] <food_snack>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'freezer', 'milk', 'floor', 'remote_control', 'thread', 'button', 'mat', 'stereo', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'tray', 'curtain', 'doorjamb', 'coffee_pot', 'dresser', 'hairbrush', 'sink', 'home_office', 'table', 'bathroom_cabinet', 'laser_pointer'] Task:Change TV channel response: | { go to living room. grab remote control. sit on couch. point remote at tv. push buttons. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table'] Task:Watch TV response: { thoughts : Watching TV, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['food_salt', 'tea', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'broom', 'wall', 'wall_clock', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'light', 'table'] Task:Browse internet response: | { I go to my desk. I turn on the computer. I open a web page and look at it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'food_pizza', 'tablelamp', 'freezer', 'blow_dryer', 'trashcan', 'orchid', 'hanger', 'floor', 'computer', 'button', 'stovefan', 'ceilinglamp', 'window', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'bed', 'novel', 'tray', 'curtain', 'after_shave', 'towel_rack', 'pencil', 'maindoor', 'sink', 'light', 'dishwasher'] Task:Go to sleep response: { thoughts : Walk to bedroom. Walk to bed, lie in bed., actions : ['[WALK] <bedroom>', '[WALK] <bed>', '[LIE] <bed>'] } Scene_Objects:['spectacles', 'tablelamp', 'toilet', 'needle', 'hanger', 'floor', 'ceiling', 'dvd_player', 'stamp', 'desk', 'toaster', 'mat', 'tvstand', 'stereo', 'stovefan', 'electric_shaver', 'ceilinglamp', 'clothes_hat', 'wall_clock', 'powersocket', 'toy', 'photoframe', 'oven_mitts', 'food_donut', 'tray', 'pencil', 'comb', 'door', 'home_office', 'light'] Task:Pick up phone response: | { Go to the living room. Find the telephone. Lift up the receiver. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'orchid', 'hanger', 'ceiling', 'keyboard', 'piano_bench', 'tvstand', 'shower', 'electric_shaver', 'clothes_socks', 'couch', 'wall', 'powersocket', 'bench', 'cutting_board', 'toy', 'photoframe', 'bed', 'razor', 'wooden_spoon', 'after_shave', 'coffee_pot', 'dresser', 'clothes_dress', 'bathtub', 'bathroom_cabinet', 'light', 'clothes_shirt', 'washing_machine', 'shoe_rack'] Task:Wash clothes response: { thoughts : walk to kitchen. grab clothes_dress. look at washing machine. open washing machine. put clothes_dress on washing machine. close washing machine. switch on washing machine. switch off washing machine., actions : ['[WALK] <dining_room>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[TURNTO] <washing_machine>', '[LOOKAT] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>', '[SWITCHOFF] <washing_machine>'] } Scene_Objects:['fork', 'chair', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'shelf', 'novel', 'television', 'food_onion', 'doorjamb', 'kettle', 'mouse', 'kitchen_counter', 'dresser', 'clothes_dress', 'door', 'light', 'table'] Task:Browse internet response: | { turn on the computer and browse the internet } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'fax_machine', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Write report response: { thoughts : Sit at a desk, turn on a computer. Open an existing document and revise it. Print a hard copy for mailing. Email a copy to the client., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[PULL] <mouse>', '[TOUCH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[TYPE] <keyboard>', '[TOUCH] <mouse>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[SWITCHOFF] <fax_machine>', '[SWITCHOFF] <computer>'] } Scene_Objects:['pot', 'tablelamp', 'beer', 'chair', 'band-aids', 'freezer', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'towel', 'pillow', 'wall', 'powersocket', 'clothes_gloves', 'television', 'doorjamb', 'mouse', 'dresser', 'laundry_detergent', 'maindoor', 'bag', 'light', 'table'] Task:Browse internet response: | { Walk to the Home Office. Find the computer. Turn on the computer. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['mop', 'bathroom', 'detergent', 'trashcan', 'food_carrot', 'knifeblock', 'floor', 'bedroom', 'thread', 'computer', 'brush', 'plate', 'picture', 'window', 'mousepad', 'clothes_hat', 'pillow', 'wall', 'box', 'bed', 'television', 'curtain', 'food_onion', 'kitchen_counter', 'maindoor', 'table', 'light', 'clothes_shirt', 'dirt', 'teeth'] Task:Read book response: { thoughts : Climb into bed, then read the novel, actions : ['[WALK] <bedroom>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <bed>', '[LIE] <bed>', '[READ] <novel>'] } Scene_Objects:['spectacles', 'food_salt', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'wall', 'nightstand', 'powersocket', 'toy', 'bed', 'coffe_maker', 'television', 'doorjamb', 'centerpiece', 'mouse', 'dresser', 'hair', 'light', 'table'] Task:Work response: | { Go to office, sit at desk, turn on computer, enter password, open application and begin 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:['walllamp', 'food_carrot', 'drawing', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'shower', 'faucet', 'window', 'oil', 'couch', 'clothes_pants', 'pillow', 'wall', 'tape', 'cup', 'novel', 'tray', 'curtain', 'mouse', 'chessboard', 'controller', 'table'] Task:Read book response: { thoughts : Sit on a couch, grab a book, open it, and scan the pages, actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>'] } Scene_Objects:['sheets', 'microwave', 'cpuscreen', 'hanger', 'floor', 'bookshelf', 'bookmark', 'stovefan', 'mat', 'faucet', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'cutting_board', 'cup', 'newspaper', 'novel', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'hair', 'clothes_dress', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'table'] Task:Relax on sofa response: | { Go to the living room and relax on the sofa with 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:['microwave', 'toilet', 'freezer', 'ground_coffee', 'walllamp', 'dough', 'food_carrot', 'floor', 'ceiling', 'stovefan', 'toaster', 'stereo', 'clothes_hat', 'wall', 'oven', 'bench', 'cutting_board', 'food_cheese', 'coffe_maker', 'food_food', 'check', 'toothbrush_holder', 'food_donut', 'tray', 'kitchen_counter', 'dishrack', 'hairbrush', 'bag', 'bathroom_cabinet', 'creditcard'] Task:Put groceries in Fridge response: { thoughts : Open the fridge, put the groceries in the fridge and close it., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table', 'clothes_skirt'] Task:Write an email response: | { enter office, find computer, 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:['toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'toaster', 'ceilinglamp', 'window', 'floor_lamp', 'couch', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'comb', 'door', 'bathtub', 'bathroom_cabinet', 'coffee'] Task:Turn on light response: { thoughts : Turning on lights, actions : ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['sponge', 'mop', 'chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'bookshelf', 'computer', 'toaster', 'faucet', 'mousepad', 'closetdrawer', 'clothes_hat', 'wall', 'powersocket', 'bed', 'standingmirror', 'television', 'doorjamb', 'cards', 'mouse', 'dresser', 'hair', 'light', 'table'] Task:Turn on light response: | { I walk to wall. I put my hand on the switch. I push the button. I turn on the lights. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'freezer', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'computer', 'food_bacon', 'mat', 'tvstand', 'ceilinglamp', 'plate', 'window', 'shower', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'wine', 'curtain', 'home_office', 'table'] 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:['fork', 'filing_cabinet', 'beer', 'tea', 'freezer', 'shampoo', 'character', 'desk', 'piano_bench', 'ceilinglamp', 'iron', 'picture', 'mousepad', 'couch', 'bowl', 'nightstand', 'wall_clock', 'toy', 'bed', 'coffe_maker', 'television', 'coin', 'after_shave', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'shoes', 'bathroom_cabinet'] Task:Change TV channel response: | { take remote control, push \ change channel\ 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:['tea', 'walllamp', 'ground_coffee', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'check', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'bathroom_cabinet', 'table', 'scrabble', 'coffee', 'creditcard'] Task:Relax on sofa response: { thoughts : Relax on the sofa in the living room., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['sheets', 'tablelamp', 'blender', 'toilet', 'detergent', 'knife', 'hanger', 'floor', 'character', 'food_cake', 'brush', 'mat', 'plate', 'faucet', 'dish_soap', 'oil', 'closetdrawer', 'food_jam', 'dining_room', 'food_kiwi', 'oven', 'powersocket', 'cup', 'after_shave', 'kitchen_counter', 'dishrack', 'pajamas', 'spoon', 'dishwasher', 'vase'] Task:Wash dishes with dishwasher response: | { Walk to kitchen. Find dishwasher. Open dishwasher. Find dishrack. Find plate 1. Grab plate 1. Put plate 1 in dishrack. Repeat for dish 2. Find dish soap. Grab dish soap. Put dish soap to dishwasher. Close dishwasher. Switch on dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'band-aids', 'walllamp', 'drawing', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'plate', 'oil', 'mousepad', 'wall', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'doorjamb', 'door', 'napkin', 'table', 'teeth'] Task:Watch TV response: { thoughts : Watch TV in the living room., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['glue', 'tablelamp', 'measuring_cup', 'microwave', 'chair', 'freezer', 'detergent', 'orchid', 'knife', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'floor', 'desk', 'mop_bucket', 'ceilinglamp', 'floor_lamp', 'food_jam', 'pillow', 'dining_room', 'photoframe', 'keys', 'toothbrush_holder', 'oven_mitts', 'wine', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'dirt'] Task:Turn on light response: | { I walk into my bedroom, go to the lamp and use the switch 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:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'bills', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light'] Task:Watch TV response: { thoughts : Sit on my couch directly opposite my tv , switch on my tv with the remote control and watch, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['microwave', 'freezer', 'walllamp', 'bathroom', 'dough', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookmark', 'stovefan', 'brush', 'deck_of_cards', 'faucet', 'window', 'closetdrawer', 'dining_room', 'wall', 'oven', 'cutting_board', 'cup', 'bed', 'coffe_maker', 'food_food', 'tray', 'shaving_cream', 'kitchen_counter', 'chessboard', 'clothes_dress', 'conditioner'] Task:Drink response: | { Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'food_pizza', 'mop', 'bathroom', 'toothbrush', 'drawing', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'mop_bucket', 'brush', 'toaster', 'faucet', 'stereo', 'couch', 'towel', 'wall', 'powersocket', 'cup', 'photoframe', 'bed', 'mouse', 'dresser', 'sink', 'bathroom_cabinet', 'soap', 'tooth_paste'] Task:Wash teeth response: { thoughts : Upon entering the restroom, walk to the sink. Take a toothbrush and apply enough toothpaste so that 1/4 of the brush is covered (this is the appropriate amount). Proceed to brush your teeth using an up and down motion with the brush in your mouth. Brush for 2 minutes covering all areas of the teeth. Rinse with water and clean toothbrush with water too., actions : ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[SCRUB] <tooth_paste>', '[FIND] <toothbrush>', '[WASH] <toothbrush>', '[FIND] <sink>', '[RINSE] <sink>'] } Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'stovefan', 'mat', 'faucet', 'oil', 'bowl', 'wall', 'wall_clock', 'oven', 'cutting_board', 'clothes_gloves', 'food_food', 'television', 'tray', 'food_onion', 'lighter', 'kitchen_counter', 'dishrack', 'sink', 'bathroom_cabinet', 'teeth'] Task:Cook some food response: | { I switch on the stove and cook my groceries there. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'toilet', 'nail_polish', 'detergent', 'cat', 'trashcan', 'milk', 'knifeblock', 'phone', 'ceiling', 'desk', 'keyboard', 'mousepad', 'couch', 'pillow', 'bench', 'oven', 'cup', 'bed', 'light_bulb', 'food_food', 'lighter', 'kitchen_counter', 'hairbrush', 'dresser', 'laundry_detergent', 'table', 'clothes_skirt', 'tooth_paste', 'dirt'] Task:Pet cat response: { thoughts : Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <milk>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[TURNTO] <cat>', '[POINTAT] <cat>'] } Scene_Objects:['fork', 'toilet', 'toothbrush', 'drawing', 'floor', 'desk', 'tea_bag', 'toaster', 'mat', 'deck_of_cards', 'window', 'oil', 'mousepad', 'couch', 'pillow', 'broom', 'wall', 'bench', 'cutting_board', 'standingmirror', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'lighter', 'maindoor', 'napkin', 'instrument_guitar', 'table', 'bathroom_cabinet'] Task:Relax on sofa response: | { Find the sofa and sit on it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'food_ice_cream', 'hanger', 'floor', 'ceiling', 'character', 'bookshelf', 'mat', 'tvstand', 'faucet', 'ceilinglamp', 'wall', 'powersocket', 'photoframe', 'clothes_gloves', 'bed', 'food_food', 'check', 'ice', 'doorjamb', 'pencil', 'kitchen_counter', 'laundry_detergent', 'door', 'napkin', 'home_office', 'light', 'dishwasher'] Task:Turn on light response: { thoughts : switching on the light, actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['fork', 'juice', 'chair', 'walllamp', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'powersocket', 'oven', 'television', 'coin', 'food_donut', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'bathtub', 'light', 'table'] Task:Write an email response: | { Turn on PC and log onto email account. Type email and send it. Switch off computer. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'tea', 'knifeblock', 'cpuscreen', 'folder', 'bedroom', 'table_cloth', 'toaster', 'plate', 'homework', 'oil', 'closetdrawer', 'powersocket', 'tape', 'bed', 'novel', 'coffe_maker', 'television', 'razor', 'wine', 'doorjamb', 'shoes', 'dishrack', 'headset', 'cupboard', 'hairdryer', 'light', 'shoe_rack'] Task:Listen to music response: { thoughts : walk into living room, walk to stereo, turn on stereo, listen to music, actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['tablelamp', 'freezer', 'walllamp', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'shower', 'oil', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'oven', 'novel', 'colander', 'tray', 'lighter', 'dresser', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both'] Task:Wash hands response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'freezer', 'ground_coffee', 'detergent', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'stovefan', 'toaster', 'faucet', 'shower', 'closetdrawer', 'candle', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'coffe_maker', 'coffee_filter', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'table'] Task:Make coffee response: { thoughts : Make coffee in the kitchen., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[PLUGIN] <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>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } 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: | { Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'jelly', 'bathroom', 'detergent', 'food_butter', 'drawing', 'needle', 'cpuscreen', 'bathroom_counter', 'character', 'stovefan', 'plate', 'window', 'bowl', 'wall', 'bench', 'cup', 'bed', 'coffe_maker', 'check', 'tray', 'towel_rack', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'sink', 'light', 'dishwasher', 'teeth'] Task:Listen to music response: { thoughts : Walk into living room. Turn on radio., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['glue', 'pot', 'microwave', 'freezer', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'alcohol', 'stovefan', 'toaster', 'tvstand', 'couch', 'wall', 'oven', 'cutting_board', 'toy', 'food_cheese', 'novel', 'coffe_maker', 'food_food', 'television', 'tray', 'shaving_cream', 'cards', 'kitchen_counter', 'shoes', 'light'] Task:Put groceries in Fridge response: | { put away groceries in fridge. open the door, put on shelf, close 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:['pot', 'toilet', 'chair', 'freezer', 'detergent', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'purse', 'toaster', 'mat', 'faucet', 'iron', 'mousepad', 'wall', 'powersocket', 'cup', 'coffe_maker', 'water', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'clothes_scarf', 'colander'] Task:Drink response: { thoughts : I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>'] } Scene_Objects:['blender', 'chair', 'walllamp', 'dough', 'orchid', 'cpuscreen', 'hanger', 'floor', 'keyboard', 'remote_control', 'food_cake', 'envelope', 'computer', 'button', 'food_bacon', 'ceilinglamp', 'stereo', 'homework', 'oven', 'tape', 'photoframe', 'coffee_table', 'keys', 'check', 'novel', 'light_bulb', 'wooden_spoon', 'curtain', 'cd', 'home_office'] Task:Change TV channel response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'beer', 'crayon', 'chair', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'bedroom', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cup', 'bed', 'keys', 'food_food', 'television', 'food_onion', 'doorjamb', 'mouse', 'home_office'] Task:Lock door response: { thoughts : Turn the lock., actions : ['[WALK] <bedroom>'] } Scene_Objects:['pot', 'beer', 'microwave', 'toilet', 'freezer', 'food_butter', 'knife', 'floor', 'table_cloth', 'toaster', 'plate', 'faucet', 'stereo', 'dish_soap', 'oil', 'wall', 'wall_clock', 'oven', 'powersocket', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'coffee_filter', 'wooden_spoon', 'tray', 'kitchen_counter', 'sink', 'dishwasher', 'laser_pointer'] Task:Wash dishes with dishwasher response: | { I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'chair', 'walllamp', 'floor', 'dvd_player', 'bedroom', 'bookshelf', 'food_cake', 'shower', 'picture', 'foundation', 'mousepad', 'closetdrawer', 'tooth_paste', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'shelf', 'food_food', 'doorjamb', 'coffee_pot', 'mouse', 'pencil', 'kitchen_counter', 'towel_rack', 'door', 'napkin', 'bathroom_cabinet', 'board_game'] Task:Go to toilet response: { thoughts : I go to the bathroom. I locate the toilet. I walk to the toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[WALK] <toilet>'] } Scene_Objects:['tablelamp', 'blender', 'food_salt', 'freezer', 'detergent', 'ceiling', 'stamp', 'desk', 'bedroom', 'mat', 'deck_of_cards', 'faucet', 'shower', 'window', 'homework', 'food_peanut_butter', 'microphone', 'bowl', 'oven', 'toy', 'bed', 'light_bulb', 'standingmirror', 'check', 'doorjamb', 'kitchen_counter', 'hairbrush', 'hairdryer', 'bathroom_cabinet', 'table'] Task:Read book response: | { 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:['food_salt', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'television', 'ice', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'headset', 'cupboard', 'sink', 'table'] Task:Relax on sofa response: { thoughts : I walk to the sofa, and lie down on the sofa., actions : ['[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['food_ice_cream', 'mop', 'ground_coffee', 'cat', 'floor', 'ceiling', 'envelope', 'stovefan', 'mat', 'tvstand', 'stereo', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'cutting_board', 'check', 'coffe_maker', 'television', 'video_game_controller', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'chessboard', 'dresser', 'door', 'table', 'colander'] Task:Pet cat response: | { walk to entrance hall, look at the sofa, sit on the sofa, look at the cat, allow cat to near with you, touch the cat smoothly on it head, now pet the cat smoothly } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['freezer', 'walllamp', 'bathroom', '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: { thoughts : Turn on tv. Sit with kids., actions : ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[FIND] <child>', '[GREET] <child>', '[FIND] <child>', '[GREET] <child>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'mop', 'measuring_cup', 'microwave', 'chair', 'freezer', 'ground_coffee', 'bathroom', 'floor', 'ceiling', 'dvd_player', 'bookshelf', 'toaster', 'stovefan', 'faucet', 'iron', 'wall', 'wall_clock', 'cutting_board', 'shelf', 'clothes_gloves', 'coffe_maker', 'coffee_filter', 'food_rice', 'curtain', 'kitchen_counter', 'controller', 'sink', 'clothes_shirt'] Task:Make coffee response: | { You walk into the kitchen and turn to the coffee maker. You grab the coffee filter and put into the coffee machine, you also grab the ground coffee and put it into the coffee machine. You turn on the coffee machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'walllamp', 'trashcan', 'drawing', 'orchid', 'ceiling', 'phone', 'bedroom', 'stovefan', 'mat', 'tvstand', 'shower', 'faucet', 'iron', 'food_noodles', 'couch', 'towel', 'pillow', 'dining_room', 'wall_clock', 'bench', 'bed', 'television', 'after_shave', 'doorjamb', 'door', 'bathtub', 'spoon', 'bathroom_cabinet'] 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:['dry_pasta', 'pot', 'microwave', 'freezer', 'walllamp', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'phone', 'food_chicken', 'stovefan', 'mat', 'faucet', 'wall', 'wall_clock', 'oven', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'food_steak', 'sink', 'bathroom_cabinet'] Task:Cook some food response: | { Walk into the kitchen. Open the fridge. Take out the chicken. Open the kitchen cabinet. Take out the frying pan. Put the chicken in the frying pan. Put the frying pan on the stove. Turn on the stove. Cook the chicken. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'water_glass', 'pot', 'spectacles', 'walllamp', 'food_carrot', 'kitchen_cabinet', 'shampoo', 'longboard', 'computer', 'bookmark', 'mat', 'stereo', 'shower', 'homework', 'oil', 'clothes_socks', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'water', 'food_onion', 'headset', 'cd', 'dresser', 'controller', 'sink', 'napkin', 'clothes_skirt'] Task:Drink response: { thoughts : Go to kitchen. Open the the cabinet. Locate the water glass. Pour water into glass. Drag the bottle close to mouth. Drink water., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[CLOSE] <kitchen_cabinet>', '[GRAB] <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['pot', 'chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'stovefan', 'mat', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'dresser', 'napkin', 'bathroom_cabinet', 'light', 'table'] Task:Relax on sofa response: | { I want to relax on the sofa to some relaxing music 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:['beer', 'bathroom', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'button', 'brush', 'mat', 'toaster', 'faucet', 'picture', 'iron', 'pillow', 'broom', 'wall', 'oven', 'keys', 'novel', 'coin', 'tray', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'soap', 'clothes_shirt', 'scrabble', 'hands_both'] Task:Wash hands response: { thoughts : Go to the bathroom and to the sink, turn the faucet on, push the bottle of soap onto your hands and scrub them. Then rinse your hands out and turn the faucet off., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[PUSH] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['fork', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'stamp', 'envelope', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'powersocket', 'standingmirror', 'television', 'curtain', 'doorjamb', 'mouse', 'bag', 'home_office', 'table', 'soap'] Task:Relax on sofa response: | { I walk to my living room and switch on the television, and lay on the sofa. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear., actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[CLOSE] <dresser>', '[WALK] <basket_for_clothes>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>'] } Scene_Objects:['pot', 'filing_cabinet', 'scissors', 'microwave', 'milk', 'knife', 'bathroom_counter', 'ceiling', 'bedroom', 'toaster', 'mat', 'plate', 'tvstand', 'dish_soap', 'bowl', 'food_kiwi', 'toy', 'cup', 'standingmirror', 'bed', 'food_food', 'food_donut', 'cards', 'dresser', 'clothes_dress', 'napkin', 'bathroom_cabinet', 'dishwasher', 'vase', 'board_game'] Task:Wash dishes with dishwasher response: | { Using dishwasher to wash dishes } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'filing_cabinet', 'chair', 'trashcan', 'drawing', 'clothes_underwear', 'floor', 'phone', 'character', 'keyboard', 'mat', 'ceilinglamp', 'plate', 'tvstand', 'shower', 'faucet', 'mousepad', 'couch', 'wall', 'bench', 'powersocket', 'newspaper', 'bed', 'television', 'mouse', 'controller', 'table', 'light', 'instrument_violin', 'creditcard'] Task:Set up table response: { thoughts : I walk to the table. I put down the dish. I put down the silverware. I put down the napkin., actions : ['[WALK] <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <table>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>', '[GRAB] <plate>', '[PUTBACK] <plate> <table>'] } Scene_Objects:['crayon', 'needle', 'clothes_underwear', 'phone', 'desk', 'stamp', 'clothes_jacket', 'stovefan', 'mat', 'tvstand', 'window', 'towel', 'pillow', 'cutting_board', 'basket_for_clothes', 'cup', 'bed', 'photoframe', 'newspaper', 'food_food', 'mouthwash', 'television', 'wine', 'kettle', 'dresser', 'bathtub', 'bathroom_cabinet', 'table', 'soap', 'washing_machine'] Task:Wash clothes response: | { Walk to the kitchen and find the basket of clothes. Put the soap and clothes into the washing machine. Turn on the washing machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'stamp', 'bookshelf', 'clothes_jacket', 'mop_bucket', 'toaster', 'mat', 'brush', 'shoe-shine_kit', 'laptop', 'couch', 'pillow', 'wall', 'oven', 'cup', 'food_cheese', 'photoframe', 'check', 'television', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'bathroom_cabinet'] 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:['chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'tvstand', 'faucet', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'food_orange', 'wall', 'powersocket', 'shelf', 'food_food', 'oven_mitts', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'vacuum_cleaner', 'dresser', 'light', 'table'] Task:Turn on light response: | { approach the light switch, raise hand to the switch, flip the 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:['tablelamp', 'microwave', 'walllamp', 'drawing', 'orchid', 'floor', 'folder', 'mop_bucket', 'ceilinglamp', 'stereo', 'picture', 'window', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'bench', 'powersocket', 'novel', 'coffe_maker', 'toilet_paper', 'toothbrush_holder', 'tray', 'curtain', 'lighter', 'headset', 'cupboard', 'table'] Task:Relax on sofa response: { thoughts : I walk to the living room and find the sofa. I sit on the sofa and get comfortable., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['tablelamp', 'beer', 'measuring_cup', 'drawing', 'floor', 'bookshelf', 'mat', 'faucet', 'stereo', 'window', 'closetdrawer', 'microphone', 'food_orange', 'pillow', 'wall', 'nightstand', 'bed', 'food_food', 'curtain', 'towel_rack', 'headset', 'dresser', 'hairbrush', 'laundry_detergent', 'home_office', 'table', 'light', 'vase', 'board_game', 'scrabble'] Task:Go to sleep response: | { Walk to bedroom. Walk to bed, lie in 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:['filing_cabinet', 'tablelamp', 'toilet', 'bathroom', 'knifeblock', 'cpuscreen', 'hanger', 'bathroom_counter', 'ceiling', 'folder', 'character', 'keyboard', 'bookshelf', 'envelope', 'computer', 'dining_room', 'wall', 'nightstand', 'cup', 'clothes_gloves', 'light_bulb', 'check', 'curtain', 'pencil', 'kitchen_counter', 'controller', 'sink', 'napkin', 'clothes_skirt', 'tooth_paste'] Task:Browse internet response: { thoughts : I turn on computer. I use keyboard to type. I open browser. I search., actions : ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['freezer', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'thread', 'computer', 'stovefan', 'mat', 'faucet', 'clothes_socks', 'clothes_hat', 'towel', 'wall', 'wall_clock', 'oven', 'shelf', 'bed', 'standingmirror', 'water', 'tray', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'soap', 'scrabble', 'hands_both'] Task:Wash hands response: | { Go into the bathroom and go over to the sink. Grab soap and turn on the water. Wet your hands and rub them together so that the soap lathers. Rub the soap all over your hands thoroughly. Rinse off the soap with water and turn off the sink. Dry your hands with 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:['pot', 'tablelamp', 'microwave', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'brush', 'mat', 'tvstand', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'photoframe', 'food_food', 'television', 'doorjamb', 'bag', 'light', 'dishwasher', 'table'] Task:Relax on sofa response: { thoughts : Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['sheets', 'microwave', 'toilet', 'ground_coffee', 'blow_dryer', 'orchid', 'wallshelf', 'bathroom_counter', 'character', 'desk', 'bookshelf', 'alcohol', 'computer', 'ceilinglamp', 'laptop', 'faucet', 'pillow', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'cup', 'television', 'oven_mitts', 'after_shave', 'doorjamb', 'diary', 'towel_rack', 'cards', 'maindoor'] Task:Pet cat response: | { Walk to living room. Find cat. Walk to cat. Pull cat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'napkin', 'spoon', 'table', 'light'] Task:Watch TV response: { thoughts : Sit on the couch and use the remote control to change channels, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[WATCH] <television>'] } Scene_Objects:['food_bread', 'chair', 'bathroom', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'character', 'computer', 'mail', 'table_cloth', 'toaster', 'foundation', 'window', 'mousepad', 'bench', 'shelf', 'photoframe', 'bed', 'coffe_maker', 'cards', 'chessboard', 'controller', 'door', 'maindoor', 'bathtub', 'light', 'vase', 'laser_pointer'] Task:Pick up phone response: | { walk into living room, look at the phone when it ringing, grab the phone or pickup the phone } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'band-aids', 'bathroom', 'trashcan', 'phone', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'picture', 'window', 'couch', 'bowl', 'broom', 'wall', 'oven', 'bench', 'cup', 'food_food', 'oven_mitts', 'colander', 'curtain', 'pencil', 'kitchen_counter', 'clothes_dress', 'sink', 'dishwasher', 'soap', 'instrument_violin'] Task:Pet cat response: { thoughts : Find Cat in living room. Walk to cat. Pet cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['food_pizza', 'food_ice_cream', 'microwave', 'freezer', 'ground_coffee', 'nail_polish', 'milk', 'hanger', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'faucet', 'clothes_hat', 'wall', 'wall_clock', 'oven', 'cutting_board', 'shelf', 'coffe_maker', 'check', 'television', 'coffee_filter', 'water', 'curtain', 'kitchen_counter', 'maindoor', 'sink', 'vase', 'soap'] Task:Make coffee response: | { Walk to kitchen. Find coffee maker. Find coffee filter. Put it in the coffee maker. Find ground coffee. Put it in the coffee maker. Find Water. Put it in the coffe maker. Switch on the coffee maker. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'walllamp', 'bathroom', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'stovefan', 'ceilinglamp', 'plate', 'shower', 'tvstand', 'food_noodles', 'bowl', 'wall', 'tape', 'shelf', 'bed', 'check', 'doorjamb', 'kitchen_counter', 'shoes', 'sink', 'light', 'laser_pointer'] Task:Take shower response: { thoughts : walk to bathroom , find shower , take a shower, actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>'] } Scene_Objects:['pot', 'tablelamp', 'freezer', 'walllamp', 'food_carrot', 'desk', 'food_cake', 'remote_control', 'button', 'ceilinglamp', 'faucet', 'stereo', 'window', 'mousepad', 'couch', 'wall_clock', 'bench', 'box', 'cup', 'bed', 'keys', 'newspaper', 'food_food', 'ice', 'after_shave', 'maindoor', 'bathroom_cabinet', 'light', 'vase', 'soap'] Task:Watch TV response: | { I walk to the living room and sit on the couch. I grab the TV remote. I press the power button on the TV remote and the TV turns on. I grab the surround sound remote. I press the power button on the surround sound remote and the system turns on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'band-aids', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'homework', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'keys', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'light', 'soap'] Task:Change TV channels response: { thoughts : Take remote. Change to desired channel by you., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>'] } Scene_Objects:['tablelamp', 'toilet', 'freezer', 'bathroom', 'cat', 'cpuscreen', 'bathroom_counter', 'bedroom', 'food_cake', 'computer', 'alcohol', 'toaster', 'stovefan', 'ceilinglamp', 'mousepad', 'closetdrawer', 'clothes_hat', 'nightstand', 'wall_clock', 'newspaper', 'coffee_filter', 'oven_mitts', 'kettle', 'kitchen_counter', 'dresser', 'hair', 'sink', 'napkin', 'bag', 'light'] Task:Pet cat response: | { find the cat, go near the cat and pet the cat } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'bathroom_counter', 'floor', 'mop_bucket', 'table_cloth', 'toaster', 'stovefan', 'plate', 'microphone', 'clothes_pants', 'dining_room', 'wall', 'pasta', 'cup', 'coffe_maker', 'food_food', 'mouse', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'home_office', 'light', 'dishwasher', 'colander', 'tooth_paste'] Task:Wash dishes with dishwasher response: { thoughts : Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['filing_cabinet', 'walllamp', 'detergent', 'cat', 'milk', 'phone', 'ceiling', 'desk', 'mop_bucket', 'brush', 'ceilinglamp', 'tvstand', 'faucet', 'toaster', 'mat', 'closetdrawer', 'microphone', 'nightstand', 'wall_clock', 'toy', 'cup', 'food_food', 'after_shave', 'lighter', 'towel_rack', 'mouse', 'pajamas', 'controller', 'laundry_detergent', 'soap'] Task:Pet cat response: | { Go to the living room where the cat sleeps. Find cat. Proceed to petting cat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'beer', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mousepad', 'food_jam', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'food_onion', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'dresser', 'door', 'table', 'light', 'dishwasher'] Task:Work response: { thoughts : I walk to the bedroom, then find the computer and sit in the chair ,next switch on the computer and finally type in the keyboard to start to work on it, actions : ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'food_butter', 'floor', 'ceiling', 'stovefan', 'faucet', 'dustpan', 'food_jam', 'wall', 'oven', 'cutting_board', 'newspaper', 'coffe_maker', 'water', 'drinking_glass', 'tray', 'doorjamb', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'home_office', 'bathroom_cabinet', 'clothes_skirt', 'vase', 'scrabble'] Task:Drink response: | { go to the kitchen } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'floor', 'dvd_player', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'electric_shaver', 'floor_lamp', 'mousepad', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'after_shave', 'cupboard', 'sink', 'home_office', 'table', 'tooth_paste'] Task:Turn on light response: { thoughts : Twist the lamp switch until the light goes on., actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['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: | { 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:['tablelamp', 'toilet', 'chair', 'walllamp', 'cat', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'ceilinglamp', 'homework', 'mousepad', 'wall', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'shoes', 'comb', 'dresser', 'hairdryer'] Task:Write an email response: { thoughts : I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email, actions : ['[WALK] <laptop>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['glue', 'blender', 'microwave', 'toilet', 'bathroom', 'food_carrot', 'milk', 'wallshelf', 'cpuscreen', 'toaster', 'window', 'clothes_socks', 'pillow', 'wall', 'standingmirror', 'food_food', 'mouthwash', 'razor', 'ice', 'rag', 'lighter', 'cards', 'mouse', 'cd', 'hairbrush', 'pajamas', 'dresser', 'laundry_detergent', 'sink', 'light'] Task:Read book response: | { walk to living room ,find a book ,open the book ,read the book } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_ice_cream', 'jelly', 'chair', 'blow_dryer', 'bathroom', 'wallshelf', 'shampoo', 'phone', 'desk', 'clothes_jacket', 'stovefan', 'faucet', 'oil', 'closetdrawer', 'food_noodles', 'mousepad', 'microphone', 'towel', 'broom', 'bed', 'newspaper', 'after_shave', 'centerpiece', 'console', 'dresser', 'bathroom_cabinet', 'soap', 'tooth_paste', 'scrabble'] Task:Read book response: { thoughts : Walk to living room. Find book. Grab book. Open book. Read book., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['food_pizza', 'microwave', 'chair', 'food_butter', 'drawing', 'bathroom_counter', 'floor', 'stamp', 'desk', 'bookmark', 'stovefan', 'tvstand', 'shower', 'microphone', 'towel', 'dining_room', 'bowl', 'nightstand', 'oven', 'bench', 'shelf', 'food_cheese', 'photoframe', 'light_bulb', 'tray', 'kitchen_counter', 'dresser', 'hair', 'door', 'bathtub'] Task:Pet cat response: | { Go into the living room and pet the cat } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'band-aids', 'drawing', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'button', 'toaster', 'mat', 'clothes_hat', 'wall', 'powersocket', 'oven', 'toy', 'novel', 'toothbrush_holder', 'after_shave', 'doorjamb', 'pencil', 'door', 'light', 'table', 'dishwasher', 'colander'] Task:Put toys away response: { thoughts : Pick up all the toys on the floor and put them in their correct storage bin or shelf., actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>'] } Scene_Objects:['fork', 'scissors', 'microwave', 'bathroom', 'nail_polish', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'bookshelf', 'mat', 'faucet', 'window', 'electric_shaver', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'newspaper', 'keys', 'television', 'curtain', 'doorjamb', 'diary', 'sink', 'spoon', 'table', 'soap'] Task:Relax on sofa response: | { Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'walllamp', 'drawing', 'needle', 'wallshelf', 'bills', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'check', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'tooth_paste'] Task:Watch TV response: { thoughts : I enter the living room and sit on the couch. I grab the remote and turn on the TV., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['sheets', 'walllamp', 'drawing', 'orchid', 'bills', 'floor', 'desk', 'mat', 'tvstand', 'stereo', 'clothes_socks', 'closetdrawer', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'basket_for_clothes', 'photoframe', 'newspaper', 'clothes_gloves', 'standingmirror', 'mouthwash', 'television', 'razor', 'towel_rack', 'kitchen_counter', 'clothes_dress', 'sink', 'soap', 'washing_machine'] Task:Wash clothes response: | { put clothes and soap in the washing machine, 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:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'kettle', 'mouse', 'dresser', 'hair', 'door', 'coffee'] Task:Browse internet response: { thoughts : walk to living room. look at computer. switch on computer. sit in chair. watch computer. switch off computer., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[WATCH] <computer>', '[SWITCHOFF] <computer>'] } Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'button', 'food_bacon', 'stovefan', 'mat', 'shower', 'faucet', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'keys', 'tray', 'doorjamb', 'lighter', 'sink', 'bathtub', 'bathroom_cabinet', 'soap'] Task:Take shower response: | { I want to take a shower so I go to the bathroom, turn on the shower, get the soap, lather and wash, then I rinse, turn off shower, get a towel and dry off. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'freezer', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stovefan', 'mat', 'tvstand', 'faucet', 'toaster', 'teeth', 'towel', 'wall', 'wall_clock', 'oven', 'powersocket', 'food_food', 'tray', 'headset', 'comb', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'instrument_guitar', 'soap', 'hands_both', 'creditcard'] Task:Wash hands response: { thoughts : Go to bathroom, turn on faucet, wet hands, apply soap, rub hands, rinse hands, turn off faucet, dry hands, actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['dry_pasta', 'filing_cabinet', 'toilet', 'walllamp', 'bathroom', 'bathroom_counter', 'phone', 'tea_bag', 'keyboard', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'brush', 'foundation', 'window', 'closetdrawer', 'couch', 'broom', 'wall_clock', 'toy', 'food_cheese', 'novel', 'food_donut', 'tray', 'kitchen_counter', 'dresser', 'bathtub', 'light', 'shoe_rack'] Task:Pick up phone response: | { Walk to the living room, Find Phone stand. Find Phone. Pickup the receiver to attend the call. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'homework', 'towel', 'dining_room', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bag', 'napkin', 'soap'] Task:Put groceries in Fridge response: { thoughts : Walk to kitchen counter, grab a grocery, walk to fridge, open fridge, put the grocery into fridge, and close fridge, actions : ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['tablelamp', 'food_ice_cream', 'bathroom', 'bathroom_counter', 'floor', 'clothes_jacket', 'toaster', 'mat', 'tvstand', 'window', 'couch', 'candle', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'pasta', 'tape', 'newspaper', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'diary', 'pencil', 'hairbrush', 'bathroom_cabinet', 'table'] Task:Relax on sofa response: | { Walk into the living room. Walk up to the sofa. Sit down on the sofa. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'food_bread', 'mop', 'freezer', 'trashcan', 'knifeblock', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'stovefan', 'mat', 'faucet', 'pillow', 'wall', 'powersocket', 'bed', 'food_food', 'check', 'mouthwash', 'after_shave', 'doorjamb', 'chessboard', 'dresser', 'cupboard', 'hair', 'door', 'instrument_guitar', 'light', 'creditcard'] Task:Turn on light response: { thoughts : Walk into living room. Find wall. Find light button. Switch on light button., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['toilet', 'chair', 'freezer', 'detergent', 'hanger', 'bathroom_counter', 'shampoo', 'ceiling', 'desk', 'bedroom', 'computer', 'stovefan', 'toaster', 'tvstand', 'shower', 'homework', 'closetdrawer', 'bench', 'oven', 'toy', 'cup', 'bed', 'photoframe', 'toilet_paper', 'coffe_maker', 'oven_mitts', 'pencil', 'dresser', 'bag', 'bathroom_cabinet'] Task:Pet cat response: | { I enter the room where the cat is. I look for the cat. I find the cat. I walk over to the cat. I use my hand to pet the cat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'scissors', 'jelly', 'walllamp', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'food_jam', 'wall', 'novel', 'television', 'curtain', 'doorjamb', 'comb', 'clothes_dress', 'sink', 'home_office', 'table'] Task:Change TV channel response: { thoughts : first i will go to living room and then take the remote and swtitch on television after that il change the channel, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['mop', 'chair', 'bathroom', 'cpuscreen', 'hanger', 'computer', 'brush', 'toaster', 'mat', 'faucet', 'shower', 'dish_soap', 'food_noodles', 'mousepad', 'bowl', 'photoframe', 'standingmirror', 'novel', 'coffe_maker', 'check', 'television', 'bed', 'coffee_filter', 'curtain', 'clothes_dress', 'food_steak', 'door', 'spoon', 'dishwasher', 'instrument_violin'] Task:Wash dishes with dishwasher response: | { walk to kitchen, find the dishwasher, apply dish soap into vessels or dishwasher, wash the dishes with a dishwasher } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'food_pizza', 'tablelamp', 'blender', 'beer', 'wallshelf', 'floor', 'phone', 'stamp', 'desk', 'stovefan', 'mat', 'laptop', 'stereo', 'window', 'food_noodles', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'cup', 'photoframe', 'clothes_gloves', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'controller', 'bathroom_cabinet', 'table'] Task:Relax on sofa response: { thoughts : walk to living room, walk to sofa, sit on sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['sponge', 'food_ice_cream', 'chair', 'freezer', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'thread', 'computer', 'alcohol', 'mat', 'window', 'foundation', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'light', 'table'] Task:Relax on sofa response: | { I walk into the living room and turn on the light. I walk to the couch then sit 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:['sheets', 'fork', 'blender', 'food_ice_cream', 'food_butter', 'phone', 'character', 'bookshelf', 'brush', 'ceilinglamp', 'plate', 'shower', 'iron', 'stereo', 'toaster', 'oil', 'food_orange', 'pillow', 'cup', 'food_food', 'check', 'oven_mitts', 'food_donut', 'food_onion', 'after_shave', 'mouse', 'hairdryer', 'bag', 'bathroom_cabinet', 'home_office'] Task:Set up table response: { thoughts : Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room, actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <home_office>', '[DROP] <plate>', '[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <home_office>', '[DROP] <cup>', '[WALK] <dining_room>', '[WALK] <fork>', '[FIND] <fork>', '[GRAB] <fork>', '[WALK] <home_office>', '[DROP] <fork>'] } Scene_Objects:['measuring_cup', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'bookshelf', 'brush', 'mat', 'stereo', 'picture', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'shelf', 'cup', 'television', 'wine', 'curtain', 'food_onion', 'doorjamb', 'towel_rack', 'mouse', 'cd', 'home_office', 'table'] Task:Listen to music response: | { Walk to living room. Walk to radio. Switch on the radio. Walk to sofa and sit on it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { thoughts : There are extra toilet papers in the bottom cabinet., actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>'] } Scene_Objects:['sheets', 'juice', 'freezer', 'walllamp', 'detergent', 'toothbrush', 'floor', 'ceiling', 'dvd_player', 'desk', 'table_cloth', 'closetdrawer', 'dining_room', 'wall', 'bench', 'cutting_board', 'light_bulb', 'check', 'mouthwash', 'video_game_controller', 'ice', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'dishrack', 'hair', 'door', 'sink', 'light'] Task:Turn on light response: | { flip the switch and turn on the lights } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stovefan', 'window', 'mat', 'plate', 'couch', 'candle', 'microphone', 'dining_room', 'wall', 'powersocket', 'box', 'photoframe', 'coffe_maker', 'television', 'curtain', 'table', 'dishwasher'] Task:Watch TV response: { thoughts : Turn on the TV, sit on the couch, find a show, and watch it., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['tablelamp', 'measuring_cup', 'cd_player', 'knife', 'character', 'tea_bag', 'remote_control', 'button', 'table_cloth', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'food_peanut_butter', 'candle', 'nightstand', 'bench', 'cutting_board', 'shelf', 'bed', 'photoframe', 'oven_mitts', 'food_rice', 'doorjamb', 'shaving_cream', 'mouse', 'dresser', 'controller', 'sink', 'table', 'clothes_skirt'] Task:Listen to music response: | { I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'tablelamp', 'toilet', 'chair', 'walllamp', 'detergent', 'cat', 'knife', 'cpuscreen', 'floor', 'ceiling', 'mail', 'toaster', 'ceilinglamp', 'stovefan', 'stereo', 'homework', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'tape', 'newspaper', 'photoframe', 'food_food', 'television', 'water', 'tray', 'bathroom_cabinet'] Task:Drink response: { thoughts : GOING TO DRINK WATER IN KITCHEN, actions : ['[WALK] <dining_room>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <water_glass>', '[POUR] <water> <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>', '[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['food_pizza', 'tablelamp', 'measuring_cup', 'freezer', 'bathroom', 'drawing', 'wallshelf', 'character', 'purse', 'envelope', 'ceilinglamp', 'nightstand', 'wall_clock', 'bench', 'cutting_board', 'newspaper', 'coffe_maker', 'tray', 'doorjamb', 'diary', 'cards', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'light', 'table', 'tooth_paste', 'clothes_shirt', 'coffee'] Task:Drink response: | { I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'food_salt', 'crayon', 'freezer', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'shampoo', 'desk', 'mail', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'stovefan', 'mat', 'electric_shaver', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'pasta', 'basket_for_clothes', 'food_food', 'diary', 'towel_rack', 'dresser', 'clothes_dress'] Task:Put groceries in Fridge response: { thoughts : in my home i walk to the kitchen with some groceries and locate the fridge,then open the fridge put the groceries into the fridge and closed., actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'chair', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'table_cloth', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'wall_clock', 'oven', 'standingmirror', 'bed', 'food_food', 'water', 'tray', 'curtain', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table', 'hands_both'] Task:Wash hands response: | { I turn on faucet. I hold out my hands. I get my hands wet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'button', 'food_bacon', 'stovefan', 'mat', 'shower', 'faucet', 'closetdrawer', 'towel', 'wall', 'wall_clock', 'oven', 'nightstand', 'keys', 'tray', 'doorjamb', 'lighter', 'sink', 'bathtub', 'bathroom_cabinet', 'soap'] Task:Take shower response: { thoughts : I want to take a shower so I go to the bathroom, turn on the shower, get the soap, lather and wash, then I rinse, turn off shower, get a towel and dry off., actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[RINSE] <shower>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>'] } Scene_Objects:['spectacles', 'pot', 'food_bread', 'microwave', 'toilet', 'freezer', 'food_carrot', 'dough', 'bathroom_counter', 'floor', 'phone', 'thread', 'stereo', 'shower', 'mousepad', 'food_jam', 'food_orange', 'form', 'bowl', 'food_kiwi', 'oven', 'shelf', 'coffe_maker', 'television', 'razor', 'towel_rack', 'coffee_pot', 'headset', 'chessboard', 'light'] Task:Listen to music response: | { I go to my bedroom, and then I switch on the radio } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'tape', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Work response: { thoughts : I go to my home office. I find the computer along with mechanical keyboard on the desk. I sit on chair. I switch on the computer. I type on keyboard and work on the computer., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'jelly', 'bills', 'food_egg', 'hanger', 'floor', 'phone', 'ceiling', 'dvd_player', 'mat', 'window', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'wall', 'cutting_board', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'hair', 'table', 'soap', 'clothes_shirt'] Task:Relax on sofa response: | { Go to living room. Find sofa. Sit on sofa. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['freezer', 'detergent', 'dough', 'drawing', 'bills', 'clothes_underwear', 'floor', 'bedroom', 'keyboard', 'piano_bench', 'ceilinglamp', 'balanceball', 'picture', 'window', 'foundation', 'electric_shaver', 'couch', 'dustpan', 'food_kiwi', 'wall', 'keys', 'check', 'television', 'tray', 'rag', 'shoes', 'door', 'table', 'vase', 'coffee'] Task:Relax on sofa response: { thoughts : Relax on the sofa in the living room., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>'] } Scene_Objects:['bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'faucet', 'shower', 'tooth_paste', 'towel', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'clothes_gloves', 'light_bulb', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'vase', 'soap', 'home_office', 'hands_both'] Task:Wash hands response: | { I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel. } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.