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:['fork', 'tablelamp', 'chair', 'walllamp', 'detergent', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'check', 'television', 'tray', 'wooden_spoon', 'kettle', 'controller', 'food_steak', 'sink'] Task:Relax on sofa response: { 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:['microwave', 'toilet', 'freezer', 'walllamp', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'shower', 'dish_soap', 'mousepad', 'pillow', 'wall', 'oven', 'photoframe', 'bed', 'coffe_maker', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'light'] Task:Wash dishes by hand response: | { i go to the kitchen, i find the faucet. I turn the faucet on, i grab the plate to wash , i then get the soap. I wash the dishes by hand } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'filing_cabinet', 'blender', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'floor', 'bedroom', 'bookshelf', 'stovefan', 'food_peanut_butter', 'clothes_hat', 'clothes_pants', 'dining_room', 'nightstand', 'wall_clock', 'video_game_controller', 'food_donut', 'curtain', 'kettle', 'shoes', 'dresser', 'cupboard', 'hairbrush', 'controller', 'home_office', 'light', 'clothes_skirt', 'soap'] Task:Listen to music response: { thoughts : Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['food_salt', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'phone', 'character', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'wall_clock', 'bed', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'hairdryer', 'sink', 'home_office', '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:['chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'stereo', 'window', 'shower', 'mousepad', 'wall', 'powersocket', 'bench', 'clothes_gloves', 'television', 'tray', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'bathtub', 'table'] Task:Work response: { thoughts : I walk into home office. I walk to desk. I sit at chair. I turn on computer., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['sponge', 'sheets', 'tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'oven', 'bed', 'coffe_maker', 'doorjamb', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'home_office'] 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:['sheets', 'glue', 'chair', 'milk', 'toothbrush', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'alcohol', 'mop_bucket', 'table_cloth', 'mat', 'faucet', 'homework', 'clothes_socks', 'closetdrawer', 'teeth', 'mousepad', 'wall', 'powersocket', 'doorjamb', 'shaving_cream', 'sink', 'bathroom_cabinet', 'light', 'hands_both'] Task:Wash hands response: { thoughts : I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>'] } Scene_Objects:['tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'form', 'wall', 'powersocket', 'photoframe', 'video_game_controller', 'television', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both'] Task:Wash hands response: | { I walk in to the bathroom. I find the soap. I find the faucet. I turn on the faucet. I wash my hands. I put the soap back. I rinse my hands. I turn the faucet off. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'mop', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'envelope', 'faucet', 'picture', 'homework', 'window', 'mousepad', 'clothes_hat', 'towel', 'wall', 'photoframe', 'hands_both', 'food_food', 'doorjamb', 'kettle', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'vase', 'teeth'] Task:Wash teeth response: { thoughts : I need to rinse my dentures off and put them back in my mouth., actions : ['[WALK] <bathroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <teeth>', '[GRAB] <teeth>', '[WASH] <teeth>', '[PUTOBJBACK] <teeth>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <towel>', '[SWITCHOFF] <light>'] } Scene_Objects:['chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'check', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'sink', 'table'] Task:Browse internet response: | { I go to the office and sit in a chair, I turn on the computer and grab the mouse. I type on the keyboard and starting working on the computer. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'crayon', 'microwave', 'detergent', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'alcohol', 'toaster', 'shower', 'couch', 'clothes_hat', 'pillow', 'wall', 'pasta', 'bench', 'oven', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'doorjamb', 'hairbrush', 'cupboard', 'door', 'table', 'light'] Task:Relax on sofa response: { thoughts : Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['dry_pasta', 'trashcan', 'toothbrush', 'drawing', 'needle', 'floor', 'ceiling', 'phone', 'computer', 'button', 'piano_bench', 'plate', 'faucet', 'pillow', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'bed', 'food_food', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'conditioner', 'door', 'food_steak', 'bathtub', 'light', 'teeth'] Task:Turn on light response: | { Walk over to light switch. Turn on lights. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'drawing', 'keyboard', 'bookmark', 'stovefan', 'ceilinglamp', 'stereo', 'shower', 'foundation', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'bed', 'check', 'television', 'wine', 'curtain', 'towel_rack', 'vacuum_cleaner', 'maindoor', 'door', 'dishwasher', 'vase'] Task:Pick up phone response: { thoughts : Enter living room. Walk to telephone. Pick up from hook., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'wallshelf', 'food_egg', 'hanger', 'cpuscreen', 'floor', 'ceiling', 'character', 'keyboard', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'toaster', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'bed', 'television', 'curtain', 'doorjamb', '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:['sponge', 'sheets', 'pot', 'blender', 'microwave', 'chair', 'nail_polish', 'detergent', 'milk', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'clothes_socks', 'broom', 'wall', 'food_kiwi', 'powersocket', 'cup', 'photoframe', 'keys', 'newspaper', 'curtain', 'lighter', 'pencil', 'pajamas', 'clothes_dress', 'sink', 'table', 'light'] Task:Sit in chair response: { thoughts : I sit in a chair to rest and eat., actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>'] } Scene_Objects:['chair', 'band-aids', 'walllamp', 'bathroom', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'pillow', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'bed', 'food_food', 'check', 'television', 'doorjamb', 'mouse', 'sink', 'napkin', 'table', 'light'] Task:Write an email response: | { go to the home office and write an email } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'crayon', 'freezer', 'bathroom', 'toothbrush', 'drawing', 'knifeblock', 'floor', 'phone', 'mail', 'brush', 'ceilinglamp', 'picture', 'window', 'couch', 'bowl', 'wall', 'pasta', 'bench', 'tape', 'newspaper', 'light_bulb', 'television', 'toothbrush_holder', 'shaving_cream', 'vacuum_cleaner', 'spoon', 'bathroom_cabinet', 'table'] Task:Relax on sofa response: { thoughts : I get home from work and walk into the living room. I see the couch and go to sit on it., actions : ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['microwave', 'walllamp', 'bathroom', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'photoframe', 'television', 'coffee_filter', 'curtain', 'towel_rack', 'dresser', 'cupboard', 'table', 'light'] Task:Watch TV response: | { Walk into the living room/den. Turn on the television. Switch channels to find a program with remote. I find a program and look at the screen. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'toilet', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'stovefan', 'faucet', 'window', 'mousepad', 'closetdrawer', 'couch', 'towel', 'wall', 'nightstand', 'curtain', 'towel_rack', 'mouse', 'coffee_pot', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : I go to the bathroom and locate the sink. I turn the faucet so that water is running, and rinse my hands briefly. Then I grab the soap and squeeze some onto my hands. I spend a few minutes rubbing my hands together, then I rinse them again. Finally, I turn the faucet off and wipe my hands on a towel., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SQUEEZE] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>'] } Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'keyboard', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'bed', 'check', 'television', 'tray', 'curtain', 'mouse', 'cupboard', 'door', 'table'] Task:Relax on sofa response: | { Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'scissors', 'chair', 'drawing', 'wallshelf', 'floor', 'bookshelf', 'envelope', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'shower', 'picture', 'oil', 'closetdrawer', 'microphone', 'food_cheese', 'newspaper', 'bed', 'food_food', 'wine', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'light'] 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:['filing_cabinet', 'tablelamp', 'chair', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'toaster', 'mat', 'ceilinglamp', 'shower', 'faucet', 'food_jam', 'dining_room', 'nightstand', 'wall', 'bench', 'powersocket', 'video_game_controller', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink', 'soap'] Task:Pick up phone response: | { I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'cat', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'couch', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'box', 'food_food', 'television', 'coffee_pot', 'kettle', 'cards', 'mouse', 'home_office', 'dishwasher'] Task:Pet cat response: { thoughts : I walk to the living room. I locate the cat. I walk to the couch and sit down beside the cat. I pet the cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <cat>'] } Scene_Objects:['pot', 'water_glass', 'microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'wallshelf', 'bookshelf', 'clothes_jacket', 'toaster', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'dining_room', 'nightstand', 'wall', 'wall_clock', 'powersocket', 'basket_for_clothes', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'console', 'dishrack', 'hairdryer', 'door', 'bathtub'] Task:Drink response: | { Drink water } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['scissors', 'bathroom', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bookshelf', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'couch', 'dining_room', 'food_kiwi', 'wall', 'toilet_paper', 'razor', 'television', 'curtain', 'diary', 'towel_rack', 'door', 'bathroom_cabinet', 'table', 'creditcard'] Task:Watch TV response: { thoughts : Sit on the couch and use the remote control to turn on the TV, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['filing_cabinet', 'toilet', 'bathroom', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'computer', 'stovefan', 'faucet', 'window', 'mousepad', 'closetdrawer', 'couch', 'towel', 'wall', 'nightstand', 'curtain', 'towel_rack', 'mouse', 'coffee_pot', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: | { I go to the bathroom and locate the sink. I turn the faucet so that water is running, and rinse my hands briefly. Then I grab the soap and squeeze some onto my hands. I spend a few minutes rubbing my hands together, then I rinse them again. Finally, I turn the faucet off and wipe my hands on a towel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'dog', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'folder', 'desk', 'bookshelf', 'keyboard', 'thread', 'computer', 'mail', 'bookmark', 'mousepad', 'wall', 'nightstand', 'photoframe', 'novel', 'toilet_paper', 'tray', 'towel_rack', 'mouse', 'door', 'light'] Task:Read book response: { thoughts : Walk to the living room. Find a desk and grab a book. Walk to the chair, sit in the chair and read a book., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'shower', 'closetdrawer', 'microphone', 'wall', 'nightstand', 'oven', 'wall_clock', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'door', 'bathroom_cabinet', 'light', 'table'] 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:['dry_pasta', 'food_bread', 'freezer', 'food_carrot', 'milk', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'mousepad', 'garbage_can', 'clothes_hat', 'food_orange', 'food_dessert', 'wall', 'powersocket', 'food_vegetable', 'food_cheese', 'doorjamb', 'lighter', 'mouse', 'coffee', 'door', 'light', 'colander', 'teeth'] Task:Rotate stock in refrigerator response: { thoughts : Throw out expired items, put older items in front., actions : ['[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_bread>', '[GRAB] <food_bread>', '[TURNTO] <food_bread>', '[LOOKAT] <food_bread>', '[PUTOBJBACK] <food_bread>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[TURNTO] <food_cheese>', '[LOOKAT] <food_cheese>', '[FIND] <garbage_can>', '[PUTBACK] <food_cheese> <garbage_can>', '[FIND] <food_cheese>', '[GRAB] <food_cheese>', '[TURNTO] <food_cheese>', '[LOOKAT] <food_cheese>', '[PUTOBJBACK] <food_cheese>', '[FIND] <food_dessert>', '[TURNTO] <food_dessert>', '[LOOKAT] <food_dessert>', '[PUSH] <food_dessert>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <milk>', '[GRAB] <milk>', '[TURNTO] <milk>', '[LOOKAT] <milk>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>'] } Scene_Objects:['chair', 'dough', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'tvstand', 'stereo', 'mousepad', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'sink', 'bathtub', 'light'] Task:Listen to music response: | { I go to the bedroom and sit at my desk. I turn my radio on and listen to music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'bathroom', 'detergent', 'food_carrot', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'thread', 'stereo', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'cup', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'hair', 'door', 'sink', 'spoon', 'table', 'light'] Task:Relax on sofa response: { thoughts : Walk to the living room, turn to the sofa. Sit on the sofa and relax., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>'] } Scene_Objects:['dry_pasta', 'filing_cabinet', 'mop', 'microwave', 'trashcan', 'drawing', 'ceiling', 'character', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'tvstand', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'form', 'pillow', 'nightstand', 'newspaper', 'bed', 'curtain', 'towel_rack', 'dishrack', 'home_office', 'light', 'dishwasher', 'table', 'scrabble'] Task:Wash dishes by hand response: | { walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'water_glass', 'food_ice_cream', 'microwave', 'freezer', 'drawing', 'floor', 'ceiling', 'toaster', 'stovefan', 'mat', 'shower', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'coffe_maker', 'television', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'door', 'dishwasher'] Task:Drink response: { thoughts : I enter the kitchen and grab a waterglass from the cupboard. I open the fridge and grap some water. I pour the water into the cup and drink it., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[OPEN] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'ceilinglamp', 'faucet', 'shower', 'towel', 'dining_room', 'wall', 'powersocket', 'bed', 'check', 'wooden_spoon', 'cards', 'mouse', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap', 'hands_both'] Task:Wash hands response: | { Go to the bathroom. turn on the water in the sink. apply soap to hands. rub hands together. rinse hands with water. turn off the water. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'filing_cabinet', 'cat', 'food_butter', 'hanger', 'floor', 'ceiling', 'food_cake', 'ceilinglamp', 'deck_of_cards', 'tvstand', 'homework', 'mousepad', 'closetdrawer', 'teeth', 'food_jam', 'nightstand', 'powersocket', 'bed', 'check', 'video_game_controller', 'mouthwash', 'towel_rack', 'mouse', 'console', 'cd', 'cupboard', 'instrument_guitar', 'coffee', 'shoe_rack'] Task:Clean response: { thoughts : Clean the welcome mat, actions : ['[WALK] <home_office>', '[WALK] <vacuum_cleaner>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>'] } Scene_Objects:['filing_cabinet', 'microwave', 'orchid', 'drawing', 'hanger', 'floor', 'phone', 'character', 'keyboard', 'toaster', 'plate', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'dining_room', 'oven', 'powersocket', 'cup', 'bed', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'dresser', 'sink', 'bathtub', 'home_office', 'table'] 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:['sheets', 'food_pizza', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'alcohol', 'mat', 'shower', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'coffee'] Task:Put groceries in Fridge response: { thoughts : I get my groceries and go to the fridge. I open the fridge and put the groceries there., 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:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouse', 'vacuum_cleaner', 'bathtub', 'sink', 'table'] Task:Pick up phone response: | { Walk into the living room, walk over to phone, grab the phone, put it to your ear . } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'mop', 'toilet', 'freezer', 'walllamp', 'bathroom', 'cat', 'food_butter', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'iron', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'toy', 'tape', 'photoframe', 'television', 'food_rice', 'doorjamb', 'cards', 'door'] Task:Relax on sofa response: { thoughts : walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>'] } Scene_Objects:['chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'stovefan', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'tape', 'newspaper', 'bed', 'television', 'doorjamb', 'mouse', 'sink', 'home_office', 'table', 'light'] Task:Work response: | { Walk to home office. Sit on chair. Switch on computer. type in keyboard. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table'] Task:Change TV channel response: { thoughts : Walk into living room. Find television remote control. Pick up remote control. Press button., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['food_bread', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bench', 'food_food', 'water', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'hands_both', 'shoe_rack'] 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:['sheets', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'food_bacon', 'alcohol', 'ceilinglamp', 'pillow', 'wall', 'powersocket', 'bed', 'curtain', 'doorjamb', 'kettle', 'mouse', 'dresser', 'cupboard', 'door', 'maindoor', 'light', 'creditcard'] Task:Turn on light response: { thoughts : I open the room door and press the light button on, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['pot', 'food_salt', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'stereo', 'couch', 'wall', 'nightstand', 'bench', 'powersocket', 'tape', 'bed', 'coffe_maker', 'check', 'tray', 'curtain', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'chair', 'bathroom', 'detergent', 'trashcan', 'toothbrush', 'knifeblock', 'bathroom_counter', 'character', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'nightstand', 'oven', 'bench', 'powersocket', 'cup', 'bed', 'ice', 'diary', 'cards', 'dresser', 'hairbrush', 'home_office', 'dishwasher', 'scrabble'] Task:Listen to music response: { thoughts : go to radio. run on radio., actions : ['[WALK] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['tablelamp', 'food_salt', 'walllamp', 'cat', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'toaster', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'powersocket', 'bed', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'kitchen_counter', 'home_office', 'table'] Task:Pet cat response: | { The cat is laying on the couch in the living room. I want to pet it, so I am going to walk to the living room, sit on the couch, and pet the cat. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'microwave', 'toilet', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'character', 'piano_bench', 'bookmark', 'toaster', 'mat', 'shower', 'dish_soap', 'couch', 'wall', 'photoframe', 'novel', 'coffe_maker', 'check', 'cards', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'sink', 'home_office', 'bathroom_cabinet', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : walk to kitchen, find the dishwasher, apply dish soap into vessels or dishwasher, wash the dishes with a dishwasher, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[WASH] <dishwasher>'] } Scene_Objects:['freezer', 'walllamp', 'cat', 'drawing', 'cpuscreen', 'floor', 'bedroom', 'keyboard', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'check', 'coffe_maker', 'television', 'curtain', 'cupboard', 'food_steak', 'sink', 'home_office', 'table', 'light', 'instrument_guitar'] 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:['sheets', 'toilet', 'chair', 'jelly', 'walllamp', 'cat', 'trashcan', 'hanger', 'floor', 'ceiling', 'phone', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'couch', 'wall', 'oven', 'bed', 'tray', 'kitchen_counter', 'shoes', 'dishrack', 'dresser', 'cupboard', 'bathroom_cabinet', 'light', 'teeth'] Task:Put away shoes response: { thoughts : Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door., actions : ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[FIND] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['sheets', 'tablelamp', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'faucet', 'shower', 'towel', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'board_game', '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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'drawing', 'clothes_underwear', 'hanger', 'bathroom_counter', 'bedroom', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mat', 'mousepad', 'couch', 'pillow', 'dining_room', 'food_food', 'check', 'coffe_maker', 'mirror', 'ice', 'wooden_spoon', 'rag', 'cupboard', 'door', 'sink', 'table'] Task:Clean mirror response: { thoughts : Spray glass cleaner on mirror. Wipe with a clean cloth., actions : ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[WALK] <mirror>', '[PUTOBJBACK] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>'] } Scene_Objects:['food_salt', 'toilet', 'knifeblock', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'bookshelf', 'brush', 'ceilinglamp', 'mat', 'stereo', 'toaster', 'pillow', 'wall', 'bench', 'photoframe', 'bed', 'novel', 'wine', 'after_shave', 'vacuum_cleaner', 'dresser', 'pajamas', 'table', 'board_game', 'shoe_rack'] Task:Vacuum response: | { Plug in vacuum. Walk around with vacuum, covering all of the floor. Unplug vacuum. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['measuring_cup', 'detergent', 'orchid', 'clothes_underwear', 'floor', 'character', 'button', 'stovefan', 'ceilinglamp', 'toaster', 'homework', 'mousepad', 'couch', 'dustpan', 'microphone', 'form', 'towel', 'powersocket', 'basket_for_clothes', 'bed', 'light_bulb', 'oven_mitts', 'tray', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'colander', 'washing_machine'] Task:Wash clothes response: { thoughts : Walk to laundry room. Find laundry basket. Grab laundry basket. Find washing machine. Walk to washing machine. Open washing machine. Find detergent. Grab detergent. Put in detergent. Put in clothes. Close washing machine. Turn on machine., actions : ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[PUTOBJBACK] <laundry_detergent>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['food_salt', 'chair', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'phone', 'remote_control', 'food_bacon', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'powersocket', 'oven', 'cup', 'bed', 'coffe_maker', 'television', 'curtain', 'lighter', 'doorjamb', 'shaving_cream', 'headset', 'cupboard', 'table', 'clothes_shirt'] Task:Watch TV response: | { We recently got a 43 inch TV and have enjoyed watching some of our favorite movies and TV shows. We use a remote to do so. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'detergent', 'food_butter', 'clothes_underwear', 'hanger', 'floor', 'stamp', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'shoe-shine_kit', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_pants', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'vacuum_cleaner', 'laundry_detergent', 'clothes_dress', 'bathroom_cabinet', 'light', 'dishwasher', 'clothes_shirt', 'washing_machine', 'creditcard'] Task:Wash clothes response: { thoughts : I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine., actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[DROP] <basket_for_clothes>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[GRAB] <laundry_detergent>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['dry_pasta', 'sponge', 'scissors', 'food_salt', 'trashcan', 'drawing', 'needle', 'hanger', 'longboard', 'floor', 'character', 'stamp', 'keyboard', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'window', 'couch', 'dining_room', 'wall', 'photoframe', 'television', 'curtain', 'rag', 'pencil', 'shoes', 'clothes_dress', 'conditioner', 'sink', 'table'] Task:Text friends while sitting on couch response: | { Text while sitting } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'blender', 'mop', 'bathroom', 'cat', 'trashcan', 'knifeblock', 'stamp', 'button', 'piano_bench', 'faucet', 'mousepad', 'bowl', 'nightstand', 'wall_clock', 'oven', 'wall', 'bench', 'photoframe', 'novel', 'food_food', 'coffe_maker', 'curtain', 'pencil', 'shoes', 'hairbrush', 'hair', 'instrument_guitar', 'dishwasher', 'tooth_paste'] Task:Read book response: { thoughts : pick up the book open the book and read, actions : ['[WALK] <bedroom>', '[WALK] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['dry_pasta', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'foundation', 'couch', 'wall', 'pasta', 'toy', 'box', 'television', 'curtain', 'diary', 'towel_rack', 'kitchen_counter', 'cupboard', 'clothes_scarf', 'home_office', 'table', 'vase', 'coffee'] Task:Change TV channels response: | { Take remote. Change to desired channel by you. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'door', 'table', 'light'] Task:Watch TV response: { thoughts : walk to living room, find couch, sit on couch, find remote control , turn on tv by pressing button, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>'] } Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'crayon', 'microwave', 'toilet', 'detergent', 'milk', 'folder', 'bedroom', 'toaster', 'stovefan', 'balanceball', 'stereo', 'window', 'mousepad', 'food_noodles', 'dining_room', 'nightstand', 'box', 'newspaper', 'tray', 'lighter', 'headset', 'controller', 'door', 'maindoor', 'instrument_guitar', 'table', 'soap'] Task:Walk through response: | { Walk through the entrance hall } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'filing_cabinet', 'blow_dryer', 'trashcan', 'drawing', 'knife', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'toaster', 'faucet', 'picture', 'towel', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'novel', 'food_food', 'controller', 'door', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'soap', 'board_game'] Task:Wash hands response: { thoughts : I walk into the bathroom. Walk to the sink. Turn on tap. Get soap. Wash and rinse hands. Turn off tap. Dry hands., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[LOOKAT] <sink>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[RINSE] <soap>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>'] } Scene_Objects:['measuring_cup', 'toilet', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'keyboard', 'remote_control', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'food_jam', 'pillow', 'wall', 'television', 'curtain', 'towel_rack', 'chessboard', 'table', 'light'] Task:Watch TV response: | { Sit on my couch directly opposite my tv , switch on my tv with the remote control and watch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'detergent', 'orchid', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'purse', 'envelope', 'mat', 'window', 'foundation', 'broom', 'wall', 'nightstand', 'keys', 'novel', 'check', 'toothbrush_holder', 'oven_mitts', 'curtain', 'doorjamb', 'mouse', 'dresser', 'hairdryer', 'home_office', 'clothes_shirt', 'coffee', 'creditcard'] Task:Put on coat response: { thoughts : Open closet and grab coat. Put on coat and fasten the front closed. Close closet., actions : ['[WALK] <home_office>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>'] } Scene_Objects:['fork', 'pot', 'tablelamp', 'crayon', 'toilet', 'bathroom', 'cat', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'faucet', 'shower', 'oil', 'clothes_pants', 'pillow', 'wall', 'bench', 'photoframe', 'television', 'shaving_cream', 'shoes', 'sink', 'bathroom_cabinet', 'light'] Task:Clean sink response: | { Take a premoistened cleaning wipe and wipe down top of sink and faucet. Next clean the sink bowl. Let air dry. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tea', 'ceilingfan', 'drawing', 'floor', 'bookshelf', 'ceilinglamp', 'shower', 'window', 'couch', 'food_orange', 'towel', 'dining_room', 'wall', 'powersocket', 'television', 'tray', 'wooden_spoon', 'rag', 'lighter', 'towel_rack', 'pencil', 'dresser', 'clothes_dress', 'hairdryer', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt'] Task:Relax on sofa response: { thoughts : walk to living room, find sofa, sit in sofa, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>'] } Scene_Objects:['filing_cabinet', 'measuring_cup', 'chair', 'ground_coffee', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'powersocket', 'cup', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'maindoor', 'light', 'table'] Task:Hang pictures response: | { My daughter was a week early which threw us for a loop. I'm still hanging pictures in her nursery. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'milk', 'toothbrush', 'drawing', 'orchid', 'cpuscreen', 'character', 'bedroom', 'stovefan', 'toaster', 'mousepad', 'clothes_pants', 'food_kiwi', 'wall_clock', 'bed', 'television', 'toothbrush_holder', 'water', 'tray', 'curtain', 'pencil', 'kitchen_counter', 'shoes', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'dirt'] Task:Brush teeth response: { thoughts : today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well, actions : ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <toothbrush>'] } Scene_Objects:['dry_pasta', 'pot', 'microwave', 'walllamp', 'food_butter', 'knifeblock', 'drawing', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'tvstand', 'balanceball', 'picture', 'shower', 'oil', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'television', 'coin', 'diary', 'mouse', 'cupboard', 'bag', 'bathroom_cabinet', 'vase', 'shoe_rack'] Task:Make popcorn response: | { Lay popcorn bag flat inside microwave and press popcorn button to start. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'band-aids', 'toothbrush', 'orchid', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'faucet', 'picture', 'shower', 'mousepad', 'candle', 'food_orange', 'oven', 'basket_for_clothes', 'bed', 'check', 'food_food', 'television', 'tray', 'after_shave', 'headset', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'bathroom_cabinet'] Task:Sit in chair response: { thoughts : I sit in a chair to rest and eat., actions : ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>'] } Scene_Objects:['pot', 'chair', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'toaster', 'mat', 'faucet', 'stereo', 'window', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'television', 'tray', 'food_onion', 'centerpiece', 'hairbrush', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'vase', 'soap', 'tooth_paste', 'hands_both'] Task:Wash hands response: | { Wash hands with soap and hot 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:['fork', 'tablelamp', 'microwave', 'toilet', 'freezer', 'trashcan', 'food_carrot', 'drawing', 'floor', 'ceiling', 'mat', 'ceilinglamp', 'shower', 'couch', 'wall', 'novel', 'food_food', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'home_office', 'instrument_guitar', 'bathroom_cabinet', 'table', 'dirt'] Task:Added meat to freezer response: { thoughts : After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['dry_pasta', 'tablelamp', 'nail_polish', 'food_carrot', 'dough', 'knife', 'drawing', 'floor', 'ceiling', 'character', 'desk', 'alcohol', 'table_cloth', 'mat', 'tvstand', 'window', 'couch', 'food_orange', 'wall', 'oven', 'photoframe', 'check', 'television', 'doorjamb', 'console', 'food_steak', 'sink', 'bathroom_cabinet', 'table', 'home_office'] Task:Put out flowers response: | { Place a flower centrepiece on the entrance hall table. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'chair', 'hanger', 'bathroom_counter', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'plate', 'tvstand', 'faucet', 'shower', 'dish_soap', 'mousepad', 'wall', 'wall_clock', 'oven', 'photoframe', 'bed', 'television', 'tray', 'towel_rack', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'dirt'] Task:Wash dishes with dishwasher response: { thoughts : walk into kitchen, find dishwasher, put plates in dishwasher, put soap in dishwasher, turn on dishwasher, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['chair', 'drawing', 'hanger', 'floor', 'phone', 'bedroom', 'purse', 'toaster', 'laptop', 'plate', 'ceilinglamp', 'tooth_paste', 'form', 'food_kiwi', 'wall', 'bench', 'powersocket', 'photoframe', 'food_food', 'television', 'centerpiece', 'doorjamb', 'diary', 'dresser', 'cupboard', 'door', 'maindoor', 'table', 'light', 'board_game'] Task:Eat response: | { Eating a meal } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'juice', 'cd_player', 'toilet', 'freezer', 'trashcan', 'bedroom', 'remote_control', 'button', 'clothes_jacket', 'toaster', 'laptop', 'ceilinglamp', 'plate', 'homework', 'dining_room', 'broom', 'bench', 'tape', 'keys', 'coffe_maker', 'television', 'towel_rack', 'hair', 'cupboard', 'maindoor', 'sink', 'clothes_skirt', 'vase'] 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:['fork', 'drawing', 'cpuscreen', 'ceiling', 'character', 'bedroom', 'man', 'keyboard', 'table_cloth', 'brush', 'stovefan', 'balanceball', 'picture', 'mousepad', 'couch', 'bowl', 'nightstand', 'pasta', 'cup', 'food_cheese', 'photoframe', 'curtain', 'shaving_cream', 'cards', 'laundry_detergent', 'maindoor', 'sink', 'napkin', 'home_office', 'bathroom_cabinet'] Task:Answer door response: | { Wait until doorbell rings, look to see who it is outside and open the door if you feel so inclined. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'dry_pasta', 'tablelamp', 'walllamp', 'detergent', 'milk', 'orchid', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'wall', 'box', 'basket_for_clothes', 'keys', 'coffe_maker', 'food_food', 'curtain', 'food_sugar', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'bathtub', 'sink', 'home_office', 'coffee_cup', 'dishwasher', 'clothes_skirt'] Task:Make coffee response: { thoughts : walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee, actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[LOOKAT] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <milk>', '[GRAB] <milk>', '[PUTBACK] <milk> <coffe_maker>', '[FIND] <food_sugar>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>'] } Scene_Objects:['sheets', 'tablelamp', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'phone', 'mop_bucket', 'bookmark', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'mat', 'stovefan', 'window', 'iron', 'couch', 'wall', 'food_cheese', 'photoframe', 'coffee_table', 'novel', 'video_game_controller', 'television', 'mouse', 'maindoor', 'bag', 'home_office', 'table', 'clothes_shirt'] Task:Read book response: | { Sit down in recliner. Pick up novel off of coffee table. Open novel to last read page. Begin reading } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'bills', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'television', 'toothbrush_holder', 'wine', 'doorjamb', 'mouse', 'dresser', 'hairbrush', 'controller', 'clothes_dress', 'home_office', 'light', 'table'] Task:Turn on computer response: { thoughts : Press the power button on the computer to turn it on, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['spectacles', 'ceilingfan', 'food_carrot', 'toothbrush', 'drawing', 'knife', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'wall', 'cup', 'photoframe', 'light_bulb', 'coffe_maker', 'television', 'tray', 'curtain', 'pencil', 'maindoor', 'table', 'light', 'coffee'] Task:Watch TV response: | { Turn TV on to TV channel and sit down on the couch and watch TV. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'door', 'light'] Task:Browse internet response: { thoughts : I want to surf the internet and look around at funny pictures., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'dog', 'freezer', 'dough', 'knifeblock', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'toaster', 'tvstand', 'faucet', 'couch', 'pasta', 'powersocket', 'oven', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'coffee_pot', 'mouse', 'dresser', 'door', 'sink', 'home_office', 'light', 'bathroom_cabinet'] Task:Greet guests response: | { Say hi } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['measuring_cup', 'microwave', 'chair', 'freezer', 'nail_polish', 'bathroom', 'food_butter', 'knifeblock', 'cpuscreen', 'hanger', 'ceiling', 'dvd_player', 'stamp', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'iron', 'nightstand', 'oven', 'cutting_board', 'check', 'television', 'coin', 'tray', 'doorjamb', 'bathroom_cabinet', 'teeth'] Task:Answer door response: { thoughts : Walk up to the door. Open the door and greet whomever is out side, actions : ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>'] } Scene_Objects:['pot', 'mop', 'toilet', 'chair', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'computer', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'wall_clock', 'bench', 'television', 'wine', 'curtain', 'coffee_pot', 'door', 'sink', 'spoon', 'table'] Task:Watch TV response: | { I watch Netflix from about 8:30 to 10:30 every night. I usually watch TV shows. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'band-aids', 'trashcan', 'dough', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'mousepad', 'food_orange', 'wall', 'oven', 'keys', 'mouse', 'shoes', 'hair', 'dishwasher', 'vase', 'coffee'] Task:Read book response: { thoughts : find a book to read. sit down. read the book., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['filing_cabinet', 'tea', 'bathroom', 'ceilingfan', 'milk', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'shoe-shine_kit', 'couch', 'food_jam', 'microphone', 'wall', 'nightstand', 'oven', 'cutting_board', 'television', 'curtain', 'pencil', 'table'] Task:Watch TV response: | { We sit all around the television and watch a program. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'table_cloth', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'keys', 'newspaper', 'food_rice', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet', 'light', 'scrabble'] Task:Turn light off response: { thoughts : Put the light switch into the down, or off, position., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHOFF] <light>'] } Scene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'chair', 'walllamp', 'trashcan', 'food_carrot', 'clothes_underwear', 'hanger', 'longboard', 'floor', 'ceiling', 'toaster', 'electric_shaver', 'couch', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'food_food', 'television', 'cards', 'mouse', 'kitchen_counter', 'maindoor', 'home_office', 'light', 'dishwasher', 'coffee'] Task:Make coffee response: | { Making coffee } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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: { 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:['spectacles', 'chair', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'character', 'bookshelf', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'shower', 'stereo', 'couch', 'wall', 'cutting_board', 'cup', 'food_cheese', 'novel', 'food_food', 'television', 'wine', 'curtain', 'door', 'table'] Task:Watch movie response: | { Sit down on couch in front of TV. Use remote to turn on the 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:['food_pizza', 'toilet', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'envelope', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'stereo', 'mousepad', 'towel', 'wall', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'tray', 'curtain', 'doorjamb', 'dresser', 'controller', 'door', 'food_steak', 'light', 'tooth_paste'] Task:Take shower response: { thoughts : walk to bathroom , find shower , take a shower, actions : ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>'] } Scene_Objects:['sponge', 'pot', 'crayon', 'tea', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'mat', 'faucet', 'picture', 'wall', 'oven', 'food_food', 'check', 'television', 'ice', 'tray', 'rag', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'spoon'] Task:Clean response: | { Take out a rag. Turn on faucet and get water on the rag. Clean counter 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', 'microwave', 'toilet', 'bathroom', 'food_butter', 'milk', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_hat', 'wall', 'coffe_maker', 'television', 'tray', 'curtain', 'dresser', 'bathtub', 'bathroom_cabinet', 'table'] Task:Pick up phone response: { thoughts : Walk to the entrance hall. Find the telephone. Grab the telephone., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['juice', 'measuring_cup', 'microwave', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'face', 'mop_bucket', 'tvstand', 'faucet', 'food_peanut_butter', 'towel', 'wall', 'oven', 'face_soap', 'tape', 'photoframe', 'bed', 'keys', 'rag', 'cards', 'comb', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet'] Task:Wash face response: | { Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand 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:['fork', 'blow_dryer', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'kitchen_cabinet', 'floor', 'phone', 'desk', 'computer', 'laptop', 'plate', 'stereo', 'oil', 'clothes_hat', 'wall', 'bench', 'oven', 'powersocket', 'newspaper', 'coffe_maker', 'curtain', 'rag', 'kitchen_counter', 'maindoor', 'home_office', 'table', 'light', 'soap'] Task:Set up table response: { thoughts : Walk into kitchen. Grab plates and forks. Walk into dining room. Put plates and forks on table., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <fork> <table>', '[PUTBACK] <plate> <table>'] } Scene_Objects:['filing_cabinet', 'blender', 'beer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'shower', 'couch', 'pillow', 'wall', 'powersocket', 'tape', 'photoframe', 'after_shave', 'doorjamb', 'shoes', 'comb', 'door', 'maindoor', 'bathroom_cabinet', 'light', 'vase', 'colander', 'coffee'] Task:Turn light off response: | { Put the light switch into the down, or off, 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:['sheets', 'microwave', 'chair', 'cat', 'dough', 'bathroom_counter', 'phone', 'bookshelf', 'ceilinglamp', 'tvstand', 'stereo', 'candle', 'bowl', 'dining_room', 'wall', 'newspaper', 'coffe_maker', 'food_food', 'coffee_filter', 'tray', 'curtain', 'diary', 'towel_rack', 'pencil', 'dresser', 'food_steak', 'sink', 'napkin', 'door', 'dishwasher'] Task:Pick up phone response: { thoughts : I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>'] } Scene_Objects:['pot', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'faucet', 'picture', 'window', 'dustpan', 'towel', 'wall', 'nightstand', 'photoframe', 'keys', 'toothbrush_holder', 'food_donut', 'mouse', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'vase', 'soap', 'hands_both'] Task:Wash hands response: | { Cleaning 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:['food_butter', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'bench', 'cutting_board', 'cup', 'check', 'food_donut', 'food_rice', 'curtain', 'centerpiece', 'mouse', 'vacuum_cleaner', 'shoes', 'dresser', 'light', 'teeth'] Task:Vacuum response: { thoughts : Run the vacuum cleaner across the floor, back and forth a couple of times until clean., actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>'] } Scene_Objects:['measuring_cup', 'microwave', 'cat', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'desk', 'mat', 'deck_of_cards', 'iron', 'stereo', 'balanceball', 'shower', 'faucet', 'mousepad', 'nightstand', 'oven', 'television', 'tray', 'curtain', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'vase'] Task:Walk through response: | { Walk through the hallway. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'crayon', 'ceilingfan', 'drawing', 'needle', 'floor', 'ceiling', 'shampoo', 'keyboard', 'remote_control', 'thread', 'food_bacon', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'photoframe', 'bed', 'television', 'coffee_filter', 'curtain', 'mouse', 'table', 'light', 'laser_pointer'] Task:Watch TV response: { thoughts : I go into the living room. I find the remote. I turn on the tv. I sit on the couch and watch tv., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['fork', 'pot', 'walllamp', 'knife', 'knifeblock', 'cpuscreen', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'tea_bag', 'toaster', 'stovefan', 'plate', 'faucet', 'deck_of_cards', 'tvstand', 'bowl', 'wall', 'oven', 'cup', 'coffe_maker', 'drinking_glass', 'food_donut', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'dishwasher'] Task:Unload dishwasher response: | { Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'bathroom', 'hanger', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'bookshelf', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'closetdrawer', 'couch', 'pillow', 'cup', 'coffe_maker', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'home_office', 'light', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['sheets', 'pot', 'food_bread', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'button', 'stovefan', 'toaster', 'ceilinglamp', 'faucet', 'wall', 'oven', 'food_food', 'video_game_controller', 'television', 'razor', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'spoon', 'dishwasher'] Task:Cook some food response: | { Cooking a meal } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'microwave', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'button', 'food_bacon', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'coffee_table', 'novel', 'mouthwash', 'television', 'doorjamb', 'diary', 'clothes_scarf', 'sink'] Task:Read book response: { thoughts : Sit down in recliner. Pick up novel off of coffee table. Open novel to last read page. Begin reading, actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <bookmark>', '[READ] <novel>'] } Scene_Objects:['sheets', 'pot', 'scissors', 'juice', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'faucet', 'towel', 'dining_room', 'wall', 'photoframe', 'food_food', 'razor', 'television', 'food_rice', 'wooden_spoon', 'after_shave', 'headset', 'laundry_detergent', 'conditioner', 'sink', 'bathroom_cabinet', 'table', 'soap', 'hands_both'] Task:Wash hands response: | { Turn on the water faucet. Wet my hands and turn off the faucet. Put soap on my hands. Rub hands together, making sure the soap covers all areas of the hands. Scrub hands for about 20 seconds. Turn on the water water faucet. Rinse hands under the running water. Turn off the water faucet. Dry 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', 'filing_cabinet', 'tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'mouse', 'chessboard', 'dresser', 'cupboard', 'door', 'light', 'table'] Task:Re arrange office response: { thoughts : Walk in.Turn on light.Move furniture. Change the room, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[PUSH] <desk>', '[WALK] <chair>', '[PUSH] <chair>', '[WALK] <couch>', '[PUSH] <couch>', '[WALK] <filing_cabinet>', '[PUSH] <filing_cabinet>'] } Scene_Objects:['scissors', 'bathroom', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bookshelf', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'couch', 'dining_room', 'food_kiwi', 'wall', 'toilet_paper', 'razor', 'television', 'curtain', 'diary', 'towel_rack', 'door', 'bathroom_cabinet', 'table', 'creditcard'] Task:Watch TV response: | { Sit on the couch and use the remote control to turn on the 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', 'juice', 'measuring_cup', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'mouse', 'pencil', 'cupboard', 'door', 'maindoor', 'home_office', 'light', 'dishwasher', 'creditcard'] Task:Work response: { thoughts : turn computer on, open application to work with, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['pot', 'food_salt', 'microwave', 'ceilingfan', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'stovefan', 'mat', 'iron', 'electric_shaver', 'food_noodles', 'mousepad', 'couch', 'clothes_pants', 'pillow', 'powersocket', 'keys', 'coffe_maker', 'oven_mitts', 'wine', 'shaving_cream', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'light', 'tooth_paste'] Task:Hang up car keys response: | { Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'beer', 'tea', 'ground_coffee', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'plate', 'tvstand', 'closetdrawer', 'couch', 'food_jam', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'chessboard', 'door', 'light'] Task:Turn on light response: { thoughts : walk into living room, walk to light, turn on light switch., actions : ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>'] } Scene_Objects:['food_pizza', 'tablelamp', 'juice', 'scissors', 'beer', 'chair', 'freezer', 'bathroom', 'ceilingfan', 'hanger', 'floor', 'computer', 'food_bacon', 'mat', 'couch', 'creditcard', 'dining_room', 'oven', 'tape', 'bed', 'light_bulb', 'novel', 'food_food', 'mouse', 'cupboard', 'conditioner', 'home_office', 'table', 'scrabble', 'shoe_rack'] Task:Pet dog response: | { Pet my dog in hall } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'dog', 'blow_dryer', 'trashcan', 'orchid', 'bathroom_counter', 'longboard', 'ceiling', 'character', 'bedroom', 'computer', 'mop_bucket', 'stereo', 'shower', 'window', 'food_peanut_butter', 'food_orange', 'bench', 'oven', 'bed', 'toilet_paper', 'television', 'razor', 'curtain', 'towel_rack', 'cupboard', 'door', 'dishwasher', 'soap'] Task:Put umbrella away response: { thoughts : Place the umbrella in the umbrella bucket point first., actions : ['[WALK] <home_office>', '[WALK] <mop_bucket>'] } Scene_Objects:['food_pizza', 'blender', 'food_salt', 'beer', 'tea', 'ceilingfan', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'face', 'mat', 'faucet', 'food_noodles', 'towel', 'wall', 'facial_cleanser', 'photoframe', 'food_rice', 'after_shave', 'rag', 'kitchen_counter', 'sink', 'napkin', 'bathroom_cabinet', 'dirt'] Task:Wash face response: | { Turn the faucet on. Wet the face. Take facial cleanser out of packaging. Lather on face. Rinse face with water. Turn off the faucet. Dry face with towel. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['drawing', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'computer', 'button', 'mat', 'ceilinglamp', 'shower', 'faucet', 'tvstand', 'food_peanut_butter', 'towel', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'curtain', 'mouse', 'kitchen_counter', 'shoes', 'laundry_detergent', 'food_steak', 'sink', 'bag', 'bathroom_cabinet', 'door', 'vase', '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:['tablelamp', 'food_ice_cream', 'toilet', 'chair', 'walllamp', 'cpuscreen', 'longboard', 'floor', 'character', 'desk', 'bookshelf', 'keyboard', 'envelope', 'computer', 'button', 'table_cloth', 'ceilinglamp', 'window', 'mousepad', 'oil', 'dustpan', 'wall', 'nightstand', 'powersocket', 'photoframe', 'clothes_gloves', 'mouse', 'sink', 'bathroom_cabinet', 'printing_paper'] Task:Add paper to printer response: | { Take a stack of paper, about 25 pieces. Place carefully in the paper tray. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['nail_polish', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'thread', 'faucet', 'couch', 'dining_room', 'wall', 'nightstand', 'bench', 'wall_clock', 'photoframe', 'coffe_maker', 'food_food', 'lighter', 'doorjamb', 'towel_rack', 'diary', 'shoes', 'comb', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap', 'dirt', 'hands_both'] Task:Wash hands response: { thoughts : Go to the bathroom. turn on the water in the sink. apply soap to hands. rub hands together. rinse hands with water. turn off the water., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[WIPE] <hands_both>'] } Scene_Objects:['dry_pasta', 'sheets', 'tablelamp', 'nail_polish', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'ceiling', 'phone', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'photoframe', 'television', 'curtain', 'laundry_detergent', 'bathroom_cabinet', 'table', 'light', 'shoe_rack'] Task:Straighten pictures on wall response: | { Move the pictures/paintings until they are straight. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'computer', 'mat', 'shoe-shine_kit', 'oil', 'pillow', 'wall', 'pasta', 'powersocket', 'cup', 'food_food', 'video_game_controller', 'toothbrush_holder', 'television', 'doorjamb', 'kettle', 'door', 'light', 'clothes_skirt', 'coffee'] Task:Turn on light response: { thoughts : switching on light in an area, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['fork', 'food_pizza', 'filing_cabinet', 'tablelamp', 'freezer', 'nail_polish', 'cat', 'food_carrot', 'drawing', 'orchid', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'stamp', 'ceilinglamp', 'plate', 'candle', 'dining_room', 'wall', 'bench', 'food_vegetable', 'newspaper', 'food_food', 'television', 'after_shave', 'cards', 'cd', 'clothes_dress', 'table'] Task:Fix snack response: | { Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['juice', 'measuring_cup', 'microwave', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'face', 'mop_bucket', 'tvstand', 'faucet', 'food_peanut_butter', 'towel', 'wall', 'oven', 'face_soap', 'tape', 'photoframe', 'bed', 'keys', 'rag', 'cards', 'comb', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet'] Task:Wash face response: { thoughts : Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <rag>', '[GRAB] <rag>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[WASH] <rag>', '[FIND] <face_soap>', '[GRAB] <face_soap>', '[POUR] <face_soap> <rag>', '[PUTOBJBACK] <face_soap>', '[FIND] <face>', '[SCRUB] <face>', '[PUTBACK] <rag> <sink>', '[RINSE] <face>', '[RINSE] <rag>', '[SWITCHOFF] <faucet>', '[GRAB] <rag>', '[PUTOBJBACK] <rag>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['spectacles', 'toilet', 'walllamp', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'remote_control', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'wall', 'powersocket', 'food_food', 'television', 'curtain', 'towel_rack', 'headset', 'door', 'bathroom_cabinet', 'table', 'clothes_skirt'] Task:Watch TV response: | { We sit all around the television and watch a program. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'tablelamp', 'measuring_cup', 'microwave', 'blow_dryer', 'bathroom', 'woman', 'knifeblock', 'clothes_underwear', 'phone', 'dvd_player', 'man', 'mail', 'toaster', 'iron', 'faucet', 'food_orange', 'child', 'powersocket', 'cup', 'food_cheese', 'check', 'tray', 'curtain', 'door', 'sink', 'home_office', 'dishwasher', 'clothes_skirt', 'tooth_paste'] Task:Say goodbye to guests leaving response: { thoughts : Tell them bye, actions : ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[FIND] <man>', '[TOUCH] <man>', '[FIND] <woman>', '[TOUCH] <woman>'] } Scene_Objects:['chair', 'freezer', 'trashcan', 'hanger', 'floor', 'ceiling', 'phone', 'mail', 'tvstand', 'clothes_socks', 'oil', 'mousepad', 'food_peanut_butter', 'food_orange', 'form', 'wall', 'cup', 'check', 'mouthwash', 'television', 'tray', 'doorjamb', 'dishrack', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'sink', 'light', 'soap'] Task:Turn light off response: | { Put the light switch into the down, or off, 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:['pot', 'microwave', 'walllamp', 'knifeblock', 'orchid', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'food_bacon', 'stovefan', 'toaster', 'plate', 'faucet', 'window', 'homework', 'closetdrawer', 'wall', 'oven', 'ice', 'tray', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'hairdryer', 'sink', 'bathroom_cabinet', 'coffee'] Task:Wash dishes by hand response: { thoughts : Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[TURNTO] <plate>', '[LOOKAT] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WASH] <plate>', '[PUTBACK] <plate> <kitchen_counter>'] } Scene_Objects:['sheets', 'pot', 'fork', 'tablelamp', 'food_salt', 'microwave', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'nightstand', 'bed', 'novel', 'television', 'curtain', 'lighter', 'mouse', 'door', 'table', 'dishwasher'] Task:Admire art response: | { Looking at painting, art } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_ice_cream', 'mop', 'tea', 'freezer', 'walllamp', 'floor', 'character', 'stovefan', 'toaster', 'mat', 'tvstand', 'stereo', 'window', 'electric_shaver', 'food_noodles', 'couch', 'soap', 'pillow', 'wall', 'bench', 'toilet_paper', 'food_food', 'doorjamb', 'diary', 'dresser', 'hairbrush', 'napkin', 'bathroom_cabinet', 'colander'] Task:Go to toilet response: { thoughts : I walk to bathroom. find closet. Uset It. Clean it. Use Toilet paper, actions : ['[WALK] <bathroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[CLOSE] <dresser>', '[FIND] <toilet_paper>', '[WASH] <dresser>', '[FIND] <toilet_paper>', '[TOUCH] <toilet_paper>'] } Scene_Objects:['fork', 'spectacles', 'tea', 'ceilingfan', 'trashcan', 'drawing', 'food_egg', 'floor', 'ceiling', 'desk', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'oil', 'couch', 'pillow', 'wall', 'bed', 'coffe_maker', 'television', 'curtain', 'sink', 'bathroom_cabinet', 'table', 'light', 'vase'] Task:Watch TV response: | { I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'walllamp', 'bathroom', 'detergent', 'cpuscreen', 'ceiling', 'computer', 'toaster', 'brush', 'laptop', 'faucet', 'mousepad', 'clothes_pants', 'dirt', 'powersocket', 'oven', 'cup', 'bed', 'food_food', 'television', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'chessboard', 'laundry_detergent', 'sink', 'dishwasher', 'washing_machine'] Task:Wash clothes response: { thoughts : Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine., actions : ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[PLUGIN] <washing_machine>'] } Scene_Objects:['filing_cabinet', 'woman', 'clothes_underwear', 'hanger', 'desk', 'man', 'bedroom', 'computer', 'ceilinglamp', 'mat', 'deck_of_cards', 'child', 'bench', 'cup', 'newspaper', 'photoframe', 'coffe_maker', 'video_game_controller', 'towel_rack', 'pencil', 'kitchen_counter', 'dresser', 'food_steak', 'sink', 'bathroom_cabinet', 'home_office', 'table', 'light', 'tooth_paste', 'laser_pointer'] Task:Say goodbye to guests leaving response: | { Tell them bye } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'measuring_cup', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'bench', 'cup', 'photoframe', 'novel', 'check', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light', 'table'] Task:Read book response: { thoughts : I go to the book case, I select a book, I go back and sit down, then I read., actions : ['[WALK] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[READ] <novel>'] } 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: | { Sit down at the dinning table with my family and eat dinner. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'food_carrot', 'drawing', 'hanger', 'phone', 'ceiling', 'desk', 'computer', 'toaster', 'mat', 'mousepad', 'closetdrawer', 'food_peanut_butter', 'towel', 'cup', 'food_cheese', 'keys', 'tray', 'after_shave', 'towel_rack', 'mouse', 'cupboard', 'sink', 'coffee'] Task:Pet cat response: { thoughts : I walk into the living room and I pet the cat, actions : ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['fork', 'filing_cabinet', 'chair', 'drawing', 'bills', 'knife', 'floor', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_jam', 'form', 'towel', 'dining_room', 'wall', 'basket_for_clothes', 'photoframe', 'novel', 'food_food', 'check', 'television', 'oven_mitts', 'razor', 'tray', 'pencil', 'dresser', 'pajamas', 'table', 'soap'] Task:Read book response: | { Sit and read } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'crayon', 'freezer', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'orchid', 'floor', 'ceiling', 'clothes_jacket', 'brush', 'ceilinglamp', 'mat', 'balanceball', 'clothes_socks', 'couch', 'microphone', 'form', 'wall', 'food_food', 'check', 'oven_mitts', 'wine', 'mouse', 'cupboard', 'food_steak', 'spoon', 'table', 'tooth_paste'] Task:Cook some food response: { thoughts : Go kitchen and make something for eat, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>'] } Scene_Objects:['sheets', 'crayon', 'food_butter', 'food_carrot', 'bills', 'hanger', 'longboard', 'phone', 'keyboard', 'computer', 'electric_shaver', 'window', 'homework', 'mousepad', 'wall', 'bench', 'powersocket', 'photoframe', 'newspaper', 'novel', 'television', 'tray', 'mouse', 'vacuum_cleaner', 'dresser', 'hairbrush', 'napkin', 'table', 'vase', 'electrical_outlet'] Task:Vacuum response: | { Plug vacuum into the wall. Turn on the vacuum. Move vacuum around the floor to clean it. Unplug vacuum. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'deck_of_cards', 'picture', 'mousepad', 'wall', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'cards', 'mouse', 'door', 'light', 'printing_paper'] Task:Add paper to printer response: { thoughts : Take a stack of paper, about 25 pieces. Place carefully in the paper tray., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[WALK] <fax_machine>', '[PUTBACK] <printing_paper> <fax_machine>'] } Scene_Objects:['toilet', 'chair', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'oil', 'couch', 'wall', 'cup', 'food_food', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'console', 'hairbrush', 'cupboard', 'food_steak', 'maindoor', 'door', 'table'] Task:Watch TV response: | { Watch favorite shows, netflix, hulu } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'mousepad', 'pillow', 'wall', 'cutting_board', 'box', 'toilet_paper', 'doorjamb', 'centerpiece', 'towel_rack', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'door', 'light', 'dishwasher', 'shoe_rack'] Task:Pick up phone response: { thoughts : Walk to living room. Go near telephone. take the receiver and then talk to other person on that side., actions : ['[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['filing_cabinet', 'mop', 'toilet', 'ceilingfan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'character', 'video_game_console', 'food_cake', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'couch', 'wall', 'powersocket', 'tape', 'cup', 'video_game_controller', 'television', 'mouthwash', 'curtain', 'hairdryer', 'table', 'coffee'] Task:Play games response: | { Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video game remote controller. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'filing_cabinet', 'nail_polish', 'toothbrush', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'food_food', 'toothbrush_holder', 'tray', 'dresser', 'cupboard', 'controller', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'light', 'tooth_paste'] Task:Wash teeth response: { thoughts : I go into the bathroom, go to the sink, get toothbrush and toothpaste. Put toothpaste on the toothbrush, brush teeth, turn on faucet, rinse brush, and return toothbrush., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[PUTBACK] <toothbrush> <toothbrush_holder>'] } Scene_Objects:['food_salt', 'walllamp', 'detergent', 'orchid', 'drawing', 'cpuscreen', 'keyboard', 'envelope', 'computer', 'stovefan', 'faucet', 'electric_shaver', 'couch', 'candle', 'microphone', 'broom', 'nightstand', 'oven', 'bench', 'tape', 'cup', 'light_bulb', 'food_rice', 'wine', 'wooden_spoon', 'hair', 'maindoor', 'table', 'dishwasher', 'vase'] Task:Dust response: | { Get a broom or duster with long handle. Dust blades of ceiling fan. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'dresser', 'hairbrush', 'clothes_dress', 'door', 'sink', 'spoon', 'table', 'light'] Task:Change TV channel response: { thoughts : I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['freezer', 'milk', 'drawing', 'orchid', 'knife', 'food_egg', 'hanger', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'folder', 'mail', 'ceilinglamp', 'tvstand', 'food_orange', 'wall', 'bench', 'cutting_board', 'food_vegetable', 'bed', 'food_food', 'television', 'tray', 'curtain', 'mouse', 'pencil', 'table', 'colander'] Task:Chop vegetables response: | { Cut up veggies with knife } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'mat', 'tvstand', 'mousepad', 'pillow', 'dining_room', 'wall', 'coffee_table', 'novel', 'television', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'cupboard', 'light'] Task:Read book response: { thoughts : I walk to the living room and pick up a book from the coffee table. I find my favorite chair. I sit in the armchair and open the book. I read., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[WALK] <coffee_table>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['food_salt', 'ceilingfan', 'dough', 'drawing', 'orchid', 'longboard', 'floor', 'ceiling', 'phone', 'character', 'remote_control', 'mail', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'faucet', 'couch', 'wall', 'oven', 'keys', 'television', 'coin', 'coffee_filter', 'curtain', 'dresser', 'maindoor', 'home_office', 'table'] Task:Watch TV response: | { Sit on my couch directly opposite my tv , switch on my tv with the remote control and watch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['freezer', 'trashcan', 'food_carrot', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'alcohol', 'button', 'ceilinglamp', 'plate', 'clothes_socks', 'couch', 'food_orange', 'wall', 'bench', 'powersocket', 'photoframe', 'light_bulb', 'food_food', 'coffee_filter', 'drinking_glass', 'water', 'towel_rack', 'dishrack', 'cupboard', 'clothes_dress', 'light', 'colander'] Task:Drink response: { thoughts : im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <drinking_glass>', '[DRINK] <drinking_glass>'] } Scene_Objects:['food_salt', 'microwave', 'trashcan', 'hanger', 'floor', 'bedroom', 'computer', 'button', 'brush', 'mat', 'shower', 'faucet', 'window', 'clothes_hat', 'wall', 'child', 'oven', 'bed', 'newspaper', 'novel', 'curtain', 'centerpiece', 'doorjamb', 'mouse', 'cd', 'dresser', 'hairdryer', 'clothes_scarf', 'vase', 'board_game'] Task:Story reading time response: | { Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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:['filing_cabinet', 'food_ice_cream', 'toilet', 'bathroom', 'detergent', 'ceilingfan', 'food_butter', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'pillow', 'wall', 'food_food', 'television', 'tray', 'curtain', 'after_shave', 'cupboard', 'table', 'laser_pointer'] Task:Watch TV response: | { TURN ON TV, SIT ON COUCH ACROSS THE ROOM, USE REMOTE TO LOOK FOR SHOW TO WATCH } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'toilet', 'walllamp', 'cat', 'drawing', 'floor', 'ceiling', 'character', 'bookshelf', 'food_cake', 'piano_bench', 'shower', 'faucet', 'pillow', 'wall', 'photoframe', 'bed', 'curtain', 'doorjamb', 'diary', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'soap', 'instrument_violin'] Task:Go to toilet response: { thoughts : Walk to the bathroom. Find the toilet. Lift the top of the toilet. Sit on the toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>'] } Scene_Objects:['chair', 'cat', 'trashcan', 'woman', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'mail', 'stovefan', 'oil', 'mousepad', 'clothes_hat', 'wall', 'child', 'powersocket', 'cutting_board', 'basket_for_clothes', 'television', 'curtain', 'doorjamb', 'chessboard', 'dresser', 'cupboard', 'pajamas', 'door', 'napkin', 'light'] Task:Greet guests response: | { Go to the kitchen, greet your family members } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'hanger', 'floor', 'phone', 'desk', 'bookshelf', 'computer', 'piano_bench', 'stovefan', 'plate', 'tvstand', 'window', 'mousepad', 'wall', 'powersocket', 'box', 'photoframe', 'novel', 'doorjamb', 'towel_rack', 'dresser', 'cupboard', 'door', 'light', 'vase', 'colander', 'shoe_rack'] Task:Read response: { thoughts : We pick out a book from the bookshelf and read it., actions : ['[WALK] <novel>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['food_salt', 'toilet', 'detergent', 'food_butter', 'dough', 'food_carrot', 'drawing', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'keyboard', 'computer', 'clothes_jacket', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'mousepad', 'towel', 'wall', 'oven', 'cup', 'photoframe', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'hands_both'] Task:Wash hands response: | { Wash hands with soap and hot water } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'measuring_cup', 'walllamp', 'bathroom', 'trashcan', 'ceilingfan', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'shampoo', 'character', 'toaster', 'mat', 'dish_soap', 'couch', 'wall', 'nightstand', 'oven', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'shaving_cream', 'cupboard', 'food_steak', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I go to the dishwasher and put dish soap. I close the dishwasher and turn it on., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['toilet', 'detergent', 'ceilingfan', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'remote_control', 'envelope', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'mousepad', 'couch', 'wall', 'love_seat', 'newspaper', 'keys', 'television', 'toothbrush_holder', 'curtain', 'after_shave', 'clothes_scarf', 'table'] Task:Watch TV response: | { I'll watch TV } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'milk', 'knife', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'purse', 'computer', 'mat', 'tvstand', 'foundation', 'window', 'mousepad', 'closetdrawer', 'couch', 'bowl', 'wall', 'powersocket', 'keys', 'coffee_filter', 'mouse', 'dresser', 'home_office', 'light', 'coffee'] Task:Hang keys response: { thoughts : Remove keys from purse, pocket or hand. Place in designated area (bowl, or on hook). Leave area, actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <purse>', '[GRAB] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[FIND] <bowl>', '[PUTBACK] <keys> <bowl>', '[CLOSE] <purse>', '[PUTOBJBACK] <purse>'] } Scene_Objects:['microwave', 'toilet', 'dog', 'toothbrush', 'bills', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'purse', 'faucet', 'balanceball', 'food_noodles', 'wall', 'bench', 'cup', 'photoframe', 'mouthwash', 'console', 'kitchen_counter', 'cupboard', 'sink', 'bag', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: | { go to bathroom. walk to sink,turn on faucet, put hands in water. rub hands together. grab soap. rub soap in hands. put soap down. put hands under water. rubs hands together. turn off faucet } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'walllamp', 'detergent', 'orchid', 'floor', 'ceiling', 'keyboard', 'remote_control', 'computer', 'button', 'alcohol', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'check', 'mouthwash', 'television', 'coffe_maker', 'curtain', 'dresser', 'clothes_dress', 'door', 'sink', 'table'] Task:Change TV channel response: { thoughts : I go to the livingroom. The TV is on. I pick up the remote and press the next channel button. I look at the television, and see that the channel has changed., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'hanger', 'floor', 'phone', 'desk', 'bookshelf', 'computer', 'piano_bench', 'stovefan', 'plate', 'tvstand', 'window', 'mousepad', 'wall', 'powersocket', 'box', 'photoframe', 'novel', 'doorjamb', 'towel_rack', 'dresser', 'cupboard', 'door', 'light', 'vase', 'colander', 'shoe_rack'] Task:Read response: | { We pick out a book from the bookshelf and read it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'chair', 'nail_polish', 'knife', 'cpuscreen', 'floor', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'mousepad', 'closetdrawer', 'couch', 'dining_room', 'wall', 'basket_for_clothes', 'cup', 'check', 'television', 'curtain', 'mouse', 'chessboard', 'shoes', 'comb', 'cupboard', 'hairdryer', 'door', 'home_office'] Task:Read book response: { thoughts : find a book to read. sit down. read the book., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['juice', 'freezer', 'ground_coffee', 'detergent', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'faucet', 'shower', 'balanceball', 'food_noodles', 'candle', 'bowl', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'toothbrush_holder', 'rag', 'doorjamb', 'towel_rack', 'conditioner', 'sink', 'bathroom_cabinet', 'soap', 'laser_pointer'] Task:Wipe down sink response: | { Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'tablelamp', 'walllamp', 'bathroom', 'trashcan', 'food_carrot', 'clothes_underwear', 'floor', 'desk', 'toaster', 'plate', 'shower', 'tvstand', 'food_noodles', 'clothes_socks', 'mousepad', 'wall', 'oven', 'cup', 'newspaper', 'coffe_maker', 'toilet_paper', 'food_donut', 'water', 'tray', 'food_onion', 'lighter', 'maindoor', 'spoon', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : first i will take all the dishes to the dish washer and with the help of dishwasher and water i will clean all the dishes, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <water>', '[TURNTO] <water>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['sheets', 'microwave', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'bills', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'folder', 'stovefan', 'tvstand', 'window', 'homework', 'wall', 'oven', 'powersocket', 'cutting_board', 'basket_for_clothes', 'food_cheese', 'clothes_gloves', 'check', 'television', 'toothbrush_holder', 'curtain', 'bathroom_cabinet', 'laser_pointer'] Task:Open window response: | { Unlock the latch at the top. Push the bottom half of the window upwards. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_pizza', 'tablelamp', 'dog', 'cat', 'drawing', 'food_egg', 'floor', 'phone', 'piano_bench', 'mat', 'mousepad', 'oil', 'food_jam', 'pillow', 'wall_clock', 'photoframe', 'coffe_maker', 'food_donut', 'food_rice', 'tray', 'after_shave', 'kitchen_counter', 'clothes_dress', 'door', 'sink', 'bag', 'bathroom_cabinet', 'table', 'dishwasher', 'creditcard'] Task:Pick up phone response: { thoughts : walk to living room , find phone ,pick up phone 3, actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>'] } Scene_Objects:['filing_cabinet', 'food_salt', 'crayon', 'freezer', 'walllamp', 'bathroom', 'knifeblock', 'orchid', 'drawing', 'cpuscreen', 'longboard', 'bathroom_counter', 'character', 'bedroom', 'bookshelf', 'toaster', 'mat', 'foundation', 'nightstand', 'wall', 'oven', 'cup', 'television', 'tray', 'mouse', 'shoes', 'cupboard', 'bathroom_cabinet', 'light', 'tooth_paste'] Task:Walk through response: | { Walk through the hallway. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'mousepad', 'couch', 'food_kiwi', 'wall', 'bench', 'cup', 'check', 'television', 'curtain', 'napkin', 'table', 'soap', 'instrument_violin'] Task:Watch TV response: { thoughts : I walk into the living room. I sit on the couch. I pick up the remote control. I push the power button. I push the guide button and look for my favorite show The Middle. I click that channel and enjoy my show., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUSH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['sponge', 'freezer', 'ceilingfan', 'food_butter', 'drawing', 'orchid', 'food_egg', 'floor', 'ceiling', 'phone', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'deck_of_cards', 'window', 'mousepad', 'couch', 'wall', 'pasta', 'television', 'curtain', 'rag', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'door', 'table', 'creditcard'] Task:Watch TV response: | { In the evenings after dinner, we sit on the couch, turn on the television, cue up Netflix and watch our favorite shows. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['measuring_cup', 'microwave', 'toilet', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'phone', 'food_cake', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'stereo', 'electric_shaver', 'homework', 'balanceball', 'picture', 'window', 'dining_room', 'powersocket', 'cup', 'photoframe', 'mirror', 'tray', 'pencil', 'shoes', 'conditioner', 'sink', 'creditcard'] Task:Shave response: { thoughts : Pick up razor. Push the button to turn it on. Move it in a linear motion against the beard growth. Make sure to get the bottom of your chin, your cheeks, and mustache area., actions : ['[WALK] <bathroom>', '[WALK] <electric_shaver>', '[FIND] <electric_shaver>', '[GRAB] <electric_shaver>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[SWITCHON] <electric_shaver>', '[SWITCHOFF] <electric_shaver>', '[PUTOBJBACK] <electric_shaver>'] } Scene_Objects:['sheets', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'window', 'mousepad', 'form', 'dining_room', 'wall', 'cutting_board', 'bed', 'clothes_gloves', 'check', 'television', 'oven_mitts', 'curtain', 'mouse', 'hair', 'napkin', 'vase', 'instrument_violin', 'laser_pointer'] Task:Gaze out window response: | { Look at the yard from the window } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'ceilingfan', 'drawing', 'food_egg', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'television', 'food_rice', 'curtain', 'kitchen_counter', 'hair', 'home_office', 'table', 'light', 'dishwasher', 'dirt'] Task:Change TV channel response: { thoughts : I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['juice', 'crayon', 'dog', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'ceiling', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'faucet', 'couch', 'food_peanut_butter', 'wall', 'keys', 'toilet_paper', 'television', 'curtain', 'towel_rack', 'mouse', 'shoes', 'vacuum_cleaner', 'table'] Task:Watch TV response: | { I sit on the couch and watch TV. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'microwave', 'trashcan', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'ceilinglamp', 'mat', 'faucet', 'shower', 'couch', 'towel', 'wall', 'bench', 'oven', 'photoframe', 'bed', 'mouse', 'kitchen_counter', 'dresser', 'pajamas', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : 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., actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[WIPE] <hands_both>'] } Scene_Objects:['microwave', 'chair', 'drawing', 'hanger', 'floor', 'phone', 'ceilinglamp', 'plate', 'iron', 'candle', 'pillow', 'wall', 'bench', 'powersocket', 'oven', 'food_food', 'video_game_controller', 'check', 'wooden_spoon', 'after_shave', 'doorjamb', 'shoes', 'dresser', 'cupboard', 'clothes_dress', 'door', 'conditioner', 'sink', 'table', 'light'] Task:Eat dinner response: | { Put food on the table, sit down, and eat the food. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', '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:['sheets', 'filing_cabinet', 'chair', 'freezer', 'detergent', 'trashcan', 'drawing', 'longboard', 'floor', 'phone', 'purse', 'computer', 'bookmark', 'brush', 'window', 'wall', 'child', 'powersocket', 'bed', 'novel', 'food_food', 'after_shave', 'curtain', 'doorjamb', 'towel_rack', 'shoes', 'laundry_detergent', 'door', 'napkin', 'light'] Task:Read book response: | { Read story to children } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'foundation', 'homework', 'closetdrawer', 'couch', 'pillow', 'broom', 'nightstand', 'wall', 'oven', 'light_bulb', 'television', 'curtain', 'dresser', 'bathroom_cabinet', 'table', 'dishwasher', 'creditcard'] Task:Watch TV response: { thoughts : I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch., actions : ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>'] } Scene_Objects:['fork', 'tea', 'chair', 'freezer', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'purse', 'face', 'mop_bucket', 'plate', 'faucet', 'balanceball', 'tvstand', 'mousepad', 'dustpan', 'wall', 'face_soap', 'photoframe', 'curtain', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher', 'teeth'] Task:Wash face response: | { Run warm water. Cleanse my face with soap. Rinse my face with water. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_salt', 'measuring_cup', 'microwave', 'freezer', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'phone', 'bedroom', 'desk', 'button', 'stereo', 'faucet', 'picture', 'pillow', 'dining_room', 'nightstand', 'wall', 'bed', 'check', 'toothbrush_holder', 'tray', 'dresser', 'sink', 'home_office', 'table', 'dishwasher'] Task:Listen to music response: { thoughts : Find the radio; switch on the radio and listen to music., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['juice', 'food_salt', 'beer', 'microwave', 'trashcan', 'food_carrot', 'milk', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'ceilinglamp', 'tvstand', 'balanceball', 'deck_of_cards', 'window', 'mousepad', 'couch', 'wall', 'bench', 'television', 'curtain', 'mouse', 'controller', 'clothes_scarf', 'napkin', 'table'] Task:Watch TV response: | { I sit on the couch and watch TV. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['crayon', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'cat', 'trashcan', 'orchid', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'shower', 'window', 'mousepad', 'microphone', 'dining_room', 'wall', 'pasta', 'bench', 'oven', 'newspaper', 'check', 'television', 'tray', 'curtain', 'towel_rack', 'mouse', 'home_office', 'bathroom_cabinet'] Task:Read newspaper response: { thoughts : Pull out dining room chair. Sit in dining room chair. Open newspaper to section you'd like to read. Read section. Keep reading all sections you'd like., actions : ['[WALK] <dining_room>', '[WALK] <newspaper>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <newspaper>'] } Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'blender', 'freezer', 'cpuscreen', 'hanger', 'longboard', 'ceiling', 'desk', 'bedroom', 'toaster', 'faucet', 'pasta', 'bench', 'love_seat', 'food_cheese', 'newspaper', 'video_game_controller', 'wine', 'curtain', 'doorjamb', 'shaving_cream', 'kettle', 'shoes', 'hairdryer', 'clothes_scarf', 'napkin', 'spoon', 'teeth'] Task:Read response: | { Reading a magazine } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'ceilinglamp', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bench', 'food_food', 'water', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'hands_both', 'shoe_rack'] Task:Wash hands response: { thoughts : I turn on faucet. I hold out my hands. I get my hands wet., actions : ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <hands_both>', '[POUR] <water> <hands_both>'] } Scene_Objects:['walllamp', 'bathroom', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'desk', 'thread', 'faucet', 'picture', 'mousepad', 'couch', 'wall', 'bed', 'photoframe', 'razor', 'doorjamb', 'console', 'mouse', 'cards', 'kitchen_counter', 'dresser', 'cupboard', 'hair', 'conditioner', 'sink', 'bag', 'vase', 'coffee'] Task:Wipe down sink response: | { Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'filing_cabinet', 'toilet', 'food_butter', 'orchid', 'bathroom_counter', 'bedroom', 'tea_bag', 'bookshelf', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'window', 'food_noodles', 'couch', 'clothes_hat', 'pillow', 'bench', 'powersocket', 'basket_for_clothes', 'television', 'oven_mitts', 'kitchen_counter', 'shoes', 'pajamas', 'door', 'light', 'soap', 'washing_machine'] Task:Wash clothes response: { thoughts : Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine, actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['sponge', 'chair', 'walllamp', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'remote_control', 'purse', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'oven', 'mouthwash', 'television', 'wine', 'curtain', 'after_shave', 'towel_rack', 'maindoor', 'clothes_scarf', 'hairdryer', 'table', 'light', 'dishwasher'] Task:Watch TV response: | { SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'thread', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'mousepad', 'couch', 'wall', 'photoframe', 'bed', 'toilet_paper', 'food_onion', 'towel_rack', 'mouse', 'kitchen_counter', 'cd', 'hairbrush', 'bathroom_cabinet', 'light'] Task:Go to toilet response: { thoughts : walk to bathroom , run to toilet, actions : ['[WALK] <bathroom>', '[RUN] <toilet>'] } Scene_Objects:['toilet', 'freezer', 'walllamp', 'cat', 'ceilingfan', 'drawing', 'cpuscreen', 'clothes_underwear', 'longboard', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'oil', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'ice', 'curtain', 'after_shave', 'door', 'table', 'dishwasher', 'vase'] Task:Watch TV response: | { Sit on couch and watch the tv } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'chair', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'oil', 'couch', 'wall', 'cup', 'food_food', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'console', 'hairbrush', 'cupboard', 'food_steak', 'maindoor', 'door', 'table'] Task:Watch TV response: { thoughts : Watch favorite shows, netflix, hulu, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['food_bread', 'blender', 'freezer', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'orchid', 'hanger', 'floor', 'bedroom', 'keyboard', 'computer', 'stereo', 'window', 'oil', 'couch', 'pillow', 'wall', 'cup', 'bed', 'food_donut', 'curtain', 'centerpiece', 'console', 'shoes', 'dresser', 'maindoor', 'home_office', 'light'] Task:Listen to music response: | { Turn on radio, put on favorite channel, 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:['pot', 'microwave', 'chair', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'toaster', 'mat', 'plate', 'shower', 'iron', 'dish_soap', 'closetdrawer', 'pillow', 'wall', 'oven', 'basket_for_clothes', 'coffe_maker', 'check', 'tray', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'dishwasher', 'board_game', 'dirt'] Task:Wash dishes with dishwasher response: { thoughts : I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet.., actions : ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>', '[GRAB] <plate>', '[WIPE] <plate>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[PUTOBJBACK] <dishrack>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'toilet', 'chair', 'jelly', 'cat', 'dough', 'cpuscreen', 'floor', 'desk', 'bedroom', 'keyboard', 'computer', 'laptop', 'mat', 'tvstand', 'mousepad', 'wall', 'nightstand', 'love_seat', 'cup', 'clothes_gloves', 'television', 'towel_rack', 'mouse', 'dresser', 'controller', 'bathroom_cabinet', 'electrical_outlet'] Task:Write book response: | { Writing a book } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'tvstand', 'faucet', 'stereo', 'window', 'couch', 'form', 'wall', 'powersocket', 'light_bulb', 'razor', 'vacuum_cleaner', 'controller', 'door', 'home_office', 'light', 'dishwasher', 'bathroom_cabinet', 'colander'] Task:Go to toilet response: { thoughts : I walk into the bath room and go to the toilet, actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[SIT] <toilet>'] } Scene_Objects:['sheets', 'chair', 'walllamp', 'detergent', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'bathroom_counter', 'phone', 'folder', 'man', 'keyboard', 'mop_bucket', 'tvstand', 'faucet', 'picture', 'plate', 'mousepad', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'check', 'food_onion', 'clothes_scarf', 'spoon', 'light', 'dishwasher'] Task:Greet guests response: | { When someone knocks I n the door walk through the hallway and greet them. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'jelly', 'chair', 'phone', 'ceiling', 'desk', 'bedroom', 'table_cloth', 'bookmark', 'stovefan', 'mat', 'tvstand', 'stereo', 'shoe-shine_kit', 'faucet', 'toaster', 'mousepad', 'powersocket', 'cutting_board', 'shelf', 'food_cheese', 'television', 'wooden_spoon', 'after_shave', 'food_onion', 'doorjamb', 'shoes', 'dishrack', 'vase', 'electrical_outlet'] Task:Turn on radio response: { thoughts : Go to the radio. Switch on the power button. Tune the station. Set the volume. Listen to the music., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[FIND] <electrical_outlet>', '[TURNTO] <electrical_outlet>', '[PLUGIN] <stereo>', '[SWITCHON] <electrical_outlet>', '[SWITCHON] <stereo>'] } Scene_Objects:['bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'shampoo', 'bookshelf', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'pillow', 'wall', 'pasta', 'tape', 'box', 'coffee_table', 'keys', 'food_food', 'razor', 'television', 'toothbrush_holder', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'table', 'tooth_paste'] Task:Watch TV response: | { I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'glue', 'microwave', 'bathroom', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'purse', 'food_bacon', 'ceilinglamp', 'plate', 'laptop', 'deck_of_cards', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'spoon', 'home_office', 'table', 'teeth'] Task:Relax on sofa response: { thoughts : I walk to the sofa, and lie down on the sofa., actions : ['[WALK] <couch>', '[LIE] <couch>'] } Scene_Objects:['microwave', 'ceilingfan', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'face', 'mail', 'table_cloth', 'faucet', 'food_jam', 'towel', 'dining_room', 'wall', 'face_soap', 'toy', 'photoframe', 'keys', 'water', 'rag', 'pencil', 'shoes', 'dresser', 'sink', 'bathroom_cabinet', 'home_office', 'colander', 'hands_both'] Task:Wash face response: | { Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand 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', 'food_bread', 'juice', 'microwave', 'chair', 'freezer', 'detergent', 'drawing', 'orchid', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'shower', 'mat', 'ceilinglamp', 'couch', 'pillow', 'wall', 'pasta', 'oven', 'cup', 'newspaper', 'coffe_maker', 'television', 'ice', 'wine', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'cupboard', 'table', 'dishwasher', 'creditcard'] Task:Grab some juice response: { thoughts : I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass., actions : ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <juice>', '[GRAB] <juice>', '[POUR] <juice> <cup>', '[PUTOBJBACK] <juice>', '[CLOSE] <freezer>', '[FIND] <table>', '[PUTBACK] <cup> <table>'] } Scene_Objects:['filing_cabinet', 'food_pizza', 'tablelamp', 'food_ice_cream', 'crayon', 'shampoo', 'keyboard', 'mail', 'bookmark', 'stovefan', 'faucet', 'pillow', 'dining_room', 'broom', 'wall', 'love_seat', 'photoframe', 'novel', 'food_food', 'wine', 'tray', 'after_shave', 'shaving_cream', 'kettle', 'headset', 'pajamas', 'laundry_detergent', 'door', 'bathroom_cabinet', 'shoe_rack'] Task:Read book response: | { Obtain a book from the book shelf. Sit in the easy chair. Read the book. Mark the stopping point with a bookmark. Put the book back on the book shelf. } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.