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:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'door', 'table', 'light', 'dishwasher'] Task:Change TV channel response: { thoughts : I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>'] } Scene_Objects:['food_bread', 'measuring_cup', 'chair', 'trashcan', 'toothbrush', 'cpuscreen', 'hanger', 'ceiling', 'character', 'keyboard', 'alcohol', 'mat', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'oven', 'bench', 'bed', 'photoframe', 'food_food', 'coffe_maker', 'toothbrush_holder', 'tray', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'home_office', 'tooth_paste'] Task:Wash teeth response: | { WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR TEETH } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'crayon', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'desk', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_orange', 'pillow', 'form', 'dining_room', 'wall', 'bench', 'coffe_maker', 'television', 'rag', 'pencil', 'comb', 'table', 'tooth_paste', 'clothes_shirt', 'scrabble', 'creditcard'] Task:Relax on sofa response: { thoughts : I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>'] } Scene_Objects:['water_glass', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'cupboard', 'sink', 'bathroom_cabinet', 'table'] Task:Relax on sofa response: | { Drink a glass of water 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:['toilet', 'chair', 'walllamp', 'milk', 'drawing', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'check', 'television', 'curtain', 'mouse', 'door', 'home_office', 'table', 'bathroom_cabinet', 'light'] Task:Do homework response: { thoughts : Sit on the couch in the Living room and pick u some papers, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <check>', '[GRAB] <check>', '[DROP] <check>'] } Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'dresser', 'food_steak', 'sink', 'bathroom_cabinet', 'table'] Task:Browse internet response: | { I sit at my computer desk and open the browser. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'detergent', 'food_carrot', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'toaster', 'balanceball', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'tray', 'doorjamb', 'cards', 'mouse', 'shaving_cream', 'shoes', 'dresser', 'cupboard', 'door', 'napkin', 'home_office', 'light', 'vase'] Task:Turn on light response: { thoughts : switching on light in an area, actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'bathroom', 'toothbrush', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'computer', 'button', 'toaster', 'mat', 'stereo', 'foundation', 'window', 'couch', 'bench', 'oven', 'cup', 'check', 'television', 'tray', 'dresser', 'home_office', 'light', 'bathroom_cabinet'] Task:Listen to music response: | { Walk into living room, look for radio, grab on button } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'food_ice_cream', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'bookshelf', 'computer', 'faucet', 'balanceball', 'window', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'nightstand', 'bench', 'powersocket', 'basket_for_clothes', 'novel', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'maindoor', 'sink', 'hairdryer'] Task:Pick up phone response: { thoughts : Enter the Home office, then walk to the phone, pickup the phone., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>'] } Scene_Objects:['tablelamp', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'bench', 'bed', 'coffe_maker', 'television', 'food_donut', 'doorjamb', 'mouse', 'door', 'table', 'shoe_rack'] Task:Work response: | { Walk to living-room. Look at the desk where Computer stays. Sit in chair. Switch on computer. Work on computer. Switch off computer. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['walllamp', 'ceilingfan', 'drawing', 'needle', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'homework', 'clothes_socks', 'couch', 'pillow', 'wall', 'powersocket', 'food_cheese', 'bed', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table', 'laser_pointer'] Task:Watch TV response: { thoughts : Walk into the living room. Sit down on the sofa. Pick up the remote control. Turn on the television with the remote control. Put down the remote control. Watch the television., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'bed', 'television', 'doorjamb', 'centerpiece', 'mouse', 'door', 'bathtub', 'sink', 'napkin', 'table', 'light'] Task:Work response: | { Sit down on chair in front of computer, turn on computer, find mouse. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'crayon', 'detergent', 'trashcan', 'orchid', 'wallshelf', 'bathroom_counter', 'ceiling', 'keyboard', 'stovefan', 'tvstand', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'basket_for_clothes', 'television', 'centerpiece', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'clothes_dress', 'laundry_detergent', 'door', 'sink', 'table', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: { thoughts : Walk to the kitchen. Find the washing machine. Open the washing machine. Find the basket for clothes. Find the clothes_dress. Grab the clothes_dress. Put the clothes_dress into the washing machine. Find the clothes_shirt. Grab the clothes_shirt. Put the clothes_shirt into the washing machine. Close the washing machine. Switch on the washing machine., actions : ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>'] } Scene_Objects:['pot', 'tablelamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'keyboard', 'envelope', 'stovefan', 'toaster', 'faucet', 'shower', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'bench', 'food_vegetable', 'bed', 'coffe_maker', 'check', 'water', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard'] Task:Cook some food response: | { walk to kicthen , find stove , find cooking pot , find vegetables , find water ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'filing_cabinet', 'food_bread', 'toilet', 'ground_coffee', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'plate', 'iron', 'mousepad', 'wall', 'oven', 'photoframe', 'light_bulb', 'coffe_maker', 'centerpiece', 'mouse', 'dresser', 'maindoor'] Task:Go to toilet response: { thoughts : I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[TURNTO] <toilet>', '[LOOKAT] <toilet>', '[WALK] <toilet>', '[TURNTO] <toilet>'] } Scene_Objects:['microwave', 'chair', 'freezer', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'food_cake', 'envelope', 'computer', 'ceilinglamp', 'window', 'mousepad', 'clothes_socks', 'closetdrawer', 'wall', 'toy', 'cup', 'coffe_maker', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table'] Task:Browse internet response: | { I turn on computer. I use keyboard to type. I open browser. I search. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'freezer', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'toaster', 'window', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'wall_clock', 'television', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'clothes_shirt'] Task:Organize closet response: { thoughts : Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear., actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[CLOSE] <dresser>', '[WALK] <basket_for_clothes>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>'] } Scene_Objects:['filing_cabinet', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'plate', 'couch', 'pillow', 'wall', 'newspaper', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'bathtub', 'light', 'table'] Task:Pet cat response: | { My cat looks like it wants attention, so I will go pet it on the couch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'tablelamp', 'measuring_cup', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'character', 'desk', 'bedroom', 'table_cloth', 'mat', 'shower', 'stereo', 'microphone', 'clothes_hat', 'pillow', 'nightstand', 'wall_clock', 'oven', 'keys', 'light_bulb', 'check', 'razor', 'tray', 'doorjamb', 'dresser', 'clothes_dress', 'bag', 'dishwasher'] Task:Listen to music response: { thoughts : I find a radio. I turn on the radio. I listen to music., actions : ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>'] } Scene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'detergent', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'wall_clock', 'television', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'table', 'light'] Task:Pet cat response: | { I see my cat on the couch so I walk over, sit down 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:['spectacles', 'tablelamp', 'toilet', 'chair', 'bathroom', 'orchid', 'knifeblock', 'floor', 'phone', 'desk', 'keyboard', 'food_cake', 'foundation', 'floor_lamp', 'pillow', 'nightstand', 'powersocket', 'box', 'basket_for_clothes', 'razor', 'tray', 'doorjamb', 'cupboard', 'bathtub', 'spoon', 'home_office', 'table', 'bathroom_cabinet', 'light', 'dishwasher'] Task:Turn on light response: { thoughts : walk to living room, find lamp, switch on., actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>'] } Scene_Objects:['tablelamp', 'microwave', 'freezer', 'band-aids', 'cat', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'folder', 'desk', 'tea_bag', 'keyboard', 'stovefan', 'toaster', 'shower', 'faucet', 'couch', 'bench', 'photoframe', 'coffe_maker', 'television', 'tray', 'vacuum_cleaner', 'hairbrush', 'dresser', 'door', 'bathtub', 'light'] Task:Pet cat response: | { Find the cat; pet the cat by touching 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', 'microwave', 'toilet', 'chair', 'band-aids', 'cat', 'food_carrot', 'knife', 'foundation', 'electric_shaver', 'mousepad', 'clothes_socks', 'pillow', 'dining_room', 'nightstand', 'oven', 'toy', 'check', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'chessboard', 'cupboard', 'conditioner', 'door', 'food_steak', 'clothes_skirt', 'duster'] Task:Dust response: { thoughts : Get a broom or duster with long handle. Dust blades of ceiling fan., actions : ['[WALK] <bedroom>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[PUTOBJBACK] <duster>'] } Scene_Objects:['toilet', 'walllamp', 'trashcan', 'drawing', 'floor', 'phone', 'computer', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'shower', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'novel', 'coffe_maker', 'television', 'tray', 'curtain', 'cupboard', 'controller', 'door', 'bathtub', 'table', 'light'] Task:Read book response: | { Walk to the couch in the living room, sit on ti and read the book } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'microwave', 'detergent', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'mail', 'toaster', 'stovefan', 'faucet', 'closetdrawer', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'coin', 'drinking_glass', 'water', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'sink', 'dishwasher', 'coffee'] Task:Drink response: { thoughts : I walk to the kitchen and approach the sink. I take a drinking glass and set it under the faucet. I turn the faucet until the water fills the glass, then turn it back. Finally I lift the glass out of the sink and drink the water., actions : ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[SWITCHOFF] <faucet>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'desk', 'envelope', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'oven_mitts', 'curtain', 'controller', 'home_office', 'table'] Task:Relax on sofa response: | { I walk into the living room. I cross the room to the couch. I sit down and relax. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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:['filing_cabinet', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'knife', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'mat', 'shower', 'window', 'food_kiwi', 'wall', 'bench', 'newspaper', 'food_food', 'coffe_maker', 'food_onion', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'home_office'] Task:Put groceries in Fridge response: | { walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'freezer', 'walllamp', 'food_butter', 'dough', 'food_carrot', 'drawing', 'food_egg', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'faucet', 'oil', 'wall', 'pasta', 'powersocket', 'oven', 'wall_clock', 'cutting_board', 'food_food', 'coffe_maker', 'oven_mitts', 'wooden_spoon', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'maindoor', 'sink', 'bathroom_cabinet', 'light'] Task:Cook some food response: { thoughts : I walk into the kitchen and walk over the cabinent. I pull out a pan and walk to the stove. I put the pan on the stove and walk over to the fridge. I pull out out meat from the fridge and walk back over the stove. Then I put the meat in the pan., actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[WALK] <oven>', '[PUTBACK] <pot> <oven>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[WALK] <oven>', '[PUTBACK] <food_chicken> <oven>'] } 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: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_salt', 'microwave', 'toilet', 'walllamp', 'cat', 'food_carrot', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'mop_bucket', 'stovefan', 'mat', 'stereo', 'couch', 'wall', 'powersocket', 'bed', 'novel', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'controller', 'door', 'food_steak', 'spoon', 'light'] Task:Turn on light response: { thoughts : I walk to wall. I put my hand on the switch. I push the button. I turn on the lights., actions : ['[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'floor', 'ceiling', 'food_chicken', 'stovefan', 'mat', 'toaster', 'shower', 'faucet', 'window', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink'] Task:Cook some food response: | { I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'scissors', 'microwave', 'bathroom', 'nail_polish', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'floor', 'bookshelf', 'mat', 'faucet', 'window', 'electric_shaver', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'newspaper', 'keys', 'television', 'curtain', 'doorjamb', 'diary', 'sink', 'spoon', 'table', 'soap'] Task:Relax on sofa response: { thoughts : Walk into the living room. Walk to the sofa and sit on it. Put your feet up on the sofa and lay down., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>'] } Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'drawing', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'food_food', 'coffe_maker', 'television', 'tray', 'curtain', 'mouse', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'sink', 'table'] Task:Relax on sofa response: | { I walk to the living room. I sit in the sofa and I relax. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['scissors', 'toilet', 'chair', 'walllamp', 'ceilingfan', 'bathroom_counter', 'floor', 'phone', 'character', 'mail', 'computer', 'toaster', 'foundation', 'clothes_socks', 'food_peanut_butter', 'dining_room', 'wall', 'oven', 'powersocket', 'tape', 'cup', 'coffe_maker', 'video_game_controller', 'television', 'tray', 'curtain', 'cd', 'maindoor', 'bathroom_cabinet', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['microwave', 'toilet', 'jelly', 'dog', 'walllamp', 'bathroom', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'toaster', 'ceilinglamp', 'stereo', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'curtain', 'mouse', 'cupboard', 'bathtub', 'home_office', 'light', 'bathroom_cabinet'] Task:Listen to music response: | { I walk into the bedroom. I walk to stereo. I turn on stereo. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_ice_cream', 'chair', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'mousepad', 'couch', 'towel', 'wall', 'bed', 'photoframe', 'curtain', 'after_shave', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both', 'shoe_rack'] Task:Wash hands response: { thoughts : Wash hands with soap and hot water, actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['filing_cabinet', 'shoe_rack', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'shower', 'mat', 'window', 'dish_soap', 'couch', 'pillow', 'wall', 'basket_for_clothes', 'bed', 'towel_rack', 'light', 'dishwasher', 'creditcard'] Task:Wash dishes with dishwasher response: | { Wash a plate using the dishwasher in the kitchen. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'crayon', 'cat', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'food_cake', 'computer', 'brush', 'electric_shaver', 'mousepad', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'toy', 'food_food', 'towel_rack', 'mouse', 'dresser', 'pajamas', 'sink', 'napkin', 'light', 'colander', 'tooth_paste'] Task:Pick up toys response: { thoughts : Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes., actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTBACK] <toy> <dresser>', '[CLOSE] <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>'] } 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: | { Walk to the entrance hall. Find the telephone. Grab the telephone. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'food_butter', 'knife', 'wallshelf', 'bathroom_counter', 'phone', 'character', 'bedroom', 'keyboard', 'computer', 'faucet', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'oven', 'shelf', 'cup', 'bed', 'food_rice', 'tray', 'mouse', 'headset', 'comb', 'dresser', 'conditioner', 'home_office', 'table'] Task:Brush teeth response: { thoughts : go to the bathroom and brush your teeth, actions : ['[WALK] <bathroom>', '[WALK] <toothbrush>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>'] } Scene_Objects:['food_salt', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'television', 'ice', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'headset', 'cupboard', 'sink', 'table'] Task:Relax on sofa response: | { I walk to the sofa, and lie down on the sofa. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'walllamp', 'detergent', 'toothbrush', 'drawing', 'cpuscreen', 'food_egg', 'phone', 'character', 'computer', 'piano_bench', 'shoe-shine_kit', 'faucet', 'food_noodles', 'mousepad', 'clothes_hat', 'towel', 'broom', 'cutting_board', 'shelf', 'keys', 'novel', 'food_food', 'check', 'wooden_spoon', 'towel_rack', 'sink', 'table', 'light', 'coffee'] Task:Change TV channel response: { thoughts : I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>'] } Scene_Objects:['dry_pasta', 'filing_cabinet', 'freezer', 'walllamp', 'cpuscreen', 'wallshelf', 'ceiling', 'computer', 'shower', 'window', 'mousepad', 'couch', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'bench', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'razor', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'home_office', 'light', 'washing_machine'] Task:Wash clothes response: | { \ I walk to entrance hall\ \ I walk to bedroom\ \ I find basket of clothes\ \ I lift basket of clothes\ \ I walk to kitchen\ \ I find washing machine\ \ I open washing machine \ \ I put laundry in washing machine\ \ I add laundry detergent\ \ \ I close washing machine lid\ \ I switch washing machine on\ } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'bathroom', 'ceilingfan', 'clothes_underwear', 'bathroom_counter', 'character', 'thread', 'piano_bench', 'toaster', 'deck_of_cards', 'homework', 'couch', 'dustpan', 'powersocket', 'newspaper', 'clothes_gloves', 'novel', 'coffe_maker', 'doorjamb', 'chessboard', 'cd', 'napkin', 'home_office', 'instrument_guitar', 'clothes_skirt', 'light'] Task:Close door response: { thoughts : Push the door shut until it latches., actions : ['[RUN] <home_office>'] } Scene_Objects:['tablelamp', 'toilet', 'jelly', 'freezer', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'computer', 'food_bacon', 'plate', 'faucet', 'shower', 'window', 'dish_soap', 'mousepad', 'couch', 'wall', 'wall_clock', 'powersocket', 'bench', 'shoes', 'hairbrush', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office'] Task:Wash dishes by hand response: | { Make some dish water, grab a dish rag, put dishes in dish water and wash. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'mop', 'bathroom', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'desk', 'food_cake', 'window', 'electric_shaver', 'microphone', 'food_jam', 'dining_room', 'wall', 'photoframe', 'food_food', 'television', 'curtain', 'mouse', 'kitchen_counter', 'cd', 'chessboard', 'dresser', 'hairbrush', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher', 'instrument_violin'] Task:Put on coat response: { thoughts : I remove my scarf from a coat peg in the entrance hall. I wrap the scarf around my neck, actions : ['[WALK] <home_office>', '[WALK] <hanger>', '[TURNTO] <hanger>', '[LOOKAT] <hanger>', '[FIND] <clothes_scarf>', '[GRAB] <clothes_scarf>', '[PUTON] <clothes_scarf>'] } Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'cat', 'trashcan', 'milk', 'hanger', 'bathroom_counter', 'desk', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'tray', 'curtain', 'chessboard', 'shoes', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'table'] Task:Pet cat response: | { Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'microwave', 'toilet', 'toothbrush', 'bills', 'orchid', 'character', 'bedroom', 'stamp', 'stovefan', 'laptop', 'ceilinglamp', 'shower', 'mat', 'faucet', 'towel', 'pillow', 'dining_room', 'oven', 'coffe_maker', 'television', 'toothbrush_holder', 'comb', 'cupboard', 'door', 'sink', 'table', 'soap', 'tooth_paste', 'teeth'] Task:Brush teeth response: { thoughts : Walk to bathroom. Find toothbrush. Find toothpaste. Put toothpaste on toothbrush. Brush teeth., actions : ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>', '[FIND] <teeth>', '[SCRUB] <teeth>'] } Scene_Objects:['water_glass', 'food_salt', 'microwave', 'freezer', 'orchid', 'cpuscreen', 'ceiling', 'character', 'bedroom', 'desk', 'food_bacon', 'bookmark', 'toaster', 'stovefan', 'faucet', 'shower', 'mousepad', 'wall', 'wall_clock', 'oven', 'bench', 'coffe_maker', 'television', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'light'] Task:Drink response: | { I go to the kitchen, take a glass from the cupboard, fill with water and drink } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tea', 'walllamp', 'detergent', 'cat', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'remote_control', 'mail', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'couch', 'wall', 'bench', 'clothes_gloves', 'coffe_maker', 'television', 'curtain', 'coffee_pot', 'home_office', 'table', 'coffee'] Task:Change TV channel response: { thoughts : walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed, actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[GRAB] <button>'] } Scene_Objects:['tablelamp', 'toilet', 'bathroom', 'cat', 'dough', 'knife', 'bathroom_counter', 'floor', 'keyboard', 'computer', 'brush', 'laptop', 'plate', 'faucet', 'deck_of_cards', 'window', 'closetdrawer', 'couch', 'dining_room', 'nightstand', 'wall', 'oven', 'bench', 'television', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathtub'] Task:Pet cat response: | { Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'blender', 'microwave', 'toilet', 'detergent', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'keyboard', 'computer', 'brush', 'mat', 'laptop', 'faucet', 'ceilinglamp', 'window', 'dustpan', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'towel_rack', 'mouse', 'kitchen_counter', 'pajamas', 'dishwasher'] Task:Go to sleep response: { thoughts : go to bedroom, put pajamas on, lie in bed, sleep, actions : ['[WALK] <bedroom>', '[WALK] <pajamas>', '[FIND] <pajamas>', '[GRAB] <pajamas>', '[PUTON] <pajamas>', '[FIND] <bed>', '[LIE] <bed>'] } Scene_Objects:['chair', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'window', 'mousepad', 'wall', 'nightstand', 'powersocket', 'bench', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'cd', 'sink', 'bathtub', 'table', 'dirt'] Task:Write an email response: | { I go to my office and sit at my desk. Turn on the computer and type my email at the keyboard. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'knife', 'knifeblock', 'orchid', 'drawing', 'floor', 'phone', 'character', 'bedroom', 'remote_control', 'computer', 'button', 'mat', 'tvstand', 'faucet', 'shower', 'oil', 'dining_room', 'powersocket', 'newspaper', 'ice', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'door', 'home_office', 'table'] Task:Change TV channel response: { thoughts : I pick up the remote. I press button on remote., actions : ['[WALK] <bedroom>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['tablelamp', 'beer', 'toilet', 'freezer', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'ceiling', 'phone', 'character', 'keyboard', 'toaster', 'mat', 'floor_lamp', 'oil', 'pillow', 'dining_room', 'nightstand', 'wall_clock', 'bench', 'novel', 'television', 'curtain', 'doorjamb', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table'] Task:Read book response: | { Turn a light on and read a book in the bedroom. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'bathroom', 'trashcan', 'food_butter', 'drawing', 'floor', 'ceiling', 'phone', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'sink', 'spoon', 'home_office', 'light'] Task:Turn on light response: { thoughts : walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light., actions : ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>'] } Scene_Objects:['sheets', 'filing_cabinet', 'crayon', 'toilet', 'bathroom', 'nail_polish', 'trashcan', 'food_carrot', 'hanger', 'floor', 'computer', 'toaster', 'window', 'food_jam', 'nightstand', 'oven', 'bench', 'tape', 'photoframe', 'food_food', 'coffe_maker', 'television', 'toilet_paper', 'doorjamb', 'dresser', 'pajamas', 'cupboard', 'door', 'sink', 'home_office'] Task:Listen to music response: | { I walk into the living room. I find the stereo and turn it on, and I listen to the music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'microwave', 'chair', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'purse', 'computer', 'toaster', 'mat', 'tvstand', 'clothes_socks', 'food_peanut_butter', 'microphone', 'food_jam', 'pillow', 'wall', 'powersocket', 'after_shave', 'doorjamb', 'cd', 'pajamas', 'laundry_detergent', 'door', 'light', 'tooth_paste'] Task:Turn on light response: { thoughts : Coming home turning on lights., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'trashcan', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'oil', 'couch', 'wall', 'wall_clock', 'powersocket', 'oven', 'food_food', 'television', 'doorjamb', 'mouse', 'table'] Task:Work response: | { turn computer on, open application to work with } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'pot', 'food_bread', 'scissors', 'microwave', 'freezer', 'milk', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'food_bacon', 'ceilinglamp', 'shower', 'faucet', 'bowl', 'food_kiwi', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'diary', 'dishrack', 'controller', 'conditioner', 'home_office'] Task:Get glass of milk response: { thoughts : Get an empty glass. Take milk from refrigerator and open it. Pour milk into glass., actions : ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>'] } Scene_Objects:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'piano_bench', 'stovefan', 'mat', 'tvstand', 'shower', 'stereo', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'bench', 'photoframe', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'sink', 'table'] Task:Put groceries in Fridge response: | { Walk to kitchen. Grab groceries and walk to the fridge. Open fridge and put groceries in the fridge. Close the fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'laptop', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dishrack', 'door', 'light', 'shoe_rack'] Task:Browse internet response: { thoughts : Walk to home office, walk to desk, sit in chair, turn on laptop, grab mouse, open a web page to look at it, move mouse, keep looking at laptop screen., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[TOUCH] <mouse>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>'] } Scene_Objects:['tablelamp', 'walllamp', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'bookshelf', 'mail', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'oven', 'toy', 'mouthwash', 'television', 'wine', 'tray', 'curtain', 'cd', 'dresser', 'bathtub', 'sink', 'table', 'light'] Task:Relax on sofa response: | { go to the living room,find the sofa,sat down in the sofa,take some relaxation. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'photoframe', 'novel', 'television', 'mouse', 'kitchen_counter', 'door', 'sink', 'clothes_skirt', 'clothes_shirt'] Task:Read book response: { thoughts : Go to home office, find the book. Sit in the chair and read the book., actions : ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>'] } Scene_Objects:['microwave', 'toilet', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'shower', 'window', 'tvstand', 'pillow', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coffe_maker', 'water', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'light', 'table'] Task:Drink response: | { Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['scissors', '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:['tablelamp', 'food_salt', 'orchid', 'hanger', 'floor', 'phone', 'ceiling', 'character', 'toaster', 'mat', 'plate', 'faucet', 'shower', 'window', 'closetdrawer', 'powersocket', 'oven', 'cup', 'curtain', 'doorjamb', 'mouse', 'comb', 'cupboard', 'clothes_dress', 'door', 'bathtub', 'home_office', 'table', 'dishwasher', 'dirt'] Task:Wash dishes with dishwasher response: | { Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['spectacles', 'pot', 'filing_cabinet', 'beer', 'crayon', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'bookshelf', 'mat', 'iron', 'electric_shaver', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'toy', 'cup', 'light_bulb', 'novel', 'food_food', 'check', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', '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:['pot', 'filing_cabinet', 'freezer', 'cpuscreen', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'desk', 'bookshelf', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'window', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'broom', 'nightstand', 'oven', 'bench', 'coffe_maker', 'check', 'towel_rack', 'mouse', 'cupboard', 'light', 'table'] Task:Listen to music response: | { I find a radio. I turn on the radio. I listen to music. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['water_glass', 'food_bread', 'food_ice_cream', 'crayon', 'microwave', 'chair', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'tvstand', 'window', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'water', 'tray', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'light', 'instrument_violin'] Task:Drink response: { thoughts : walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass, actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[FIND] <water>', '[GRAB] <water>', '[WALK] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>'] } Scene_Objects:['tablelamp', 'beer', 'freezer', 'bathroom', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'computer', 'ceilinglamp', 'mat', 'faucet', 'couch', 'clothes_pants', 'wall', 'wall_clock', 'bench', 'powersocket', 'nightstand', 'photoframe', 'novel', 'tray', 'curtain', 'doorjamb', 'sink', 'napkin', 'bathroom_cabinet', 'hands_both'] Task:Wash hands response: | { Going to the sink and scrubbing hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_salt', 'freezer', 'orchid', 'wallshelf', 'clothes_underwear', 'cpuscreen', 'phone', 'character', 'bedroom', 'keyboard', 'toaster', 'mat', 'plate', 'picture', 'foundation', 'dish_soap', 'clothes_socks', 'pillow', 'powersocket', 'cutting_board', 'basket_for_clothes', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'sink', 'spoon', 'home_office'] Task:Wash dishes by hand response: { thoughts : Pick up dish. Put in soapy water. Wash dish., actions : ['[WALK] <dining_room>', '[WALK] <dish_soap>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <dish_soap> <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WIPE] <plate>'] } Scene_Objects:['filing_cabinet', 'food_salt', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'wallshelf', 'phone', 'desk', 'toaster', 'stovefan', 'mat', 'shower', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'powersocket', 'bench', 'bed', 'photoframe', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'bathroom_cabinet', 'light'] Task:Pet cat response: | { Walk into the living room. Walk up to the cat. Pet the cat with your 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:['chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'floor', 'character', 'keyboard', 'bookshelf', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'wall_clock', 'toilet_paper', 'mouthwash', 'television', 'food_food', 'coffe_maker', 'curtain', 'doorjamb', 'bathroom_cabinet', 'table'] 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:['water_glass', 'microwave', 'freezer', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'button', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'couch', 'wall', 'wall_clock', 'oven', 'keys', 'coffe_maker', 'water', 'tray', 'curtain', 'coffee_pot', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'tooth_paste'] Task:Drink response: | { I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and 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:['spectacles', 'chair', 'walllamp', 'orchid', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'desk', 'bedroom', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'iron', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'bed', 'television', 'doorjamb', 'mouse', 'door', 'home_office', 'light', 'table'] Task:Write an email response: { thoughts : enter office, find computer, turn it on,, actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TOUCH] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['sheets', 'blender', 'microwave', 'toilet', 'freezer', 'detergent', 'cat', 'food_carrot', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'ceilinglamp', 'faucet', 'oil', 'dining_room', 'nightstand', 'wall_clock', 'oven', 'bed', 'television', 'coffee_filter', 'tray', 'mouse', 'dresser', 'hair', 'light', 'table'] Task:Listen to music response: | { I walk into my room and turn the radio on so that I can 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', 'detergent', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'laptop', 'shower', 'window', 'oil', 'clothes_socks', 'couch', 'food_orange', 'pillow', 'wall', 'novel', 'coffe_maker', 'television', 'food_rice', 'rag', 'doorjamb', 'cupboard', 'door', 'sink', 'napkin', 'table', 'light'] Task:Relax response: { thoughts : Lie down on the couch., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>'] } 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: | { I go to the book case, I select a book, I go back and sit down, then I read. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sponge', 'chair', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'knife', 'hanger', 'floor', 'phone', 'ceiling', 'keyboard', 'computer', 'brush', 'deck_of_cards', 'food_jam', 'bowl', 'dining_room', 'wall', 'bench', 'razor', 'doorjamb', 'mouse', 'dishrack', 'dresser', 'cupboard', 'door', 'sink', 'table', 'light'] Task:Pick up phone response: { thoughts : Pick up phone, actions : ['[WALK] <table>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>'] } 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: | { I walk to the living room and pick up a book from the coffee table. I find my favorite chair. I sit in the armchair and open the book. I read. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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:['filing_cabinet', 'toilet', 'chair', 'freezer', 'walllamp', 'ceiling', 'bedroom', 'keyboard', 'toaster', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_pants', 'food_orange', 'nightstand', 'bench', 'photoframe', 'bed', 'food_food', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'table', 'washing_machine'] Task:Wash clothes response: | { Walk into laundry room. Open washing machine door. Put dirty clothes into washing machine. Measure laundry detergent and place into washing machine. Turn dial to appropriate wash setting. Power on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'freezer', 'knifeblock', 'drawing', 'wallshelf', 'ceiling', 'phone', 'desk', 'keyboard', 'face', 'toaster', 'laptop', 'tvstand', 'shower', 'stereo', 'homework', 'oil', 'towel', 'oven', 'basket_for_clothes', 'tray', 'towel_rack', 'hair', 'cupboard', 'door', 'bathtub', 'clothes_shirt'] Task:Rain welcome response: { thoughts : The robot would greet me and then hand me a towel. It would make an appropriate quip about the weather while I dried off. It would receive the wet towel when I was done., actions : ['[WALK] <bedroom>', '[WALK] <towel>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <hair>', '[WIPE] <hair>', '[PUTOBJBACK] <towel>'] } Scene_Objects:['microwave', 'toilet', 'trashcan', 'toothbrush', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'alcohol', 'stovefan', 'faucet', 'shower', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'bench', 'photoframe', 'towel_rack', 'mouse', 'cupboard', 'conditioner', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'home_office', 'tooth_paste'] Task:Wash teeth response: | { Upon entering the restroom, walk to the sink. Take a toothbrush and apply enough toothpaste so that 1/4 of the brush is covered (this is the appropriate amount). Proceed to \ brush\ your teeth using an up and down motion with the brush in your mouth. Brush for 2 minutes covering all areas of the teeth. Rinse with water and clean toothbrush with water too. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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_bread', 'toilet', 'chair', 'freezer', 'bathroom', 'food_carrot', 'hanger', 'keyboard', 'envelope', 'mail', 'tvstand', 'clothes_pants', 'bowl', 'dining_room', 'oven', 'powersocket', 'bed', 'clothes_gloves', 'check', 'wine', 'curtain', 'food_onion', 'kettle', 'dresser', 'vase', 'home_office', 'light', 'clothes_skirt', 'dishwasher'] Task:Pick up phone response: { thoughts : I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone., actions : ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>', '[SWITCHON] <phone>'] } Scene_Objects:['pot', 'filing_cabinet', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'laptop', 'shower', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'oven', 'cutting_board', 'coffe_maker', 'television', 'tray', 'doorjamb', 'mouse', 'hair', 'door', 'sink', 'home_office', 'table'] Task:Write an email response: | { I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer off. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'detergent', 'bills', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'mat', 'laptop', 'shower', 'faucet', 'ceilinglamp', 'mousepad', 'microphone', 'form', 'pillow', 'broom', 'wall', 'newspaper', 'after_shave', 'doorjamb', 'cd', 'comb', 'controller', 'door', 'bathroom_cabinet', 'light', 'table', 'creditcard'] Task:Turn on light response: { thoughts : I walk to wall. I put my hand on the switch. I push the button. I turn on the lights., actions : ['[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'bedroom', 'computer', 'toaster', 'mat', 'oil', 'couch', 'dining_room', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'food_rice', 'tray', 'curtain', 'mouse', 'dresser', 'bathtub', 'home_office', 'table', 'bathroom_cabinet', 'coffee', 'shoe_rack'] Task:Browse internet response: | { I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'chair', 'trashcan', 'food_carrot', 'drawing', 'knifeblock', 'hanger', 'floor', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'window', 'homework', 'couch', 'dustpan', 'food_orange', 'dining_room', 'wall', 'nightstand', 'photoframe', 'clothes_gloves', 'coffe_maker', 'check', 'television', 'mouse', 'pencil', 'table', 'laser_pointer'] 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:['blender', 'chair', 'nail_polish', 'knife', 'cpuscreen', 'bathroom_counter', 'table_cloth', 'stovefan', 'tvstand', 'stereo', 'faucet', 'window', 'mousepad', 'dining_room', 'broom', 'nightstand', 'wall_clock', 'wall', 'oven', 'bed', 'newspaper', 'food_food', 'video_game_controller', 'wine', 'after_shave', 'curtain', 'towel_rack', 'bathtub', 'light', 'table'] Task:Listen to music response: | { Find radio, turn it on } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'jelly', 'bathroom', 'detergent', 'dough', 'orchid', 'floor', 'bedroom', 'mat', 'dish_soap', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'ice', 'tray', 'kitchen_counter', 'headset', 'dishrack', 'dresser', 'cupboard', 'door', 'home_office', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I go to the dishwasher and put dish soap. I close the dishwasher and turn it on., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'dustpan', 'pillow', 'wall', 'wall_clock', 'powersocket', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'table'] Task:Browse internet response: | { Browsing the internet for information. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'chair', 'walllamp', '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: { thoughts : When someone knocks I n the door walk through the hallway and greet them., actions : ['[RUN] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'orchid', 'drawing', 'wallshelf', 'floor', 'phone', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'shower', 'window', 'mousepad', 'pillow', 'nightstand', 'wall', 'oven', 'wall_clock', 'bed', 'novel', 'curtain', 'towel_rack', 'cupboard', 'door', 'sink', 'light', 'laser_pointer'] Task:Read book response: | { Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. Read the book. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['juice', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'thread', 'computer', 'stovefan', 'mat', 'tvstand', 'toaster', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'television', 'doorjamb', 'laundry_detergent', 'conditioner', 'sink', 'door', 'bathroom_cabinet', 'table', 'dishwasher'] Task:Do homework response: { thoughts : Sit on the couch in the Living room and pick u some papers, actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <check>', '[GRAB] <check>', '[DROP] <check>'] } Scene_Objects:['food_pizza', 'mop', 'chair', 'bathroom', 'drawing', 'wallshelf', 'character', 'bedroom', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'shower', 'faucet', 'floor_lamp', 'mousepad', 'closetdrawer', 'nightstand', 'wall', 'oven', 'bench', 'photoframe', 'bed', 'coffe_maker', 'food_food', 'check', 'conditioner', 'light', 'table', 'tooth_paste'] Task:Turn on light response: | { walk to living room, find lamp, switch on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'toilet', 'jelly', 'freezer', 'walllamp', 'knifeblock', 'drawing', 'floor', 'ceiling', 'food_cake', 'stovefan', 'toaster', 'plate', 'mat', 'shower', 'food_kiwi', 'wall', 'nightstand', 'oven', 'powersocket', 'photoframe', 'food_food', 'tray', 'food_onion', 'doorjamb', 'kitchen_counter', 'sauce_pan', 'cupboard', 'door', 'food_steak', 'spoon', 'light', 'dishwasher'] Task:Cook some food response: { thoughts : I pull a sauce pan from the cupboard. I turn the stove on. I take my ingredients from the pantry and fridge. I put the ingredients in the pan and I mix them with a spoon. I cook until the food is finished and transfer my food to a plate., actions : ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <spoon>', '[GRAB] <spoon>', '[FIND] <sauce_pan>', '[PUTBACK] <spoon> <sauce_pan>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <plate>', '[PUTBACK] <pot> <plate>'] } Scene_Objects:['fork', 'toilet', 'freezer', 'detergent', 'drawing', 'knife', 'wallshelf', 'dvd_player', 'character', 'bookshelf', 'plate', 'shower', 'tvstand', 'dish_soap', 'closetdrawer', 'pillow', 'food_kiwi', 'nightstand', 'powersocket', 'cutting_board', 'photoframe', 'wooden_spoon', 'dishrack', 'dresser', 'cupboard', 'door', 'sink', 'spoon', 'light', 'dishwasher'] Task:Wash dishes with dishwasher response: | { put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'floor', 'ceiling', 'keyboard', 'stovefan', 'electric_shaver', 'clothes_socks', 'form', 'wall', 'nightstand', 'oven', 'cutting_board', 'coffe_maker', 'food_food', 'oven_mitts', 'food_donut', 'tray', 'doorjamb', 'kettle', 'mouse', 'kitchen_counter', 'laundry_detergent', 'home_office', 'table', 'bathroom_cabinet', 'instrument_guitar'] Task:Put groceries in Fridge response: { thoughts : go to the kitchen and put the groceries in the fridge, actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>'] } Scene_Objects:['sheets', 'food_ice_cream', 'microwave', 'toilet', 'freezer', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'shower', 'faucet', 'wall', 'nightstand', 'oven', 'food_food', 'video_game_controller', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink'] Task:Cook some food response: | { Walk Into Kitchen. Open Refrigerator. Grab Food. Walk to Microwave. Insert food into microwave. Cook until warm. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'door'] Task:Watch youtube response: { thoughts : Go to youtube.Com watch videos, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['microwave', 'chair', 'jelly', 'walllamp', 'orchid', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'envelope', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mousepad', 'wall', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table'] Task:Work response: | { Go into the office and sit down at the desk in front of the computer. Turn on the computer and look at it while clicking with the mouse and typing with the 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:['microwave', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'toaster', 'tvstand', 'window', 'oil', 'couch', 'wall', 'nightstand', 'newspaper', 'coffe_maker', 'television', 'coffee_filter', 'water', 'food_donut', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'dirt'] Task:Make coffee response: { thoughts : Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on., actions : ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>'] } Scene_Objects:['chair', 'walllamp', 'blow_dryer', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'thread', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'mat', 'foundation', 'mousepad', 'wall', 'powersocket', 'television', 'doorjamb', 'kettle', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'light'] Task:Work response: | { I go to my home office, sit on the chair and turn on the computer. I open my email account to look for all the information I need.I pull up my online task on the computer to look at what the assigned task is. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'ceiling', 'desk', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'homework', 'mousepad', 'closetdrawer', 'pillow', 'dining_room', 'wall_clock', 'oven', 'tape', 'photoframe', 'dresser', 'cupboard', 'bathtub', 'light', 'dirt'] Task:Listen to music response: { thoughts : I reach out arm. I put hand on radio. I turn on radio. I pick a station., actions : ['[WALK] <bedroom>', '[WALK] <stereo>', '[TOUCH] <stereo>', '[TURNTO] <stereo>'] } Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'tea_bag', 'food_bacon', 'mop_bucket', 'tvstand', 'electric_shaver', 'dining_room', 'wall', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'table', 'home_office', 'colander'] Task:Turn on light response: | { push any ligth button to turn it on, for example in the living room } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'pot', 'microwave', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'keyboard', 'food_cake', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'oil', 'tooth_paste', 'couch', 'closetdrawer', 'dining_room', 'toy', 'basket_for_clothes', 'light_bulb', 'check', 'centerpiece', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'light', 'board_game'] Task:Brush teeth response: { thoughts : EARLY MORNING AND BEFORE GOING TO BED, actions : ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>'] } Scene_Objects:['jelly', 'freezer', 'walllamp', 'bathroom', 'bills', 'needle', 'drawing', 'character', 'table_cloth', 'toaster', 'picture', 'floor_lamp', 'window', 'mousepad', 'microphone', 'food_kiwi', 'wall', 'wall_clock', 'newspaper', 'bed', 'television', 'tray', 'cupboard', 'controller', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office'] Task:Turn on light response: | { I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'computer', 'stovefan', 'tvstand', 'faucet', 'shower', 'pillow', 'wall', 'cup', 'bed', 'coffe_maker', 'television', 'tray', 'lighter', 'dresser', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response: { thoughts : Walk to the sink, turn on the faucet, put soap on hands, rub hands together under the water, rinse off hands, turn off faucet, dry hands, actions : ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[WALK] <sink>', '[FIND] <soap>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>'] } Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'pencil', 'bathtub', 'home_office', 'table'] Task:Browse internet response: | { For browsing internet walk to home office. Find Computer. Walk to Computer. Find Chair. Sit in a chair and switch on computer. Connect with internet and browse the net. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. 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', 'ground_coffee', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'bookmark', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'dining_room', 'wall', 'nightstand', 'oven', 'cup', 'bed', 'television', 'coffee_filter', 'mouse', 'door'] Task:Answer emails response: { thoughts : Open email application. Open new emails. Respond accordingly, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <laptop>'] } Scene_Objects:['tablelamp', 'freezer', 'bathroom', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'toaster', 'tvstand', 'faucet', 'mousepad', 'towel', 'wall', 'wall_clock', 'bench', 'powersocket', 'nightstand', 'bed', 'toilet_paper', 'television', 'wine', 'curtain', 'doorjamb', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'clothes_skirt', 'soap'] Task:Wash hands response: | { I walk into the bathroom. Walk to the sink. Turn on tap. Get soap. Wash and rinse hands. Turn off tap. Dry hands. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'stereo', 'faucet', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_food', 'food_donut', 'towel_rack', 'mouse', 'shoes', 'dishrack', 'sink', 'spoon', 'light', 'coffee'] Task:Go to toilet response: { thoughts : Walk to bathroom, find toilet., actions : ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>'] } Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'dining_room', 'wall', 'oven', 'powersocket', 'food_food', 'coffe_maker', 'television', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'bathtub', 'bathroom_cabinet'] Task:Put groceries in Fridge response: | { go to the kitchen and put the groceries in the fridge } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'love_seat', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'clothes_scarf'] Task:Watch TV response: { thoughts : Sit and watch the television, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'microwave', 'toilet', 'jelly', 'freezer', 'cpuscreen', 'floor', 'phone', 'ceiling', 'keyboard', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'foundation', 'clothes_socks', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'photoframe', 'tray', 'curtain', 'kitchen_counter', 'sink', 'clothes_scarf'] Task:Go to toilet response: | { walk to bathroom , run to toilet } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'chair', 'walllamp', 'drawing', 'needle', 'wallshelf', 'bills', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'check', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'tooth_paste'] Task:Watch TV response: { thoughts : I enter the living room and sit on the couch. I grab the remote and turn on the TV., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>'] } Scene_Objects:['sheets', 'water_glass', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'stovefan', 'mat', 'shower', 'closetdrawer', 'couch', 'wall', 'powersocket', 'oven', 'food_food', 'check', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light'] Task:Drink response: | { walk to kitchen ,find fridge ,open fridge ,find water glass , drink from water glass } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'character', 'bedroom', 'keyboard', 'table_cloth', 'toaster', 'stovefan', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'wall', 'oven', 'lighter', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'home_office'] Task:Go to toilet response: | { Travel through the house and locate the bathroom, and proceed to the toilet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['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', 'freezer', 'walllamp', 'drawing', 'orchid', 'needle', 'floor', 'phone', 'ceiling', 'character', 'keyboard', 'food_cake', 'computer', 'stovefan', 'mat', 'plate', 'window', 'closetdrawer', 'wall', 'powersocket', 'tape', 'television', 'tray', 'curtain', 'towel_rack', 'sink', 'spoon', 'bathtub', 'table', 'bathroom_cabinet'] Task:Set up table response: | { Place your plate on the placemat. The forks will be placed on the left side of the plate and the knife and spoon on the right and place the spoon to the right of the knife. If you want to set out food, place them above the plate. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'light', 'table'] Task:Draft home response: { thoughts : Using mathematics and CAD software design a home, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>'] } Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'clothes_jacket', 'mat', 'ceilinglamp', 'shower', 'window', 'closetdrawer', 'couch', 'dining_room', 'wall', 'powersocket', 'food_food', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub', 'board_game'] Task:Put groceries in Fridge response: | { Walk to kitchen. Open fridge. Put groceries in fridge. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['glue', 'pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Work response: { thoughts : I sit at my desk and work on the computer., actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['sheets', 'filing_cabinet', 'toilet', 'chair', 'freezer', 'drawing', 'floor', 'ceiling', 'keyboard', 'computer', 'stovefan', 'toaster', 'tvstand', 'faucet', 'shower', 'window', 'wall', 'oven', 'powersocket', 'cup', 'coffe_maker', 'coffee_filter', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'dirt', 'coffee'] Task:Make coffee response: | { Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'cat', 'floor', 'character', 'stamp', 'table_cloth', 'piano_bench', 'mat', 'window', 'couch', 'food_jam', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'cup', 'mouthwash', 'television', 'coffee_filter', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'clothes_dress', 'door', 'food_steak', 'bathtub', 'bag', 'table'] Task:Pet cat response: { thoughts : I see my cat on the couch so I walk over, sit down and pet the cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>'] } Scene_Objects:['ground_coffee', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'toaster', 'mat', 'faucet', 'electric_shaver', 'towel', 'pillow', 'wall', 'wall_clock', 'bench', 'bed', 'coffe_maker', 'curtain', 'doorjamb', 'dresser', 'sink', 'bag', 'bathroom_cabinet', 'table', 'soap', 'hands_both'] Task:Wash hands response: | { Go to bathroom, turn on faucet, wet hands, apply soap, rub hands, rinse hands, turn off faucet, dry hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'filing_cabinet', 'toilet', 'freezer', 'dough', 'drawing', 'hanger', 'floor', 'ceiling', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'powersocket', 'wall_clock', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'razor', 'coffee_filter', 'doorjamb', 'hairbrush', 'door', 'home_office', 'light', 'soap'] Task:Put away groceries response: { thoughts : Place groceries in refrigerator from shopping at the grocery store., actions : ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>'] } Scene_Objects:['pot', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'brush', 'ceilinglamp', 'tvstand', 'plate', 'mousepad', 'closetdrawer', 'dustpan', 'pillow', 'wall', 'powersocket', 'television', 'tray', 'doorjamb', 'centerpiece', 'mouse', 'shoes', 'table'] Task:Write an email response: | { walk to living room, look at computer, find chair, sit in chair, grab keyboard, grab mouse, type using keyboard and mouse } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'blender', 'crayon', 'walllamp', 'ceilingfan', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'mat', 'stovefan', 'wall', 'powersocket', 'oven', 'bench', 'cutting_board', 'food_rice', 'doorjamb', 'cd', 'door', 'light', 'vase', 'creditcard'] Task:Turn on light response: { thoughts : I enter the bedroom and find the light. Then I turn it on., actions : ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>'] } Scene_Objects:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'bookshelf', 'stovefan', 'mat', 'shower', 'window', 'closetdrawer', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'wall_clock', 'photoframe', 'food_food', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'home_office'] Task:Put groceries in Fridge response: | { Put groceries into the fridge } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'food_salt', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'phone', 'bookshelf', 'computer', 'toaster', 'tvstand', 'stereo', 'closetdrawer', 'food_peanut_butter', 'clothes_pants', 'form', 'wall', 'oven', 'cup', 'bed', 'mouthwash', 'rag', 'towel_rack', 'kitchen_counter', 'pajamas', 'food_steak', 'door', 'napkin', 'bathroom_cabinet'] Task:Listen to music response: { thoughts : Find the playback device you want to listen to. turn on. press play. enjoyu music., actions : ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>'] } Scene_Objects:['pot', 'tablelamp', 'microwave', 'toothbrush', 'drawing', 'orchid', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'bedroom', 'stovefan', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'pillow', 'wall', 'pasta', 'oven', 'coffe_maker', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'headset', 'sauce_pan', 'cupboard'] Task:Cook some food response: | { Cook some pasta on the stove } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'walllamp', 'cpuscreen', 'clothes_underwear', 'hanger', 'phone', 'bedroom', 'bookshelf', 'electric_shaver', 'window', 'towel', 'wall', 'nightstand', 'oven', 'powersocket', 'basket_for_clothes', 'newspaper', 'check', 'oven_mitts', 'after_shave', 'towel_rack', 'mouse', 'kettle', 'dresser', 'laundry_detergent', 'bag', 'table', 'dishwasher', 'washing_machine', 'shoe_rack'] Task:Wash clothes response: { thoughts : Pick up my dirty clothes, load the washer, add detergent, turn on washer, actions : ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>'] } Scene_Objects:['food_salt', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'needle', 'floor', 'ceiling', 'computer', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'oven', 'cup', 'photoframe', 'toilet_paper', 'coffe_maker', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'light', 'creditcard'] Task:Go to toilet response: | { i go to the bathroom. I find the toilet } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'band-aids', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'stamp', 'desk', 'cleaning_solution', 'computer', 'stovefan', 'deck_of_cards', 'faucet', 'tvstand', 'window', 'couch', 'wall', 'nightstand', 'coffe_maker', 'television', 'mirror', 'after_shave', 'paper_towel', 'clothes_dress', 'sink', 'bag', 'bathroom_cabinet', 'dishwasher', 'laser_pointer'] Task:Clean mirror response: { thoughts : First spray the mirrors with Windex or window type spray. Take paper towels and wipe until sparkly clean. If they have streaks, repeat the process., actions : ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[FIND] <cleaning_solution>', '[RINSE] <cleaning_solution>', '[WIPE] <mirror>'] } Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_cake', 'stovefan', 'faucet', 'closetdrawer', 'couch', 'form', 'dining_room', 'wall', 'nightstand', 'photoframe', 'television', 'tray', 'doorjamb', 'cards', 'kitchen_counter', 'dresser', 'sink', 'bathtub', 'bathroom_cabinet', 'home_office', 'light', 'teeth'] Task:Wash teeth response: | { Walk to bathroom. Find mouthwash or turn on water. Put mouthwash or water in mouth. Swish around for 30 seconds. Spit mouthwash out. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'bookshelf', 'ceilinglamp', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'novel', 'check', 'tray', 'doorjamb', 'towel_rack', 'console', 'pencil', 'light'] Task:Read book response: { thoughts : Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook., actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[TURNTO] <filing_cabinet>', '[LOOKAT] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>'] } Scene_Objects:['microwave', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'computer', 'stovefan', 'tvstand', 'faucet', 'shower', 'pillow', 'wall', 'cup', 'bed', 'coffe_maker', 'television', 'tray', 'lighter', 'dresser', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'soap', 'hands_both'] Task:Wash hands response: | { Walk to the sink, turn on the faucet, put soap on hands, rub hands together under the water, rinse off hands, turn off faucet, dry hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'ground_coffee', 'detergent', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'bookshelf', 'envelope', 'mat', 'shower', 'faucet', 'homework', 'mousepad', 'wall', 'toy', 'photoframe', 'check', 'coffee_filter', 'food_onion', 'shaving_cream', 'cards', 'mouse', 'dresser', 'hairbrush', 'door', 'soap', 'scrabble'] Task:Clean response: { thoughts : Enter inside kid's room, begin picking up toys from the floor and putting them in a toy box, leave once once., actions : ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>'] } Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'orchid', 'floor', 'bedroom', 'bookshelf', 'toaster', 'tvstand', 'faucet', 'shower', 'stereo', 'closetdrawer', 'couch', 'broom', 'wall', 'wall_clock', 'photoframe', 'bed', 'television', 'mouse', 'kitchen_counter', 'comb', 'dresser', 'sink', 'spoon', 'clothes_skirt'] Task:Go to toilet response: | { I walk into the bath room and go to the toilet } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'mop', 'chair', 'blow_dryer', 'orchid', 'cpuscreen', 'floor', 'phone', 'folder', 'desk', 'bookshelf', 'remote_control', 'computer', 'toaster', 'stovefan', 'mousepad', 'couch', 'pillow', 'wall', 'wall_clock', 'photoframe', 'novel', 'television', 'coin', 'coffee_filter', 'doorjamb', 'shoes', 'cupboard', 'sink', 'light'] Task:Watch TV response: { thoughts : I walk to the living room and sit on the couch. I grab the TV remote. I press the power button on the TV remote and the TV turns on. I grab the surround sound remote. I press the power button on the surround sound remote and the system turns on., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[PUSH] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>'] } Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'towel_rack', 'kitchen_counter', 'chessboard', 'sink', 'home_office', 'bathroom_cabinet', 'table', 'instrument_violin'] Task:Go to toilet response: | { Walk to the bathroom. Find the toilet. Lift the top of the toilet. Sit on the toilet. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'door', 'light', 'table'] Task:Vacuum response: { thoughts : Keep my keyboard vacuumed and free of debris., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>'] } Scene_Objects:['toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'toaster', 'ceilinglamp', 'window', 'floor_lamp', 'couch', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'comb', 'door', 'bathtub', 'bathroom_cabinet', 'coffee'] Task:Turn on light response: | { Turning on lights } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['fork', 'toilet', 'freezer', 'detergent', 'drawing', 'knife', 'wallshelf', 'dvd_player', 'character', 'bookshelf', 'plate', 'shower', 'tvstand', 'dish_soap', 'closetdrawer', 'pillow', 'food_kiwi', 'nightstand', 'powersocket', 'cutting_board', 'photoframe', 'wooden_spoon', 'dishrack', 'dresser', 'cupboard', 'door', 'sink', 'spoon', 'light', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <dishrack>', '[PUTBACK] <fork> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishrack>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishrack>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['water_glass', 'filing_cabinet', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'ceiling', 'desk', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'tvstand', 'wall', 'oven', 'box', 'food_food', 'coffe_maker', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub'] Task:Drink response: | { I enter the kitchen and grab a waterglass from the cupboard. I open the fridge and grap some water. I pour the water into the cup and drink it. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'dining_room', 'wall', 'powersocket', 'oven', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table'] Task:Turn on computer response: { thoughts : Push power button., actions : ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'microwave', 'chair', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'computer', 'table_cloth', 'tvstand', 'shower', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'television', 'tray', 'doorjamb', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'board_game'] Task:Turn on light response: | { walk into living room, walk to light, turn on light switch. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['juice', 'nail_polish', 'wallshelf', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'stovefan', 'mat', 'plate', 'faucet', 'picture', 'tvstand', 'dish_soap', 'food_noodles', 'pillow', 'food_kiwi', 'wall', 'wall_clock', 'oven', 'tape', 'shelf', 'coin', 'tray', 'curtain', 'sink', 'napkin', 'bathroom_cabinet'] Task:Wash dishes by hand response: { thoughts : Make some dish water, grab a dish rag, put dishes in dish water and wash., actions : ['[RUN] <sink>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[PUTBACK] <dish_soap> <plate>', '[RINSE] <dish_soap>', '[FIND] <plate>', '[WASH] <plate>'] } Scene_Objects:['filing_cabinet', 'measuring_cup', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'oven', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office'] Task:Make coffee response: | { Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'food_bread', 'walllamp', 'bathroom', 'cpuscreen', 'kitchen_cabinet', 'floor', 'tea_bag', 'toaster', 'mat', 'stereo', 'balanceball', 'dish_soap', 'towel', 'wall', 'oven', 'bed', 'light_bulb', 'novel', 'coffe_maker', 'check', 'coin', 'food_donut', 'tray', 'doorjamb', 'towel_rack', 'sink', 'dishwasher', 'vase', 'clothes_shirt'] Task:Wash dishes with dishwasher response: { thoughts : I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTIN] <dish_soap> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['pot', 'walllamp', 'cat', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'toaster', 'window', 'oil', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'wall_clock', 'coffe_maker', 'television', 'curtain', 'mouse', 'home_office', 'table', 'coffee'] Task:Pet cat response: | { I walk into the living room. I see my cat on the couch. I go sit next to the cat on the couch. I pet the cat on the back. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'chair', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'toaster', 'mat', 'ceilinglamp', 'plate', 'stovefan', 'dish_soap', 'broom', 'wall', 'bench', 'food_food', 'coffe_maker', 'tray', 'wooden_spoon', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'table', 'dishwasher', 'instrument_violin'] Task:Wash dishes with dishwasher response: { thoughts : I go the in kitchen then grab the plate on the table. I put the plate and dish soap in the dishwasher. Finally, I turn on the dishwasher., actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['sheets', 'filing_cabinet', 'scissors', 'tablelamp', 'microwave', 'chair', 'bathroom', 'trashcan', 'drawing', 'clothes_underwear', 'phone', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'candle', 'clothes_pants', 'wall', 'photoframe', 'curtain', 'mouse', 'cupboard', 'clothes_dress', 'soap', 'tooth_paste', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: | { I need to get the dirty clothes basket. Walk to bathroom. Put all the clothes in washing machine. Add soap. Turn on machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light'] Task:Work response: { thoughts : Using desktop computer in home office, actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['food_ice_cream', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'mat', 'faucet', 'window', 'wall', 'wall_clock', 'powersocket', 'box', 'cup', 'bed', 'video_game_controller', 'television', 'doorjamb', 'console', 'kitchen_counter', 'door', 'light', 'teeth'] Task:Pick up phone response: | { I walk over to the phone and pick it up. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'blow_dryer', 'cat', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'ceilinglamp', 'balanceball', 'shower', 'window', 'couch', 'wall', 'powersocket', 'food_food', 'television', 'oven_mitts', 'doorjamb', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light', 'table', 'dishwasher'] Task:Pet cat response: { thoughts : My cat looks like it wants attention, so I will go pet it on the couch., actions : ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['tablelamp', 'chair', 'freezer', 'walllamp', 'bathroom', 'cat', 'trashcan', 'drawing', 'wallshelf', 'floor', 'desk', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'cup', 'food_food', 'television', 'curtain', 'towel_rack', 'mouse', 'sink', 'bathroom_cabinet', 'table', 'scrabble'] Task:Pet cat response: | { 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. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'walllamp', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'laptop', 'plate', 'stovefan', 'shower', 'dish_soap', 'wall', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher', 'coffee'] Task:Wash dishes with dishwasher response: { thoughts : Put the dishes on dinner table in the dishwasher and wash them, actions : ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[WALK] <table>', '[FIND] <pot>', '[GRAB] <pot>', '[WALK] <dishwasher>', '[PUTBACK] <pot> <dishwasher>', '[CLOSE] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'desk', 'tea_bag', 'bookshelf', 'ceilinglamp', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'novel', 'check', 'tray', 'doorjamb', 'towel_rack', 'console', 'pencil', 'light'] Task:Read book response: | { Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'sink'] Task:Use computer response: { thoughts : Browse the internet, actions : ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'freezer', 'bathroom', 'nail_polish', 'toothbrush', 'drawing', 'cpuscreen', 'food_egg', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'faucet', 'picture', 'powersocket', 'oven', 'bed', 'photoframe', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'food_steak', 'sink', 'door', 'table', 'instrument_violin'] Task:Pick up phone response: | { walk to living room, walk to the phone reach for the phone and pick up the phone. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'dry_pasta', 'food_ice_cream', 'toilet', 'freezer', 'knifeblock', 'wallshelf', 'folder', 'desk', 'stamp', 'bedroom', 'computer', 'toaster', 'mat', 'floor_lamp', 'dustpan', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'check', 'curtain', 'console', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'dishwasher'] Task:Turn on light response: { thoughts : I go home and it's dark so I can not see anything, actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'nail_polish', 'trashcan', 'drawing', 'orchid', 'floor', 'desk', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'bench', 'coffe_maker', 'television', 'curtain', 'mouse', 'bathtub', 'home_office', 'table', 'bathroom_cabinet'] Task:Relax on sofa response: | { Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'trashcan', 'drawing', 'floor', 'character', 'desk', 'purse', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'couch', 'pillow', 'nightstand', 'powersocket', 'novel', 'tray', 'mouse', 'bathroom_cabinet', 'soap', 'teeth'] Task:Pet cat response: { thoughts : First I need to find the cat in the living room. Then I walk over to the cat and pet it gently., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['chair', 'walllamp', 'detergent', 'drawing', 'orchid', 'food_egg', 'clothes_underwear', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'remote_control', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'bench', 'box', 'television', 'curtain', 'towel_rack', 'table', 'light'] Task:Change TV channel response: | { Changing channel } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['toilet', 'freezer', 'walllamp', 'food_butter', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'stereo', 'faucet', 'window', 'mousepad', 'pillow', 'wall', 'powersocket', 'bed', 'coffee_table', 'television', 'doorjamb', 'pencil', 'dresser', 'clothes_dress', 'door', 'table', 'dishwasher'] Task:Change TV channel response: { thoughts : Walk to the living room and look at the coffee table. Grab the remote control and turn to the television and point the remote control. Put back the remote control., actions : ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <coffee_table>', '[TURNTO] <coffee_table>', '[LOOKAT] <coffee_table>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUTOBJBACK] <remote_control>'] } Scene_Objects:['scissors', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'couch', 'pillow', 'wall', 'television', 'wine', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'cupboard', 'controller', 'sink', 'table', 'light'] Task:Change TV channel response: | { Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['sheets', 'tablelamp', 'scissors', 'chair', 'freezer', 'knifeblock', 'clothes_underwear', 'bookshelf', 'mop_bucket', 'stovefan', 'shower', 'window', 'couch', 'dining_room', 'nightstand', 'wall_clock', 'powersocket', 'photoframe', 'keys', 'bed', 'towel_rack', 'cd', 'dresser', 'cupboard', 'sink', 'napkin', 'bathroom_cabinet', 'home_office', 'dishwasher', 'board_game'] Task:Pet cat response: { thoughts : Find the cat. Pet the cat., actions : ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'microwave', 'toilet', 'freezer', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bookshelf', 'computer', 'toaster', 'mat', 'shower', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'bench', 'cup', 'food_food', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'napkin'] Task:Put groceries in Fridge response: | { Find groceries. Grab groceries. Walk to refrigerator. Open refrigerator door. Place groceries into refrigerator. Close refrigerator door. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'chair', 'milk', 'bathroom_counter', 'floor', 'bookshelf', 'table_cloth', 'toaster', 'tvstand', 'shower', 'foundation', 'pillow', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'cup', 'coffe_maker', 'food_onion', 'kitchen_counter', 'dishrack', 'cupboard', 'clothes_dress', 'sink', 'bag', 'table', 'dishwasher', 'dirt', 'shoe_rack'] Task:Wash dishes by hand response: { thoughts : walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer, actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <dishrack>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <dishrack> <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['food_bread', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'phone', 'desk', 'bookshelf', 'toaster', 'ceilinglamp', 'shower', 'faucet', 'couch', 'dining_room', 'nightstand', 'wall_clock', 'oven', 'wall', 'bed', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'hands_both'] Task:Wash hands response: | { walk to bathroom, look at the water, wash hands } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'remote_control', 'computer', 'button', 'toaster', 'mat', 'shower', 'food_peanut_butter', 'food_kiwi', 'nightstand', 'oven', 'photoframe', 'television', 'oven_mitts', 'tray', 'kettle', 'cards', 'pencil', 'kitchen_counter', 'towel_rack', 'bathtub', 'table'] Task:Change TV channel response: { thoughts : Walk into living room. Find television remote control. Pick up remote control. Press button., actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>'] } Scene_Objects:['microwave', 'chair', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mousepad', 'bowl', 'wall', 'newspaper', 'bed', 'novel', 'curtain', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'light', 'table'] Task:Browse internet response: | { go to the room, sit in the chair, turn on the computer, look for the news } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['blender', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'stereo', 'picture', 'mat', 'closetdrawer', 'couch', 'dining_room', 'wall_clock', 'bench', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'home_office', 'instrument_guitar'] Task:Turn on light response: { thoughts : I walk into the living room and then I walk to the light switch in there and turn the lights on, actions : ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>'] } Scene_Objects:['sheets', 'pot', 'tablelamp', 'microwave', 'toilet', 'trashcan', 'hanger', 'bathroom_counter', 'bedroom', 'keyboard', 'stovefan', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'nightstand', 'wall', 'oven', 'wall_clock', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'lighter', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'light', 'instrument_guitar', 'teeth'] Task:Set up table response: | { Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'freezer', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'toaster', 'window', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'nightstand', 'wall_clock', 'television', 'tray', 'curtain', 'mouse', 'kitchen_counter', 'dresser', 'clothes_shirt'] Task:Organize closet response: { thoughts : Organize the hanging clothes in my closet by color and type and get rid of clothes I don't wear., actions : ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PULL] <clothes_pants>', '[PUTIN] <clothes_pants> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUSH] <clothes_shirt>', '[PUTIN] <clothes_shirt> <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[CLOSE] <dresser>', '[WALK] <basket_for_clothes>', '[PUTBACK] <clothes_shirt> <basket_for_clothes>'] } Scene_Objects:['sheets', 'tablelamp', 'microwave', 'chair', 'bathroom', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'phone', 'character', 'computer', 'toaster', 'mat', 'tvstand', 'couch', 'clothes_hat', 'pillow', 'wall', 'wall_clock', 'bench', 'powersocket', 'cup', 'bed', 'food_food', 'television', 'mouse', 'pencil', 'bathroom_cabinet', 'table'] Task:Set up table response: | { walk to entrance hall. find a table. pull table. walk to living rook. push 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:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'doorjamb', 'headset', 'dresser', 'bathroom_cabinet', 'soap'] Task:Change TV channel response: { thoughts : I find the remote then I push the button to switch it to the tv channel i want to watch, actions : ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUSH] <remote_control>'] } Scene_Objects:['fork', 'tablelamp', 'chair', 'walllamp', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'toaster', 'plate', 'dish_soap', 'mousepad', 'closetdrawer', 'oven', 'powersocket', 'bed', 'photoframe', 'check', 'water', 'cards', 'hairbrush', 'sink', 'bathroom_cabinet', 'light'] Task:Wash dishes by hand response: | { walk to kitchen, fins soap, arrange dishes, wash dishes } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'food_food', 'television', 'wooden_spoon', 'curtain', 'diary', 'dresser', 'cupboard', 'clothes_dress', 'table', 'light'] Task:Watch TV response: { thoughts : You walk to the living room and sit on the sofa. You grab the remote control, look at it and point at the television, you watch television., actions : ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[WATCH] <television>'] } Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'freezer', 'trashcan', 'dough', 'cpuscreen', 'ceiling', 'bedroom', 'keyboard', 'toaster', 'mat', 'plate', 'shower', 'faucet', 'dish_soap', 'mousepad', 'closetdrawer', 'dining_room', 'wall_clock', 'bench', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'clothes_dress', 'sink', 'home_office', 'dishwasher', 'coffee'] Task:Wash dishes with dishwasher response: | { Walk to the kitchen. Open the dishwasher. Put plates into the dishwasher. Put dish soap into the dishwasher. Close the dishwasher. Turn on the dishwasher. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'crayon', 'toilet', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'bedroom', 'mail', 'food_bacon', 'clothes_jacket', 'table_cloth', 'faucet', 'mousepad', 'closetdrawer', 'food_jam', 'nightstand', 'powersocket', 'novel', 'food_food', 'centerpiece', 'diary', 'console', 'cupboard', 'bathroom_cabinet', 'table', 'light'] Task:Pick up phone response: { thoughts : Pick up the ringing phone, actions : ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[POINTAT] <table>', '[FIND] <phone>', '[GRAB] <phone>', '[PUTOBJBACK] <phone>'] } Scene_Objects:['microwave', 'toilet', 'chair', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'floor_lamp', 'mousepad', 'couch', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'doorjamb', 'cd', 'door', 'bathtub', 'home_office', 'light'] Task:Turn on light response: | { walk to wall, find 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:['filing_cabinet', 'tablelamp', 'toilet', 'freezer', 'orchid', 'drawing', 'wallshelf', 'floor', 'phone', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'shower', 'window', 'mousepad', 'pillow', 'nightstand', 'wall', 'oven', 'wall_clock', 'bed', 'novel', 'curtain', 'towel_rack', 'cupboard', 'door', 'sink', 'light', 'laser_pointer'] Task:Read book response: { thoughts : Go to the bedroom. Grab the book out of the nightstand. Lay down in bed. Open the book. Read the book., actions : ['[WALK] <bedroom>', '[WALK] <nightstand>', '[FIND] <nightstand>', '[OPEN] <nightstand>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bed>', '[TURNTO] <bed>', '[SIT] <bed>', '[READ] <novel>'] } Scene_Objects:['freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'phone', 'bookshelf', 'clothes_jacket', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'shower', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'table'] Task:Relax on sofa response: | { I walk to the living room and find the sofa. I sit on the sofa and get comfortable. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'stamp', 'bedroom', 'stovefan', 'toaster', 'plate', 'faucet', 'shower', 'dish_soap', 'food_jam', 'towel', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'ice', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'dishwasher'] Task:Wash dishes with dishwasher response: { thoughts : I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on., actions : ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>'] } Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'orchid', 'floor', 'desk', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'pillow', 'nightstand', 'wall_clock', 'oven', 'wall', 'coffe_maker', 'mouthwash', 'television', 'tray', 'towel_rack', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'light'] Task:Pick up phone response: | { walk to phone, grab phone, pick up phone, put to 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:['microwave', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'television', 'doorjamb', 'mouse', 'hairdryer', 'door', 'sink', 'home_office', 'table'] Task:Work response: { thoughts : Using desktop computer in home office, actions : ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>'] } Scene_Objects:['tea', 'toilet', 'dog', 'walllamp', 'trashcan', 'orchid', 'drawing', 'bedroom', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'bench', 'basket_for_clothes', 'tray', 'wooden_spoon', 'kitchen_counter', 'clothes_dress', 'hairdryer', 'sink', 'light', 'table', 'clothes_shirt', 'washing_machine'] Task:Wash clothes response: | { Walk to the kitchen. Find the washing machine. Open the washing machine. Find the basket for clothes. Find the clothes_dress. Grab the clothes_dress. Put the clothes_dress into the washing machine. Find the clothes_shirt. Grab the clothes_shirt. Put the clothes_shirt into the washing machine. Close the washing machine. Switch on the washing machine. } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['filing_cabinet', 'food_bread', 'crayon', 'tea', 'freezer', 'walllamp', 'bathroom', 'detergent', 'blow_dryer', 'drawing', 'floor', 'desk', 'thread', 'mop_bucket', 'tvstand', 'towel', 'wall', 'toy', 'cup', 'check', 'razor', 'food_donut', 'wine', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'laundry_detergent', 'light', 'soap'] Task:Vacuum response: { thoughts : Robot has a vacuum underneath its feat/body that will allow it to clean the surface of the floor., actions : ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[WALK] <dining_room>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[WALK] <home_office>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <filing_cabinet>', '[PUTBACK] <vacuum_cleaner> <filing_cabinet>', '[CLOSE] <filing_cabinet>'] } Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'window', 'mat', 'closetdrawer', 'wall', 'wall_clock', 'bed', 'photoframe', 'doorjamb', 'console', 'kitchen_counter', 'door', 'hairdryer', 'sink', 'light', 'clothes_skirt'] Task:Turn on light response: | { switching on light in an area } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['dry_pasta', 'food_ice_cream', 'toothbrush', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'alcohol', 'brush', 'shoe-shine_kit', 'faucet', 'mousepad', 'closetdrawer', 'candle', 'clothes_pants', 'wall', 'standingmirror', 'food_food', 'television', 'tray', 'coffee_pot', 'towel_rack', 'dresser', 'bathtub', 'bathroom_cabinet', 'vase'] Task:Dust response: { thoughts : Using soft brush, carefully dust both Indonesian wedding doll statues., actions : ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <brush>', '[GRAB] <brush>', '[CLOSE] <dresser>'] } Scene_Objects:['chair', 'drawing', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'dvd_player', 'bookshelf', 'remote_control', 'button', 'piano_bench', 'ceilinglamp', 'tvstand', 'mat', 'wall', 'wall_clock', 'bench', 'oven', 'nightstand', 'photoframe', 'television', 'doorjamb', 'kitchen_counter', 'cd', 'door', 'table', 'light'] Task:Change TV channel response: | { Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control } |
You serve as an AI task planner. 1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format [verb] <target1> <target2> , where 'verb' represents the action, and 'target1' and 'target2' are optional arguments. 2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. Ensure that you response can be parsed by Python json.loads. Here is an example plan to achieve a goal for reference: Scene_Objects:['pot', 'tablelamp', 'freezer', 'blow_dryer', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'shoe-shine_kit', 'couch', 'microphone', 'food_jam', 'wall', 'coffe_maker', 'check', 'television', 'curtain', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'colander', 'tooth_paste'] Task:Watch TV response: { thoughts : Walk to the living room. Find the television. Walk to the television. Switch on the television. Find the sofa. Walk to the sofa. Sit on the sofa. Find the remote control. Grab the remote control. Look at the television., actions : ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[WALK] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>'] } Scene_Objects:['sponge', 'filing_cabinet', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'table_cloth', 'toaster', 'stovefan', 'tvstand', 'shower', 'faucet', 'closetdrawer', 'nightstand', 'wall', 'bench', 'coffe_maker', 'check', 'television', 'tray', 'pencil', 'shoes', 'sink', 'bathtub', 'light'] Task:Listen to music response: | { turn radio on, listen to music } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.