instruction
stringlengths 999
2.35k
| input
stringlengths 341
562
| output
dict |
|---|---|---|
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'crayon', 'dog', 'toothbrush', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'faucet', 'shower', 'balanceball', 'mousepad', 'wall', 'pasta', 'powersocket', 'oven', 'nightstand', 'photoframe', 'video_game_controller', 'coffee_filter', 'wooden_spoon', 'console', 'shoes', 'sink', 'bathroom_cabinet', 'tooth_paste', 'teeth']
Task:Brush teeth
response:
{
"thoughts": Put toothpaste on toothbrush, brush teeth, rinse mouth,
"actions": ['[WALK] <bathroom>', '[WALK] <toothbrush>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>', '[PUTOBJBACK] <tooth_paste>', '[WALK] <sink>', '[FIND] <teeth>', '[SCRUB] <teeth>', '[SCRUB] <teeth>', '[SCRUB] <teeth>', '[PUTBACK] <toothbrush> <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[RINSE] <teeth>', '[SWITCHOFF] <faucet>', '[GRAB] <toothbrush>', '[PUTOBJBACK] <toothbrush>']
}
|
Scene_Objects:['sponge', 'microwave', 'chair', 'trashcan', 'ceilingfan', 'bills', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'stamp', 'bookshelf', 'envelope', 'computer', 'stovefan', 'pillow', 'wall', 'powersocket', 'coffe_maker', 'television', 'oven_mitts', 'ice', 'doorjamb', 'towel_rack', 'dresser', 'cupboard', 'door', 'light', 'table']
Task:Turn on light
response:
| {
"thoughts": "Coming home turning on lights.",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'microwave', 'walllamp', 'bathroom', 'toothbrush', 'drawing', 'orchid', 'floor', 'desk', 'computer', 'ceilinglamp', 'mat', 'deck_of_cards', 'stereo', 'window', 'couch', 'food_jam', 'pillow', 'wall', 'light_bulb', 'food_donut', 'tray', 'curtain', 'shoes', 'dishrack', 'sink', 'spoon', 'table', 'dishwasher', 'coffee']
Task:Relax on sofa
response:
{
"thoughts": I walk to the living room. I see the couch. I sit down on the couch, then lie down and put my feet up.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['filing_cabinet', 'food_bread', 'scissors', 'measuring_cup', 'toilet', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'remote_control', 'purse', 'brush', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'form', 'dining_room', 'wall', 'powersocket', 'television', 'curtain', 'food_onion', 'table']
Task:Watch TV
response:
| {
"thoughts": "Walk to living room. Find remote control. Look at remote control. Push power on button. Find sofa. Sit down on sofa. Watch Television.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[TURNTO] <remote_control>",
"[LOOKAT] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <couch>",
"[SIT] <couch>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'ceilinglamp', 'floor_lamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'oven', 'photoframe', 'novel', 'television', 'doorjamb', 'dresser', 'cupboard', 'light']
Task:Read book
response:
{
"thoughts": A person brings a book into the living room and sits down in a comfortable chair. If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read. The person begins reading the book until they need to stop for some reason.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <novel>']
}
|
Scene_Objects:['pot', 'tablelamp', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bookshelf', 'computer', 'stovefan', 'toaster', 'food_noodles', 'wall', 'oven', 'toy', 'food_vegetable', 'food_food', 'video_game_controller', 'water', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'dishwasher', 'scrabble']
Task:Cook some food
response:
| {
"thoughts": "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",
"actions": [
"[WALK] <dining_room>",
"[WALK] <oven>",
"[FIND] <oven>",
"[FIND] <pot>",
"[FIND] <food_vegetable>",
"[FIND] <water>",
"[GRAB] <water>",
"[WASH] <food_vegetable>",
"[POUR] <water> <pot>",
"[FIND] <pot>",
"[GRAB] <pot>",
"[PUTBACK] <pot> <oven>",
"[SWITCHON] <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'toilet', 'detergent', 'food_butter', 'dough', 'food_carrot', 'drawing', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'keyboard', 'computer', 'clothes_jacket', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'mousepad', 'towel', 'wall', 'oven', 'cup', 'photoframe', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'hands_both']
Task:Wash hands
response:
{
"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:['tablelamp', 'toilet', 'chair', 'walllamp', 'cpuscreen', 'clothes_underwear', 'floor', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'mail', 'toaster', 'laptop', 'balanceball', 'window', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'photoframe', 'novel', 'coffe_maker', 'coffee_filter', 'mouse', 'clothes_skirt', 'vase']
Task:Write an email
response:
| {
"thoughts": "I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email",
"actions": [
"[WALK] <laptop>",
"[SWITCHON] <laptop>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'food_bread', 'toilet', 'bathroom', 'detergent', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'mail', 'ceilinglamp', 'shower', 'iron', 'closetdrawer', 'couch', 'towel', 'oven', 'coin', 'lighter', 'console', 'mouse', 'shoes', 'cd', 'dishrack', 'spoon', 'light', 'table']
Task:Switch on lamp
response:
{
"thoughts": Press the button so the light comes on.,
"actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}
|
Scene_Objects:['pot', 'crayon', 'toilet', 'walllamp', 'milk', 'orchid', 'knife', 'ceiling', 'dvd_player', 'character', 'desk', 'thread', 'mop_bucket', 'toaster', 'oil', 'food_noodles', 'candle', 'bowl', 'bench', 'powersocket', 'check', 'mouthwash', 'television', 'maindoor', 'spoon', 'home_office', 'bathroom_cabinet', 'light', 'vase', 'laser_pointer']
Task:Listen to music
response:
| {
"thoughts": "Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'stovefan', 'faucet', 'food_jam', 'wall', 'nightstand', 'oven', 'cup', 'photoframe', 'light_bulb', 'bed', 'clothes_gloves', 'television', 'water', 'tray', 'lighter', 'towel_rack', 'kitchen_counter', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'colander']
Task:Drink
response:
{
"thoughts": Walk to kitchen, grab a cup, fill with water and then drink it.,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[DRINK] <cup>']
}
|
Scene_Objects:['measuring_cup', 'chair', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'window', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'curtain', 'doorjamb', 'shaving_cream', 'mouse', 'comb', 'door', 'napkin', 'table', 'light']
Task:Browse internet
response:
| {
"thoughts": "I turn on computer. I use keyboard to type. I open browser. I search.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <computer>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_salt', 'microwave', 'drawing', 'orchid', 'wallshelf', 'floor', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'shower', 'faucet', 'dish_soap', 'closetdrawer', 'pillow', 'wall', 'novel', 'coffe_maker', 'food_rice', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Walk to kitchen. Find dishwasher. Open dishwasher. Find dishrack. Find plate 1. Grab plate 1. Put plate 1 in dishrack. Repeat for dish 2. Find dish soap. Grab dish soap. Put dish soap to dishwasher. Close dishwasher. Switch on dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', '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:
{
"thoughts": 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.,
"actions": ['[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[DROP] <plate>', '[FIND] <fork>', '[GRAB] <fork>', '[DROP] <fork>', '[FIND] <spoon>', '[GRAB] <spoon>', '[DROP] <spoon>']
}
|
Scene_Objects:['filing_cabinet', 'dog', 'bathroom', 'food_carrot', 'bills', 'ceiling', 'phone', 'keyboard', 'stovefan', 'stereo', 'window', 'oven', 'bench', 'tape', 'bed', 'light_bulb', 'food_onion', 'coffee_pot', 'kettle', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'maindoor', 'instrument_guitar', 'table', 'bathroom_cabinet', 'dishwasher', 'coffee']
Task:Pet cat
response:
| {
"thoughts": "I walk to my living room, find my cat, scrub it using my hand.",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[SCRUB] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'tea_bag', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'hair', 'door']
Task:Write an email
response:
{
"thoughts": 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.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <computer>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'juice', 'freezer', 'cat', 'drawing', 'knife', 'floor', 'ceiling', 'shampoo', 'desk', 'clothes_jacket', 'button', 'ceilinglamp', 'mat', 'balanceball', 'window', 'couch', 'clothes_pants', 'wall', 'oven', 'tape', 'photoframe', 'television', 'tray', 'curtain', 'table', 'soap', 'shoe_rack']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'bathroom', 'clothes_underwear', 'floor', 'ceiling', 'thread', 'computer', 'bookmark', 'toaster', 'stovefan', 'couch', 'wall', 'powersocket', 'cup', 'food_food', 'razor', 'water', 'tray', 'centerpiece', 'pencil', 'kitchen_counter', 'chessboard', 'cupboard', 'clothes_scarf', 'light', 'table', 'dishwasher']
Task:Drink
response:
{
"thoughts": Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']
}
|
Scene_Objects:['fork', 'scissors', 'tea', 'freezer', 'walllamp', 'knifeblock', 'knife', 'bills', 'floor', 'toaster', 'mat', 'plate', 'stereo', 'picture', 'tvstand', 'dish_soap', 'microphone', 'wall', 'oven', 'cup', 'light_bulb', 'coffe_maker', 'drinking_glass', 'tray', 'mouse', 'cupboard', 'controller', 'maindoor', 'spoon', 'dishwasher']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into the dishwasher. Turn on the dishwasher.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[TURNTO] <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[OPEN] <dishwasher>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[FIND] <drinking_glass>",
"[GRAB] <drinking_glass>",
"[PUTBACK] <drinking_glass> <dishwasher>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[PUTBACK] <fork> <dishwasher>",
"[FIND] <knife>",
"[GRAB] <knife>",
"[PUTBACK] <knife> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'blender', 'beer', 'toilet', 'jelly', 'freezer', 'blow_dryer', 'detergent', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'mail', 'computer', 'bookmark', 'stereo', 'window', 'couch', 'microphone', 'check', 'television', 'rag', 'pencil', 'controller', 'dishwasher']
Task:Pet cat
response:
{
"thoughts": Pet Cat,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'ground_coffee', 'trashcan', 'desk', 'bedroom', 'purse', 'mop_bucket', 'shower', 'picture', 'homework', 'mousepad', 'form', 'wall', 'oven', 'bed', 'keys', 'video_game_controller', 'wine', 'food_onion', 'after_shave', 'console', 'mouse', 'cd', 'comb', 'dresser', 'door', 'clothes_skirt', 'dirt']
Task:Pet cat
response:
| {
"thoughts": "Find the cat; pet the cat by touching it",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'toilet', 'freezer', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'button', 'bookmark', 'ceilinglamp', 'window', 'couch', 'microphone', 'pillow', 'wall', 'pasta', 'tape', 'box', 'novel', 'curtain', 'doorjamb', 'hairbrush', 'door', 'home_office', 'table', 'bathroom_cabinet', 'soap', 'tooth_paste', 'clothes_shirt']
Task:Text friends while sitting on couch
response:
{
"thoughts": Text while sitting,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[TOUCH] <phone>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'food_carrot', 'drawing', 'floor', 'character', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'candle', 'wall', 'wall_clock', 'oven', 'cup', 'photoframe', 'bed', 'novel', 'check', 'toilet_paper', 'television', 'curtain', 'towel_rack', 'mouse', 'hairbrush', 'laundry_detergent', 'table', 'clothes_skirt']
Task:Read book
response:
| {
"thoughts": "Walk to the couch in the living room, sit on ti and read the book",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'console', 'dresser', 'cupboard', 'home_office', 'table', 'clothes_skirt', 'vase']
Task:Watch TV
response:
{
"thoughts": Watch the television,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[SWITCHON] <television>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['pot', 'beer', 'toilet', 'jelly', 'drawing', 'orchid', 'cpuscreen', 'floor', 'purse', 'ceilinglamp', 'mat', 'shower', 'window', 'couch', 'food_orange', 'dining_room', 'wall', 'box', 'food_cheese', 'photoframe', 'bed', 'coffe_maker', 'television', 'tray', 'doorjamb', 'centerpiece', 'towel_rack', 'cd', 'table', 'creditcard']
Task:Relax on sofa
response:
| {
"thoughts": "I walk into the living room. I cross the room to the couch. I sit down and relax.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'beer', 'toilet', 'band-aids', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'desk', 'mail', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'stereo', 'iron', 'shower', 'pillow', 'nightstand', 'toy', 'bed', 'food_food', 'oven_mitts', 'coffee_filter', 'after_shave', 'curtain', 'lighter', 'cupboard', 'maindoor']
Task:Pet cat
response:
{
"thoughts": I walk to the living room. I find the cat. I pet the cat.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['fork', 'tablelamp', 'freezer', 'ceilingfan', 'food_carrot', 'knifeblock', 'clothes_underwear', 'floor', 'ceiling', 'bedroom', 'desk', 'stamp', 'alcohol', 'food_bacon', 'table_cloth', 'ceilinglamp', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'food_food', 'check', 'television', 'towel_rack', 'kettle', 'kitchen_counter', 'dishrack', 'hair', 'dishwasher', 'vase']
Task:Put groceries in Fridge
response:
| {
"thoughts": "walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in fridge.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[OPEN] <freezer>",
"[PUTIN] <food_food> <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'walllamp', 'drawing', 'orchid', 'floor', 'folder', 'mop_bucket', 'ceilinglamp', 'stereo', 'picture', 'window', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'bench', 'powersocket', 'novel', 'coffe_maker', 'toilet_paper', 'toothbrush_holder', 'tray', 'curtain', 'lighter', 'headset', 'cupboard', 'table']
Task:Relax on sofa
response:
{
"thoughts": I walk to the living room and find the sofa. I sit on the sofa and get comfortable.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['sheets', 'microwave', 'chair', 'freezer', 'hanger', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'balanceball', 'picture', 'window', 'clothes_hat', 'broom', 'wall', 'pasta', 'novel', 'doorjamb', 'coffee_pot', 'vacuum_cleaner', 'dresser', 'cupboard', 'clothes_dress', 'door', 'maindoor', 'bag', 'light', 'table', 'vase']
Task:Pick up phone
response:
| {
"thoughts": "walk over and pick up the phone",
"actions": [
"[WALK] <phone>",
"[GRAB] <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:['chair', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'tvstand', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'oven', 'cup', 'standingmirror', 'check', 'television', 'centerpiece', 'console', 'mouse', 'vacuum_cleaner', 'shoes', 'comb', 'dresser', 'hairbrush', 'sink', 'bag', 'napkin', 'bathroom_cabinet', 'vase']
Task:vacuum carpet
response:
{
"thoughts": I bring my vacuum cleaner into the living room. I plug it into the wall. I press the on switch on the vacuum cleaner. I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet. I turn the vacuum cleaner off. I take the vacuum cleaner back to the hall closet.,
"actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']
}
|
Scene_Objects:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'detergent', 'food_butter', 'longboard', 'floor', 'bathroom_counter', 'bedroom', 'keyboard', 'toaster', 'plate', 'dish_soap', 'bowl', 'broom', 'wall', 'pasta', 'oven', 'bed', 'coffe_maker', 'check', 'food_food', 'coffee_filter', 'tray', 'doorjamb', 'headset', 'cupboard', 'light', 'dishwasher']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Go to the kitchen. Find the dishwasher. Open the dishwasher. Find the plates. Load the plates into the dishwasher. Find the soap. Load the soap into the dishwasher. Close the dishwasher. Turn on the dishwasher.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'crayon', 'bathroom', 'drawing', 'floor', 'phone', 'character', 'keyboard', 'remote_control', 'button', 'ceilinglamp', 'shower', 'window', 'foundation', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'check', 'food_food', 'television', 'dresser', 'sink', 'table', 'dishwasher', 'clothes_skirt', 'tooth_paste', 'dirt']
Task:Change TV channel
response:
{
"thoughts": go to living room. grab remote control. sit on couch. point remote at tv. push buttons.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[FIND] <button>', '[PUSH] <button>']
}
|
Scene_Objects:['sheets', 'microwave', 'freezer', 'walllamp', 'bathroom', 'ground_coffee', 'cat', 'blow_dryer', 'ceilingfan', 'bathroom_counter', 'bedroom', 'desk', 'clothes_jacket', 'toaster', 'ceilinglamp', 'tvstand', 'stereo', 'light_bulb', 'coffe_maker', 'mouthwash', 'kitchen_counter', 'chessboard', 'cupboard', 'clothes_dress', 'door', 'clothes_scarf', 'table', 'dishwasher', 'washing_machine', 'coffee']
Task:Wash clothes
response:
| {
"thoughts": "walk to kitchen. grab clothes_dress. look at washing machine. open washing machine. put clothes_dress on washing machine. close washing machine. switch on washing machine. switch off washing machine.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <clothes_dress>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[FIND] <washing_machine>",
"[TURNTO] <washing_machine>",
"[LOOKAT] <washing_machine>",
"[OPEN] <washing_machine>",
"[PUTBACK] <clothes_dress> <washing_machine>",
"[CLOSE] <washing_machine>",
"[SWITCHON] <washing_machine>",
"[SWITCHOFF] <washing_machine>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'juice', 'microwave', 'chair', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'drawing', 'knife', 'floor', 'ceiling', 'thread', 'toaster', 'dustpan', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'chessboard', 'cupboard', 'spoon', 'light', 'dishwasher']
Task:Make coffee
response:
{
"thoughts": Walk to kitchen. Find coffee maker. Find coffee filter. Put it in the coffee maker. Find ground coffee. Put it in the coffee maker. Find Water. Put it in the coffe maker. Switch on the coffee maker.,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[FIND] <water>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['sponge', 'juice', 'toilet', 'walllamp', 'toothbrush', 'drawing', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stamp', 'faucet', 'balanceball', 'clothes_pants', 'wall', 'powersocket', 'photoframe', 'novel', 'toothbrush_holder', 'television', 'food_donut', 'tray', 'towel_rack', 'cupboard', 'controller', 'sink', 'bathroom_cabinet', 'tooth_paste']
Task:Wash teeth
response:
| {
"thoughts": "I go into the bathroom, go to the sink, get toothbrush and toothpaste. Put toothpaste on the toothbrush, brush teeth, turn on faucet, rinse brush, and return toothbrush.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <toothbrush_holder>",
"[TURNTO] <toothbrush_holder>",
"[LOOKAT] <toothbrush_holder>",
"[FIND] <toothbrush>",
"[GRAB] <toothbrush>",
"[FIND] <tooth_paste>",
"[GRAB] <tooth_paste>",
"[PUTBACK] <tooth_paste> <toothbrush_holder>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <toothbrush>",
"[PUTBACK] <toothbrush> <toothbrush_holder>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'band-aids', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'bathroom_counter', 'phone', 'bookshelf', 'computer', 'stovefan', 'mat', 'plate', 'ceilinglamp', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'bench', 'powersocket', 'oven', 'cutting_board', 'curtain', 'mouse', 'table', 'dishwasher', 'light']
Task:Set up table
response:
{
"thoughts": Walk to the kitchen. Open the kitchen cabinet. Grab the plate and put it on the table.,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <table>', '[PUTBACK] <plate> <table>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'drawing', 'orchid', 'clothes_underwear', 'hanger', 'bathroom_counter', 'dvd_player', 'desk', 'bookshelf', 'ceilinglamp', 'mat', 'plate', 'shower', 'homework', 'candle', 'towel', 'pillow', 'bed', 'food_food', 'television', 'food_donut', 'pencil', 'kitchen_counter', 'shoes', 'hair', 'sink', 'laser_pointer', 'dirt', 'coffee']
Task:Pick up phone
response:
| {
"thoughts": "go to living room, find phone, pick up phone",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>",
"[GRAB] <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:['fork', 'food_salt', 'food_butter', 'food_carrot', 'drawing', 'food_egg', 'floor', 'phone', 'ceiling', 'character', 'purse', 'mat', 'plate', 'window', 'mousepad', 'closetdrawer', 'couch', 'food_orange', 'bed', 'photoframe', 'tray', 'coffee_pot', 'kitchen_counter', 'shoes', 'pajamas', 'sink', 'spoon', 'bathtub', 'table', 'vase']
Task:Set up table
response:
{
"thoughts": 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.,
"actions": ['[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[DROP] <plate>', '[FIND] <fork>', '[GRAB] <fork>', '[DROP] <fork>', '[FIND] <spoon>', '[GRAB] <spoon>', '[DROP] <spoon>']
}
|
Scene_Objects:['pot', 'freezer', 'walllamp', 'trashcan', 'food_carrot', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'food_chicken', 'desk', 'stovefan', 'ceilinglamp', 'toaster', 'balanceball', 'shower', 'faucet', 'food_noodles', 'bowl', 'wall', 'oven', 'powersocket', 'cup', 'bed', 'food_food', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'dishwasher']
Task:Cook some food
response:
| {
"thoughts": "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.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_chicken>",
"[GRAB] <food_chicken>",
"[FIND] <pot>",
"[GRAB] <pot>",
"[FIND] <oven>",
"[PUTBACK] <pot> <oven>",
"[PUTBACK] <food_chicken> <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'food_salt', 'toilet', 'walllamp', 'bathroom', 'food_butter', 'drawing', 'hanger', 'shampoo', 'bedroom', 'purse', 'computer', 'stovefan', 'laptop', 'ceilinglamp', 'electric_shaver', 'window', 'homework', 'clothes_socks', 'wall_clock', 'shelf', 'basket_for_clothes', 'bed', 'coffe_maker', 'check', 'wooden_spoon', 'centerpiece', 'lighter', 'kettle']
Task:Browse internet
response:
{
"thoughts": The task is browse and surf on the internet regarding a particular topic,
"actions": ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>']
}
|
Scene_Objects:['freezer', 'drawing', 'cpuscreen', 'floor', 'stamp', 'desk', 'keyboard', 'bookshelf', 'brush', 'ceilinglamp', 'laptop', 'balanceball', 'toaster', 'window', 'couch', 'clothes_pants', 'broom', 'wall', 'pasta', 'oven', 'nightstand', 'box', 'mouthwash', 'television', 'razor', 'curtain', 'pajamas', 'sink', 'table', 'clothes_skirt']
Task:Relax on sofa
response:
| {
"thoughts": "I walk to the living room. I sit in the sofa and I relax.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <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:['tablelamp', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'broom', 'wall', 'pasta', 'powersocket', 'shelf', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'light', 'table']
Task:Work
response:
{
"thoughts": I walk to the living room. I find the computer and turn it on. I look at the computer screen. I move and click the mouse to select buttons on the screen.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[PUSH] <mouse>', '[FIND] <button>', '[PUSH] <button>']
}
|
Scene_Objects:['food_pizza', 'filing_cabinet', 'crayon', 'walllamp', 'bathroom', 'toothbrush', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'faucet', 'electric_shaver', 'dish_soap', 'broom', 'wall', 'oven', 'bench', 'photoframe', 'light_bulb', 'novel', 'coffe_maker', 'television', 'tray', 'towel_rack', 'kettle', 'dishrack', 'table', 'dishwasher', 'tooth_paste']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <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:['filing_cabinet', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'bowl', 'wall', 'powersocket', 'cup', 'novel', 'coffe_maker', 'food_donut', 'doorjamb', 'mouse', 'dresser', 'light']
Task:Read book
response:
{
"thoughts": Walk to the living room. Find a desk and grab a book. Walk to the chair, sit in the chair and read a book.,
"actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']
}
|
Scene_Objects:['fork', 'pot', 'filing_cabinet', 'beer', 'bathroom', 'detergent', 'trashcan', 'cpuscreen', 'ceiling', 'bedroom', 'desk', 'keyboard', 'clothes_jacket', 'tvstand', 'couch', 'pillow', 'food_kiwi', 'oven', 'bench', 'coffe_maker', 'oven_mitts', 'towel_rack', 'pencil', 'cupboard', 'hair', 'clothes_dress', 'food_steak', 'napkin', 'vase', 'laser_pointer']
Task:Listen to music
response:
| {
"thoughts": "I walk into the bedroom. I walk to stereo. I turn on stereo.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <stereo>",
"[SWITCHON] <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:['spectacles', 'glue', 'filing_cabinet', 'microwave', 'jelly', 'freezer', 'ceilingfan', 'orchid', 'food_egg', 'floor', 'phone', 'ceiling', 'desk', 'thread', 'mat', 'laptop', 'deck_of_cards', 'faucet', 'foundation', 'pillow', 'nightstand', 'powersocket', 'basket_for_clothes', 'food_food', 'lighter', 'sink', 'home_office', 'vase', 'soap', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine.,
"actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['pot', 'toilet', 'detergent', 'hanger', 'floor', 'phone', 'stamp', 'toaster', 'balanceball', 'oil', 'pillow', 'dining_room', 'wall_clock', 'toy', 'newspaper', 'keys', 'photoframe', 'food_food', 'clothes_gloves', 'rag', 'doorjamb', 'mouse', 'dishrack', 'dresser', 'cupboard', 'hairdryer', 'spoon', 'table', 'light', 'scrabble']
Task:Pet cat
response:
| {
"thoughts": "Pet Cat",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[WALK] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'food_pizza', 'juice', 'toilet', 'freezer', 'blow_dryer', 'walllamp', 'ceilingfan', 'knifeblock', 'bathroom_counter', 'alcohol', 'button', 'stereo', 'form', 'towel', 'oven', 'basket_for_clothes', 'photoframe', 'light_bulb', 'toilet_paper', 'toothbrush_holder', 'kitchen_counter', 'shoes', 'chessboard', 'vacuum_cleaner', 'clothes_scarf', 'home_office', 'dishwasher', 'soap', 'shoe_rack']
Task:Wash hands
response:
{
"thoughts": I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel.,
"actions": ['[WALK] <dining_room>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[FIND] <towel>', '[RINSE] <towel>']
}
|
Scene_Objects:['sheets', 'spectacles', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'form', 'pillow', 'wall', 'oven', 'box', 'newspaper', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'pencil', 'cupboard', 'maindoor', 'table', 'dishwasher']
Task:Change TV channel
response:
| {
"thoughts": "Walk to living room. Walk to and sit at the sofa. Grab remote control and switch on TV.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'mop', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'envelope', 'faucet', 'picture', 'homework', 'window', 'mousepad', 'clothes_hat', 'towel', 'wall', 'photoframe', 'hands_both', 'food_food', 'doorjamb', 'kettle', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'vase', 'teeth']
Task:Wash teeth
response:
{
"thoughts": I need to rinse my dentures off and put them back in my mouth.,
"actions": ['[WALK] <bathroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <teeth>', '[GRAB] <teeth>', '[WASH] <teeth>', '[PUTOBJBACK] <teeth>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <towel>', '[SWITCHOFF] <light>']
}
|
Scene_Objects:['spectacles', 'pot', 'fork', 'tablelamp', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'toaster', 'plate', 'tvstand', 'dish_soap', 'food_noodles', 'bowl', 'wall', 'pasta', 'oven', 'box', 'coffe_maker', 'television', 'ice', 'tray', 'curtain', 'console', 'towel_rack', 'pencil', 'maindoor', 'sink', 'instrument_guitar', 'dishwasher']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Wash a plate using the dishwasher in the kitchen.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <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:['food_salt', 'freezer', 'ceilingfan', 'clothes_underwear', 'bathroom_counter', 'phone', 'keyboard', 'computer', 'table_cloth', 'mop_bucket', 'tvstand', 'mousepad', 'candle', 'clothes_pants', 'basket_for_clothes', 'cup', 'bed', 'food_food', 'curtain', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'controller', 'clothes_dress', 'clothes_scarf', 'light', 'soap', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": I need to get the dirty clothes basket. Walk to bathroom. Put all the clothes in washing machine. Add soap. Turn on machine.,
"actions": ['[WALK] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['filing_cabinet', 'cat', 'ceilingfan', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'dvd_player', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'foundation', 'oil', 'couch', 'towel', 'wall', 'pasta', 'powersocket', 'television', 'curtain', 'doorjamb', 'shoes', 'pajamas', 'maindoor', 'table']
Task:Change TV channel
response:
| {
"thoughts": "I go to the livingroom. The TV is on. I pick up the remote and press the next channel button. I look at the television, and see that the channel has changed.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <button>",
"[PUSH] <button>",
"[TURNTO] <television>",
"[LOOKAT] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'beer', 'measuring_cup', 'microwave', 'dog', 'orchid', 'wallshelf', 'floor', 'bedroom', 'computer', 'mop_bucket', 'ceilinglamp', 'faucet', 'electric_shaver', 'couch', 'food_peanut_butter', 'broom', 'cutting_board', 'photoframe', 'newspaper', 'mouthwash', 'ice', 'tray', 'curtain', 'kitchen_counter', 'shoes', 'headset', 'bathroom_cabinet', 'board_game']
Task:Pet cat
response:
{
"thoughts": I walk to my living room, find my cat, scrub it using my hand.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>']
}
|
Scene_Objects:['fork', 'mop', 'freezer', 'food_carrot', 'knifeblock', 'drawing', 'cpuscreen', 'phone', 'envelope', 'computer', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'foundation', 'candle', 'dining_room', 'bench', 'toy', 'cup', 'bed', 'tray', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'cupboard', 'clothes_scarf', 'bathroom_cabinet', 'light', 'table', 'home_office']
Task:Pick up phone
response:
| {
"thoughts": "Walk to the entrance hall. Find the telephone. Grab the telephone.",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>",
"[WALK] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['mop', 'microwave', 'cd_player', 'walllamp', 'drawing', 'orchid', 'bills', 'floor', 'ceiling', 'desk', 'tea_bag', 'button', 'piano_bench', 'stovefan', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'ice', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'door', 'bathtub', 'home_office', 'table', 'light']
Task:Listen to music
response:
{
"thoughts": Walk to living room, walk to cd player, turn on cd player, press play button, walk to sofa, sit in sofa and listen to music,
"actions": ['[WALK] <home_office>', '[WALK] <cd_player>', '[SWITCHON] <cd_player>', '[FIND] <button>', '[PUSH] <button>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['sheets', 'tablelamp', 'food_salt', 'microwave', 'ceilingfan', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'keyboard', 'toaster', 'mat', 'balanceball', 'stereo', 'window', 'microphone', 'bench', 'basket_for_clothes', 'clothes_gloves', 'check', 'oven_mitts', 'kettle', 'dresser', 'cupboard', 'maindoor', 'napkin', 'light', 'clothes_skirt', 'washing_machine', 'shoe_rack']
Task:Wash clothes
response:
| {
"thoughts": "Wash the clothes in the washing machine",
"actions": [
"[WALK] <bathroom>",
"[WALK] <basket_for_clothes>",
"[FIND] <basket_for_clothes>",
"[GRAB] <basket_for_clothes>",
"[FIND] <washing_machine>",
"[OPEN] <washing_machine>",
"[PUTBACK] <basket_for_clothes> <washing_machine>",
"[FIND] <washing_machine>",
"[CLOSE] <washing_machine>",
"[SWITCHON] <washing_machine>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'mop', 'ground_coffee', 'cat', 'floor', 'ceiling', 'envelope', 'stovefan', 'mat', 'tvstand', 'stereo', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'cutting_board', 'check', 'coffe_maker', 'television', 'video_game_controller', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'chessboard', 'dresser', 'door', 'table', 'colander']
Task:Pet cat
response:
{
"thoughts": walk to entrance hall, look at the sofa, sit on the sofa, look at the cat, allow cat to near with you, touch the cat smoothly on it head, now pet the cat smoothly,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['sheets', 'glue', 'microwave', 'bathroom', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'purse', 'food_bacon', 'ceilinglamp', 'plate', 'laptop', 'deck_of_cards', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'spoon', 'home_office', 'table', 'teeth']
Task:Relax on sofa
response:
| {
"thoughts": "I walk to the sofa, and lie down on the sofa.",
"actions": [
"[WALK] <couch>",
"[LIE] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'measuring_cup', 'walllamp', 'knifeblock', 'knife', 'drawing', 'floor', 'ceiling', 'character', 'toaster', 'mat', 'plate', 'shower', 'dish_soap', 'clothes_socks', 'wall', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dishrack', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'instrument_guitar', 'dishwasher', 'bathtub']
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:['spectacles', 'food_ice_cream', 'beer', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'detergent', 'trashcan', 'longboard', 'floor', 'ceiling', 'phone', 'bookshelf', 'ceilinglamp', 'stereo', 'homework', 'oil', 'wall', 'cup', 'food_food', 'check', 'television', 'coffee_filter', 'curtain', 'diary', 'cupboard', 'conditioner', 'sink', 'bag']
Task:Put groceries in Fridge
response:
| {
"thoughts": "I walk to the kitchen, open the fridge and put the groceries in the fridge. Then I close the fridge.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'ground_coffee', 'walllamp', 'milk', 'cpuscreen', 'ceiling', 'phone', 'keyboard', 'stovefan', 'plate', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'wine', 'tray', 'food_onion', 'mouse', 'kitchen_counter', 'headset', 'comb', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher']
Task:Get out dish
response:
{
"thoughts": Open cupboard. Get out the dish.,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[OPEN] <cupboard>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <cupboard>']
}
|
Scene_Objects:['sheets', 'tablelamp', 'detergent', 'ceilingfan', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'food_cake', 'clothes_jacket', 'button', 'laptop', 'tvstand', 'mat', 'dustpan', 'food_food', 'after_shave', 'towel_rack', 'pencil', 'kitchen_counter', 'laundry_detergent', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'table', 'vase', 'washing_machine', 'coffee']
Task:Wash clothes
response:
| {
"thoughts": "\"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\"",
"actions": [
"[WALK] <home_office>",
"[WALK] <bedroom>",
"[WALK] <basket_for_clothes>",
"[FIND] <basket_for_clothes>",
"[GRAB] <basket_for_clothes>",
"[WALK] <dining_room>",
"[WALK] <washing_machine>",
"[FIND] <washing_machine>",
"[OPEN] <washing_machine>",
"[PUTBACK] <basket_for_clothes> <washing_machine>",
"[FIND] <laundry_detergent>",
"[GRAB] <laundry_detergent>",
"[PUTBACK] <laundry_detergent> <washing_machine>",
"[CLOSE] <washing_machine>",
"[TURNTO] <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:['spectacles', 'tea', 'ground_coffee', 'walllamp', 'hanger', 'longboard', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'mousepad', 'candle', 'wall', 'nightstand', 'powersocket', 'keys', 'novel', 'coffe_maker', 'clothes_gloves', 'coffee_filter', 'water', 'ice', 'tray', 'food_onion', 'cupboard', 'door', 'light', 'dishwasher', 'soap']
Task:Make coffee
response:
{
"thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['mop', 'microwave', 'toilet', 'band-aids', 'food_butter', 'ceilingfan', 'character', 'bedroom', 'desk', 'stovefan', 'form', 'dining_room', 'bench', 'cutting_board', 'basket_for_clothes', 'clothes_gloves', 'check', 'water', 'tray', 'curtain', 'towel_rack', 'coffee_pot', 'mouse', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'door', 'vase', 'soap', 'dirt']
Task:Wash hands
response:
| {
"thoughts": "put soap on hands, scrub it and rinse with water",
"actions": [
"[WALK] <bathroom>",
"[WALK] <soap>",
"[FIND] <soap>",
"[SCRUB] <soap>",
"[FIND] <water>",
"[RINSE] <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', 'bills', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'bookshelf', 'brush', 'ceilinglamp', 'tvstand', 'stereo', 'stovefan', 'mat', 'mousepad', 'wall', 'powersocket', 'bed', 'television', 'doorjamb', 'dresser', 'clothes_scarf', 'light', 'dishwasher', 'table', 'colander', 'clothes_shirt']
Task:Turn on light
response:
{
"thoughts": Walk to the Living Room. Switch on 1 light. Walk to dining room. Switch on 1 light. Walk to Entrance hall. Switch on 1 light.,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <dining_room>', '[WALK] <home_office>']
}
|
Scene_Objects:['filing_cabinet', 'crayon', 'microwave', 'toilet', 'dog', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'desk', 'computer', 'toaster', 'plate', 'faucet', 'deck_of_cards', 'dish_soap', 'form', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'toy', 'photoframe', 'towel_rack', 'cupboard', 'sink', '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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'hanger', 'floor', 'ceiling', 'phone', 'ceilinglamp', 'tvstand', 'stereo', 'electric_shaver', 'food_noodles', 'form', 'bowl', 'wall', 'nightstand', 'cup', 'check', 'toothbrush_holder', 'after_shave', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'light', 'board_game', 'clothes_shirt']
Task:Put on coat
response:
{
"thoughts": Open closet and grab coat. Put on coat and fasten the front closed. Close closet.,
"actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>']
}
|
Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'drawing', 'keyboard', 'bookmark', 'stovefan', 'ceilinglamp', 'stereo', 'shower', 'foundation', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'bed', 'check', 'television', 'wine', 'curtain', 'towel_rack', 'vacuum_cleaner', 'maindoor', 'door', 'dishwasher', 'vase']
Task:Pick up phone
response:
| {
"thoughts": "Enter living room. Walk to telephone. Pick up from hook.",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_pizza', 'filing_cabinet', 'microwave', 'chair', 'bathroom', 'orchid', 'character', 'desk', 'bedroom', 'thread', 'computer', 'brush', 'ceilinglamp', 'faucet', 'stereo', 'closetdrawer', 'dining_room', 'wall', 'pasta', 'toy', 'cup', 'standingmirror', 'television', 'wine', 'doorjamb', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'clothes_shirt']
Task:Open door
response:
{
"thoughts": Open the door when leaving or coming in.,
"actions": ['[WALK] <home_office>']
}
|
Scene_Objects:['sponge', 'pot', 'food_pizza', 'bathroom', 'trashcan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'alcohol', 'mop_bucket', 'ceilinglamp', 'window', 'electric_shaver', 'couch', 'food_kiwi', 'wall', 'broom', 'nightstand', 'toilet_paper', 'television', 'tray', 'mouse', 'dishrack', 'cupboard', 'home_office', 'table', 'instrument_violin']
Task:Relax on sofa
response:
| {
"thoughts": "lie in the sofa, relax",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[LIE] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_oatmeal', 'microwave', 'freezer', 'bathroom', 'nail_polish', 'dough', 'food_carrot', 'orchid', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'brush', 'mat', 'couch', 'pillow', 'food_cereal', 'wall', 'food_vegetable', 'food_food', 'television', 'console', 'cards', 'kitchen_counter', 'cupboard', 'hair', 'door', 'light']
Task:Put groceries in Fridge
response:
{
"thoughts": Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge.,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_vegetable> <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTIN] <food_carrot> <freezer>', '[FIND] <food_cereal>', '[GRAB] <food_cereal>', '[PUTIN] <food_cereal> <freezer>', '[FIND] <food_oatmeal>', '[GRAB] <food_oatmeal>', '[PUTIN] <food_oatmeal> <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[FIND] <freezer>', '[CLOSE] <freezer>']
}
|
Scene_Objects:['sponge', 'spectacles', 'filing_cabinet', 'blender', 'ceilingfan', 'drawing', 'orchid', 'floor', 'purse', 'computer', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'window', 'clothes_socks', 'couch', 'food_jam', 'wall', 'pasta', 'bench', 'television', 'wine', 'mouse', 'pencil', 'dresser', 'door', 'table', 'dishwasher', 'light']
Task:Relax on sofa
response:
| {
"thoughts": "Walk to living room. Sit on sofa. Lie down on sofa.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[LIE] <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:['pot', 'scissors', 'ceilingfan', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'food_kiwi', 'wall', 'oven', 'powersocket', 'cup', 'light_bulb', 'novel', 'television', 'tray', 'curtain', 'after_shave', 'kitchen_counter', 'dresser', 'table', 'light']
Task:Watch TV
response:
{
"thoughts": walk to living room, find couch, sit on couch, find remote control , turn on tv by pressing button,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>']
}
|
Scene_Objects:['water_glass', 'food_pizza', 'pot', 'microwave', 'bathroom', 'bills', 'knifeblock', 'cpuscreen', 'drawing', 'longboard', 'floor', 'phone', 'folder', 'bedroom', 'keyboard', 'mail', 'food_bacon', 'piano_bench', 'button', 'table_cloth', 'shower', 'couch', 'dining_room', 'wall', 'powersocket', 'cutting_board', 'water', 'tray', 'pencil', 'door']
Task:Drink
response:
| {
"thoughts": "Drinking a glass of water",
"actions": [
"[WALK] <dining_room>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[FIND] <water_glass>",
"[POUR] <water> <water_glass>",
"[FIND] <water_glass>",
"[GRAB] <water_glass>",
"[DRINK] <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:['pot', 'tablelamp', 'microwave', 'chair', 'toothbrush', 'drawing', 'floor', 'ceiling', 'computer', 'toaster', 'stovefan', 'mat', 'shower', 'faucet', 'couch', 'wall', 'oven', 'cup', 'coffe_maker', 'food_food', 'mouthwash', 'drinking_glass', 'wine', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'pajamas', 'sink', 'dishwasher']
Task:Drink
response:
{
"thoughts": First I go into the kitchen, open the cupboard and find a glass.Then I close the cupboard. Then I go to the sink, turn the faucet on fill the glass under the faucet. I turn off the faucet and then I drink.,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>']
}
|
Scene_Objects:['sheets', 'filing_cabinet', 'chair', 'ground_coffee', 'bathroom', 'detergent', 'bathroom_counter', 'bedroom', 'bookshelf', 'button', 'toaster', 'mat', 'ceilinglamp', 'window', 'mousepad', 'couch', 'dining_room', 'photoframe', 'bed', 'novel', 'coffe_maker', 'food_food', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'sink', 'dishwasher', 'clothes_skirt', 'soap']
Task:Pick up phone
response:
| {
"thoughts": "walk to living room , find phone ,pick up phone 3",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'band-aids', 'drawing', 'cpuscreen', 'hanger', 'floor', 'computer', 'ceilinglamp', 'balanceball', 'window', 'oil', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'coffe_maker', 'toilet_paper', 'television', 'kitchen_counter', 'chessboard', 'home_office', 'table', 'bathroom_cabinet', 'vase', 'light', 'coffee']
Task:Relax on sofa
response:
{
"thoughts": Sitting down and relaxing on the sofa,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['crayon', 'microwave', 'blow_dryer', 'cat', 'milk', 'bathroom_counter', 'phone', 'food_cake', 'computer', 'stovefan', 'balanceball', 'homework', 'couch', 'clothes_hat', 'bench', 'oven', 'powersocket', 'cup', 'newspaper', 'coffe_maker', 'tray', 'wooden_spoon', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'cd', 'cupboard', 'laundry_detergent', 'door']
Task:Pet cat
response:
| {
"thoughts": "Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food.",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <cat>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[WALK] <milk>",
"[FIND] <milk>",
"[GRAB] <milk>",
"[POUR] <milk> <cup>",
"[TURNTO] <cat>",
"[POINTAT] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'freezer', 'walllamp', 'detergent', 'bills', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'shower', 'faucet', 'closetdrawer', 'microphone', 'dining_room', 'pasta', 'mouthwash', 'mouse', 'pencil', 'dresser', 'pajamas', 'controller', 'sink', 'napkin', 'home_office', 'dishwasher', 'soap']
Task:Switch on lamp
response:
{
"thoughts": Press the button so the light comes on.,
"actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}
|
Scene_Objects:['water_glass', 'pot', 'walllamp', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'clothes_jacket', 'stovefan', 'tvstand', 'faucet', 'mousepad', 'food_jam', 'broom', 'wall', 'nightstand', 'clothes_gloves', 'food_food', 'razor', 'water', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', 'napkin']
Task:Drink
response:
| {
"thoughts": "I go to the kitchen, take a glass from the cupboard, fill with water and drink",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <water_glass>",
"[GRAB] <water_glass>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <water_glass>",
"[DRINK] <water_glass>",
"[RINSE] <water_glass>",
"[PUTBACK] <water_glass> <cupboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'needle', 'cpuscreen', 'floor', 'character', 'keyboard', 'table_cloth', 'plate', 'faucet', 'window', 'oil', 'mousepad', 'pillow', 'wall', 'oven', 'food_cheese', 'bed', 'tray', 'kettle', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'home_office', 'light']
Task:Wash dishes by hand
response:
{
"thoughts": Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry.,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[TURNTO] <plate>', '[LOOKAT] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WASH] <plate>', '[PUTBACK] <plate> <kitchen_counter>']
}
|
Scene_Objects:['pot', 'tablelamp', 'walllamp', 'bathroom', 'cat', 'ceilingfan', 'knifeblock', 'phone', 'character', 'brush', 'toaster', 'mat', 'faucet', 'ceilinglamp', 'shower', 'window', 'couch', 'wall_clock', 'cup', 'newspaper', 'food_onion', 'lighter', 'towel_rack', 'mouse', 'kitchen_counter', 'headset', 'cupboard', 'table', 'vase', 'laser_pointer']
Task:Pet cat
response:
| {
"thoughts": "Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner.",
"actions": [
"[WALK] <home_office>",
"[WALK] <bedroom>",
"[WALK] <bedroom>",
"[WALK] <home_office>",
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[FIND] <brush>",
"[GRAB] <brush>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'dresser', 'sink', 'instrument_violin']
Task:Watch TV
response:
{
"thoughts": I go to the the living room, sit down on the sofa, and then I switch on the TV with the TV remote,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['spectacles', 'pot', 'freezer', 'walllamp', 'detergent', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'stamp', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'couch', 'food_peanut_butter', 'form', 'pillow', 'wall', 'bench', 'novel', 'food_food', 'oven_mitts', 'food_rice', 'diary', 'towel_rack', 'controller', 'maindoor', 'light', 'clothes_skirt']
Task:Put groceries in Fridge
response:
| {
"thoughts": "Walk to kitchen. Find groceries. Grab groceries. Find fridge. Walk to fridge. Put groceries in fridge.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[FIND] <freezer>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[PUTIN] <food_food> <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'stovefan', 'mat', 'tvstand', 'window', 'closetdrawer', 'microphone', 'food_orange', 'pillow', 'wall', 'nightstand', 'bed', 'food_rice', 'curtain', 'kettle', 'dresser', 'pajamas', 'bathtub', 'bathroom_cabinet', 'table', 'vase']
Task:Go to sleep
response:
{
"thoughts": Enter bedroom, turn on the light, and shut door. Change into night clothes. Turn off light. Turn down comforter, climb into bed, lay head on pillow, and cover up with comforter. Close eyes and drift off to sleep.,
"actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <sheets>', '[PULL] <sheets>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'food_food', 'doorjamb', 'mouse', 'shoes', 'door', 'home_office', 'light', 'dishwasher']
Task:Work
response:
| {
"thoughts": "I walk to the living room. I find the computer and turn it on. I look at the computer screen. I move and click the mouse to select buttons on the screen.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <mouse>",
"[PUSH] <mouse>",
"[FIND] <button>",
"[PUSH] <button>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'tablelamp', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'pillow', 'wall', 'nightstand', 'bench', 'food_food', 'doorjamb', 'kettle', 'mouse', 'pencil', 'headset', 'light']
Task:Browse internet
response:
{
"thoughts": go to the office, turn computer on, open an browser or any application to open any website.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <computer>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'detergent', 'orchid', 'food_egg', 'hanger', 'bathroom_counter', 'floor', 'phone', 'brush', 'tvstand', 'foundation', 'couch', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'cutting_board', 'food_cheese', 'coffe_maker', 'food_food', 'toothbrush_holder', 'wine', 'tray', 'mouse', 'laundry_detergent', 'home_office', 'table', 'washing_machine', 'creditcard']
Task:Wash clothes
response:
| {
"thoughts": "Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <washing_machine>",
"[FIND] <washing_machine>",
"[OPEN] <washing_machine>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[PUTBACK] <clothes_pants> <washing_machine>",
"[WALK] <laundry_detergent>",
"[FIND] <laundry_detergent>",
"[GRAB] <laundry_detergent>",
"[POUR] <laundry_detergent> <washing_machine>",
"[CLOSE] <washing_machine>",
"[PLUGIN] <washing_machine>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'detergent', 'food_butter', 'clothes_underwear', 'hanger', 'floor', 'stamp', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'shoe-shine_kit', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_pants', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'vacuum_cleaner', 'laundry_detergent', 'clothes_dress', 'bathroom_cabinet', 'light', 'dishwasher', 'clothes_shirt', 'washing_machine', 'creditcard']
Task:Wash clothes
response:
{
"thoughts": I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine.,
"actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[DROP] <basket_for_clothes>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[GRAB] <laundry_detergent>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['food_bread', 'scissors', 'chair', 'bathroom', 'detergent', 'cat', 'ceilingfan', 'dough', 'knifeblock', 'hanger', 'floor', 'ceiling', 'character', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'microphone', 'wall', 'oven', 'coffe_maker', 'tray', 'curtain', 'lighter', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'dishwasher']
Task:Pet cat
response:
| {
"thoughts": "Find a cat in the kitchen and touch it",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cat>",
"[FIND] <cat>",
"[WALK] <cat>",
"[TOUCH] <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:['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:['food_salt', 'beer', 'measuring_cup', 'freezer', 'ground_coffee', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'envelope', 'computer', 'toaster', 'stereo', 'wall', 'photoframe', 'light_bulb', 'novel', 'coffe_maker', 'coffee_filter', 'water', 'wine', 'curtain', 'doorjamb', 'coffee_pot', 'dresser', 'dishwasher', 'soap']
Task:Make coffee
response:
| {
"thoughts": "Making Coffee",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[FIND] <water>",
"[GRAB] <water>",
"[OPEN] <coffe_maker>",
"[POUR] <water> <coffe_maker>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[FIND] <coffee_pot>",
"[GRAB] <coffee_pot>",
"[PUTBACK] <coffee_pot> <coffe_maker>",
"[SWITCHON] <coffe_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:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light']
Task:Greet guests
response:
{
"thoughts": Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,
"actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']
}
|
Scene_Objects:['glue', 'crayon', 'microwave', 'food_butter', 'drawing', 'knifeblock', 'floor', 'bedroom', 'envelope', 'stovefan', 'ceilinglamp', 'mat', 'balanceball', 'window', 'couch', 'clothes_hat', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'television', 'after_shave', 'cards', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'hairdryer', 'spoon', 'table', 'light']
Task:Relax on sofa
response:
| {
"thoughts": "Walk to the living room. Walk to the sofa and sit on the sofa.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[SIT] <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:['pot', 'jelly', 'chair', 'freezer', 'bathroom', 'food_carrot', 'knifeblock', 'bathroom_counter', 'keyboard', 'alcohol', 'clothes_jacket', 'stovefan', 'mat', 'toaster', 'stereo', 'picture', 'ceilinglamp', 'dining_room', 'bowl', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'check', 'video_game_controller', 'razor', 'food_food', 'curtain', 'shoes']
Task:Listen to music
response:
{
"thoughts": turn radio on, listen to music,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['fork', 'food_ice_cream', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'couch', 'wall', 'wall_clock', 'basket_for_clothes', 'bed', 'food_food', 'television', 'curtain', 'hairbrush', 'controller', 'bathroom_cabinet', 'table', 'vase']
Task:Watch TV
response:
| {
"thoughts": "Walk to living room, walk to TV, grab TV remote, turn on TV, put down the remote, walk to sofa, sit in soft, watch TV",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[SWITCHON] <television>",
"[PUTOBJBACK] <remote_control>",
"[WALK] <couch>",
"[SIT] <couch>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'band-aids', 'bathroom', 'cat', 'orchid', 'wallshelf', 'hanger', 'floor', 'phone', 'character', 'bedroom', 'purse', 'computer', 'table_cloth', 'tvstand', 'powersocket', 'toy', 'clothes_gloves', 'coffe_maker', 'razor', 'food_onion', 'centerpiece', 'headset', 'chessboard', 'cupboard', 'door', 'home_office', 'table', 'laser_pointer']
Task:Open door
response:
{
"thoughts": I walk up to the door. I use my hand to turn the door knob to the left. I pull the door open with the same hand I used to turn the door knob,
"actions": ['[RUN] <home_office>']
}
|
Scene_Objects:['pot', 'chair', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'piano_bench', 'table_cloth', 'brush', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'nightstand', 'oven', 'mouthwash', 'television', 'wine', 'curtain', 'doorjamb', 'mouse', 'dishrack', 'table', 'clothes_skirt']
Task:Watch TV
response:
| {
"thoughts": "go to the living room to watch TV",
"actions": [
"[RUN] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[TURNTO] <television>",
"[POINTAT] <television>",
"[TOUCH] <remote_control>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[WATCH] <television>",
"[DROP] <remote_control>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'ceilingfan', 'trashcan', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bookshelf', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'food_noodles', 'couch', 'wall', 'nightstand', 'food_food', 'television', 'curtain', 'cupboard', 'table', 'light', 'vase', 'dishwasher', 'dirt']
Task:Watch TV
response:
{
"thoughts": Sit on the couch or the chair or the floor and watch cable, movies, or netflix.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['blender', 'food_salt', 'beer', 'cpuscreen', 'desk', 'toaster', 'ceilinglamp', 'stovefan', 'tvstand', 'faucet', 'homework', 'floor_lamp', 'window', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'cutting_board', 'cup', 'bed', 'novel', 'coffe_maker', 'food_rice', 'ice', 'dresser', 'cupboard', 'laundry_detergent', 'bathroom_cabinet', 'tooth_paste', 'shoe_rack']
Task:Read book
response:
| {
"thoughts": "Turn a light on and read a book in the bedroom.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <floor_lamp>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'tablelamp', 'food_salt', 'chair', 'walllamp', 'detergent', 'drawing', 'clothes_underwear', 'floor', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'food_noodles', 'garbage_can', 'mousepad', 'microphone', 'wall', 'nightstand', 'food_vegetable', 'bed', 'food_food', 'coffee_filter', 'mouse', 'sink', 'home_office', 'table', 'dishwasher', 'pantry']
Task:Organize pantry
response:
{
"thoughts": Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.,
"actions": ['[WALK] <dining_room>', '[WALK] <pantry>', '[FIND] <food_food>', '[GRAB] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[FIND] <garbage_can>', '[PUTBACK] <food_food> <garbage_can>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <dry_pasta>', '[GRAB] <dry_pasta>', '[TURNTO] <dry_pasta>', '[LOOKAT] <dry_pasta>', '[PUTOBJBACK] <dry_pasta>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[PUSH] <food_food>', '[FIND] <food_noodles>', '[GRAB] <food_noodles>', '[TURNTO] <food_noodles>', '[LOOKAT] <food_noodles>', '[PUTOBJBACK] <food_noodles>']
}
|
Scene_Objects:['filing_cabinet', 'chair', 'dog', 'blow_dryer', 'toothbrush', 'orchid', 'clothes_underwear', 'hanger', 'bathroom_counter', 'ceiling', 'purse', 'food_bacon', 'toaster', 'ceilinglamp', 'shower', 'clothes_socks', 'mousepad', 'oil', 'clothes_pants', 'microphone', 'pillow', 'pajamas', 'controller', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'dishwasher', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
| {
"thoughts": "I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <basket_for_clothes>",
"[FIND] <basket_for_clothes>",
"[GRAB] <basket_for_clothes>",
"[WALK] <washing_machine>",
"[DROP] <basket_for_clothes>",
"[OPEN] <washing_machine>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[PUTBACK] <clothes_pants> <washing_machine>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUTBACK] <clothes_shirt> <washing_machine>",
"[FIND] <clothes_underwear>",
"[GRAB] <clothes_underwear>",
"[PUTBACK] <clothes_underwear> <washing_machine>",
"[FIND] <clothes_socks>",
"[GRAB] <clothes_socks>",
"[PUTBACK] <clothes_socks> <washing_machine>",
"[FIND] <laundry_detergent>",
"[GRAB] <laundry_detergent>",
"[PUTBACK] <laundry_detergent> <washing_machine>",
"[GRAB] <laundry_detergent>",
"[PUTOBJBACK] <laundry_detergent>",
"[CLOSE] <washing_machine>",
"[SWITCHON] <washing_machine>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'cat', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'tooth_paste', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'coin', 'doorjamb', 'dresser', 'board_game']
Task:Watch TV
response:
{
"thoughts": Watch TV in the living room.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['food_pizza', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'dough', 'ceiling', 'character', 'computer', 'stovefan', 'toaster', 'tvstand', 'oil', 'pillow', 'pasta', 'powersocket', 'cup', 'bed', 'novel', 'food_food', 'mouthwash', 'curtain', 'rag', 'towel_rack', 'cupboard', 'controller', 'door', 'spoon', 'home_office', 'table']
Task:Listen to music
response:
| {
"thoughts": "I walk into the living room. I find the stereo and turn it on, and I listen to the music.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'chair', 'ground_coffee', 'bathroom', 'detergent', 'bathroom_counter', 'bedroom', 'bookshelf', 'button', 'toaster', 'mat', 'ceilinglamp', 'window', 'mousepad', 'couch', 'dining_room', 'photoframe', 'bed', 'novel', 'coffe_maker', 'food_food', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'sink', 'dishwasher', 'clothes_skirt', 'soap']
Task:Pick up phone
response:
{
"thoughts": walk to living room , find phone ,pick up phone 3,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>']
}
|
Scene_Objects:['pot', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'phone', 'tea_bag', 'computer', 'button', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'couch', 'clothes_hat', 'wall', 'oven', 'bench', 'television', 'curtain', 'vacuum_cleaner', 'dresser', 'maindoor', 'spoon', 'home_office', 'table']
Task:Watch TV
response:
| {
"thoughts": "walk to living room, find the television, switch on the television, find the sofa, walk to sofa, sit in sofa, watch the television",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <couch>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'blow_dryer', 'cat', 'toothbrush', 'orchid', 'floor', 'keyboard', 'mat', 'ceilinglamp', 'shoe-shine_kit', 'picture', 'window', 'mousepad', 'couch', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'shelf', 'photoframe', 'television', 'ice', 'curtain', 'after_shave', 'doorjamb', 'diary', 'vacuum_cleaner', 'conditioner', 'home_office', 'table']
Task:Pet cat
response:
{
"thoughts": I would walk into the living room. Then sit on the couch and pet the cat.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['sheets', 'spectacles', 'filing_cabinet', 'walllamp', 'ceilingfan', 'food_carrot', 'toothbrush', 'drawing', 'desk', 'bookshelf', 'stovefan', 'balanceball', 'shower', 'window', 'candle', 'clothes_pants', 'food_orange', 'dining_room', 'bench', 'bed', 'keys', 'food_food', 'diary', 'mouse', 'shoes', 'sink', 'vase', 'tooth_paste', 'scrabble', 'teeth']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'walllamp', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'window', 'toaster', 'clothes_pants', 'broom', 'powersocket', 'bench', 'bed', 'check', 'food_food', 'coffe_maker', 'after_shave', 'dresser', 'hair', 'door', 'sink', 'clothes_shirt']
Task:Get dressed
response:
{
"thoughts": Get some clothes together that make an appropriate outfit. Put them on,
"actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>']
}
|
Scene_Objects:['jelly', 'trashcan', 'food_carrot', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'keyboard', 'bookshelf', 'mop_bucket', 'tvstand', 'iron', 'oil', 'food_noodles', 'mousepad', 'dustpan', 'towel', 'nightstand', 'cup', 'light_bulb', 'razor', 'food_donut', 'rag', 'shaving_cream', 'towel_rack', 'pencil', 'kitchen_counter', 'bag', 'bathroom_cabinet', 'dishwasher']
Task:Listen to music
response:
| {
"thoughts": "I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'freezer', 'bathroom', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'bookshelf', 'shower', 'homework', 'wall', 'powersocket', 'box', 'bed', 'coffe_maker', 'television', 'after_shave', 'doorjamb', 'towel_rack', 'mouse', 'cards', 'cupboard', 'home_office', 'light', 'dishwasher']
Task:Turn on light
response:
{
"thoughts": Walk into living room. Find wall. Find light button. Switch on light button.,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['tablelamp', 'juice', 'measuring_cup', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'mouse', 'pencil', 'cupboard', 'door', 'maindoor', 'home_office', 'light', 'dishwasher', 'creditcard']
Task:Work
response:
| {
"thoughts": "turn computer on, open application to work with",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'toilet', 'freezer', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'toaster', 'mat', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'bench', 'photoframe', 'coffe_maker', 'food_rice', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'home_office']
Task:Set up table
response:
{
"thoughts": Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.,
"actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>']
}
|
Scene_Objects:['sheets', 'juice', 'band-aids', 'walllamp', 'detergent', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'shower', 'tvstand', 'balanceball', 'dustpan', 'towel', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'dishrack', 'door', 'sink', 'bathroom_cabinet', 'shoe_rack']
Task:Take shower
response:
| {
"thoughts": "Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <bathroom_cabinet>",
"[FIND] <bathroom_cabinet>",
"[OPEN] <bathroom_cabinet>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[CLOSE] <bathroom_cabinet>",
"[FIND] <shower>",
"[RINSE] <shower>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'microwave', 'freezer', 'drawing', 'floor', 'ceiling', 'dvd_player', 'keyboard', 'stovefan', 'mat', 'laptop', 'stereo', 'oil', 'mousepad', 'couch', 'pillow', 'wall', 'food_food', 'television', 'drinking_glass', 'water', 'curtain', 'diary', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'light', 'instrument_violin']
Task:Drink
response:
{
"thoughts": go to the kitchen,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>']
}
|
Scene_Objects:['band-aids', 'walllamp', 'floor', 'keyboard', 'toaster', 'mat', 'plate', 'tvstand', 'stereo', 'window', 'dish_soap', 'couch', 'food_kiwi', 'wall', 'oven', 'bench', 'cup', 'coffe_maker', 'wine', 'tray', 'cards', 'dishrack', 'dresser', 'clothes_dress', 'maindoor', 'spoon', 'napkin', 'dishwasher', 'vase', 'colander']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[WALK] <dishwasher>",
"[OPEN] <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <spoon>",
"[GRAB] <spoon>",
"[PUTBACK] <spoon> <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'blender', 'beer', 'mop', 'chair', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'ceiling', 'keyboard', 'alcohol', 'ceilinglamp', 'faucet', 'window', 'powersocket', 'toy', 'food_cheese', 'check', 'tray', 'console', 'mouse', 'pencil', 'kitchen_counter', 'hairbrush', 'hair', 'food_steak', 'bathtub', 'bathroom_cabinet', 'vase']
Task:Answer door
response:
{
"thoughts": Wait until doorbell rings, look to see who it is outside and open the door if you feel so inclined.,
"actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>']
}
|
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'dog', 'freezer', 'walllamp', 'dough', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'mousepad', 'food_peanut_butter', 'clothes_pants', 'dining_room', 'wall', 'novel', 'coffe_maker', 'coffee_filter', 'water', 'shoes', 'controller', 'dishwasher', 'clothes_shirt', 'coffee']
Task:Make coffee
response:
| {
"thoughts": "Go to the kitchen and make coffee.",
"actions": [
"[RUN] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[OPEN] <coffe_maker>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[FIND] <coffee>",
"[GRAB] <coffee>",
"[POUR] <coffee> <coffe_maker>",
"[PUTOBJBACK] <coffee>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <coffe_maker>",
"[SWITCHON] <coffe_maker>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'spectacles', 'filing_cabinet', 'food_salt', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'character', 'shower', 'stereo', 'microphone', 'wall', 'toy', 'cutting_board', 'cup', 'novel', 'food_food', 'check', 'food_onion', 'coffee_pot', 'console', 'shaving_cream', 'towel_rack', 'shoes', 'cd', 'hairbrush', 'maindoor', 'soap', 'coffee']
Task:Read
response:
{
"thoughts": Read a book in the living room,
"actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[READ] <novel>']
}
|
Scene_Objects:['measuring_cup', 'chair', 'freezer', 'ceilingfan', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookmark', 'ceilinglamp', 'stereo', 'balanceball', 'microphone', 'wall', 'powersocket', 'box', 'cup', 'food_cheese', 'mouthwash', 'television', 'coffee_filter', 'tray', 'doorjamb', 'kitchen_counter', 'hairdryer', 'home_office', 'table', 'vase']
Task:Put groceries in Fridge
response:
| {
"thoughts": "Walk to kitchen. Grab groceries and walk to the fridge. Open fridge and put groceries in the fridge. Close the fridge.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tea', 'toilet', 'jelly', 'band-aids', 'dog', 'walllamp', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'mop_bucket', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'couch', 'food_peanut_butter', 'dining_room', 'wall', 'pasta', 'powersocket', 'nightstand', 'razor', 'food_donut', 'tray', 'chessboard', 'controller', 'laundry_detergent', 'light']
Task:Go to toilet
response:
{
"thoughts": I walk into the bathroom. I walk over to the toilet. I sit on the toilet.,
"actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[SIT] <toilet>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'check', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light']
Task:Work
response:
| {
"thoughts": "you go into your office, switch on the light, find chair at desk, sit in the chair, switch on the computer and work.",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[FIND] <desk>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <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:['sheets', 'crayon', 'chair', 'walllamp', 'bathroom', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'clothes_jacket', 'toaster', 'deck_of_cards', 'faucet', 'mousepad', 'microphone', 'wall', 'tape', 'novel', 'food_food', 'check', 'food_donut', 'tray', 'towel_rack', 'dresser', 'pajamas', 'clothes_dress', 'hairdryer', 'bathroom_cabinet', 'home_office', 'table']
Task:Grab things
response:
{
"thoughts": The robot will need some kind of hands or grabbing device to transport objects.,
"actions": ['[WALK] <novel>', '[TURNTO] <novel>', '[GRAB] <novel>']
}
|
Scene_Objects:['sheets', 'food_pizza', 'chair', 'cat', 'drawing', 'floor', 'tea_bag', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'stovefan', 'window', 'couch', 'food_orange', 'wall', 'food_food', 'television', 'oven_mitts', 'food_onion', 'curtain', 'after_shave', 'comb', 'napkin', 'home_office', 'table', 'dishwasher', 'bathroom_cabinet', 'laser_pointer', 'scrabble']
Task:Relax on sofa
response:
| {
"thoughts": "go to the living room,find the sofa,sat down in the sofa,take some relaxation.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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:['measuring_cup', 'freezer', 'orchid', 'phone', 'clothes_jacket', 'table_cloth', 'mat', 'plate', 'shower', 'clothes_socks', 'food_jam', 'bowl', 'broom', 'nightstand', 'oven', 'cup', 'food_food', 'television', 'after_shave', 'curtain', 'doorjamb', 'mouse', 'dresser', 'clothes_dress', 'maindoor', 'door', 'napkin', 'instrument_guitar', 'home_office', 'light']
Task:Pet cat
response:
| {
"thoughts": "Walk into the living room, sit down by the cat, put out hand, stroke the cat from head to tail",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'chair', 'dog', 'toothbrush', 'drawing', 'bills', 'ceiling', 'folder', 'desk', 'bedroom', 'remote_control', 'button', 'clothes_jacket', 'stovefan', 'mat', 'faucet', 'dining_room', 'broom', 'nightstand', 'wall', 'cutting_board', 'novel', 'mouse', 'kitchen_counter', 'cd', 'pajamas', 'sink', 'bathroom_cabinet', 'home_office']
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:['freezer', 'walllamp', 'ground_coffee', 'knifeblock', 'cpuscreen', 'longboard', 'floor', 'phone', 'bedroom', 'toaster', 'faucet', 'pillow', 'wall', 'bed', 'novel', 'water', 'tray', 'centerpiece', 'cards', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'conditioner', 'sink', 'bag', 'napkin', 'table', 'dishwasher', 'board_game']
Task:Drink
response:
| {
"thoughts": "Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cup>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[WALK] <sink>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <cup>",
"[DRINK] <cup>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'television', 'curtain', 'shaving_cream', 'dresser', 'home_office', 'table', 'bathroom_cabinet', 'shoe_rack']
Task:Watch TV
response:
{
"thoughts": Watch favorite shows, netflix, hulu,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['filing_cabinet', 'food_salt', 'jelly', 'walllamp', 'trashcan', 'hanger', 'longboard', 'floor', 'desk', 'mail', 'toaster', 'plate', 'shower', 'balanceball', 'couch', 'wall', 'oven', 'box', 'cup', 'bed', 'coffe_maker', 'tray', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'vase', 'laser_pointer']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[PUTBACK] <cup> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[GRAB] <cup>",
"[PUTBACK] <cup> <plate>",
"[GRAB] <cup>",
"[PUTBACK] <cup> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'microwave', 'dog', 'chair', 'cat', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'phone', 'character', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'closetdrawer', 'oven', 'food_cheese', 'novel', 'toothbrush_holder', 'television', 'food_donut', 'console', 'controller', 'clothes_scarf', 'light', 'colander', 'board_game', 'creditcard']
Task:Pet cat
response:
{
"thoughts": I walk to my cat, and I pet him,
"actions": ['[WALK] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['microwave', 'toilet', 'chair', 'ceiling', 'toaster', 'ceilinglamp', 'mat', 'shower', 'faucet', 'tvstand', 'deck_of_cards', 'picture', 'clothes_pants', 'food_orange', 'food_kiwi', 'oven', 'bench', 'bed', 'food_food', 'television', 'wine', 'pencil', 'dresser', 'clothes_dress', 'bathroom_cabinet', 'light', 'dishwasher', 'vase', 'table', 'coffee']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'toilet', 'blow_dryer', 'bathroom', 'trashcan', 'orchid', 'dvd_player', 'keyboard', 'mail', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'picture', 'window', 'couch', 'clothes_pants', 'oven', 'photoframe', 'coffe_maker', 'food_food', 'television', 'food_onion', 'coffee_pot', 'sink', 'bathroom_cabinet', 'light', 'dishwasher', 'vase']
Task:Wash dishes with dishwasher
response:
{
"thoughts": grab the vesseles and wash,
"actions": ['[WALK] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dining_room>', '[WASH] <bowl>', '[WALK] <detergent>', '[FIND] <detergent>', '[RINSE] <detergent>']
}
|
Scene_Objects:['dry_pasta', 'food_pizza', 'filing_cabinet', 'scissors', 'chair', 'ceilingfan', 'dough', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'coffee_table', 'television', 'coin', 'wooden_spoon', 'curtain', 'maindoor', 'table']
Task:Watch TV
response:
| {
"thoughts": "I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <coffee_table>",
"[PUTBACK] <remote_control> <coffee_table>",
"[TURNTO] <television>",
"[LOOKAT] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_ice_cream', 'mop', 'tea', 'freezer', 'walllamp', 'floor', 'character', 'stovefan', 'toaster', 'mat', 'tvstand', 'stereo', 'window', 'electric_shaver', 'food_noodles', 'couch', 'soap', 'pillow', 'wall', 'bench', 'toilet_paper', 'food_food', 'doorjamb', 'diary', 'dresser', 'hairbrush', 'napkin', 'bathroom_cabinet', 'colander']
Task:Go to toilet
response:
{
"thoughts": I walk to bathroom. find closet. Uset It. Clean it. Use Toilet paper,
"actions": ['[WALK] <bathroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[CLOSE] <dresser>', '[FIND] <toilet_paper>', '[WASH] <dresser>', '[FIND] <toilet_paper>', '[TOUCH] <toilet_paper>']
}
|
Scene_Objects:['microwave', 'walllamp', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'character', 'toaster', 'mat', 'laptop', 'faucet', 'tvstand', 'couch', 'dining_room', 'wall', 'powersocket', 'tape', 'cup', 'photoframe', 'coffe_maker', 'shaving_cream', 'towel_rack', 'cupboard', 'maindoor', 'sink', 'bag', 'bathroom_cabinet', 'light', 'hands_both']
Task:Wash hands
response:
| {
"thoughts": "Going to the sink and scrubbing hands",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <sink>",
"[FIND] <hands_both>",
"[RINSE] <hands_both>",
"[SCRUB] <hands_both>",
"[RINSE] <hands_both>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'chair', 'freezer', 'detergent', 'trashcan', 'dough', 'clothes_underwear', 'folder', 'stamp', 'bookshelf', 'clothes_jacket', 'table_cloth', 'mousepad', 'couch', 'food_jam', 'clothes_hat', 'pillow', 'nightstand', 'bench', 'oven', 'cutting_board', 'bed', 'food_food', 'check', 'doorjamb', 'console', 'cupboard', 'home_office', 'table']
Task:Pick up phone
response:
{
"thoughts": i go find the phone. i pick up the phone,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['filing_cabinet', 'juice', 'jelly', 'detergent', 'cat', 'bathroom_counter', 'keyboard', 'food_bacon', 'piano_bench', 'faucet', 'window', 'couch', 'candle', 'pillow', 'nightstand', 'tape', 'food_food', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cd', 'cupboard', 'hair', 'door', 'bathroom_cabinet', 'table', 'creditcard']
Task:Pet cat
response:
| {
"thoughts": "Walk into the living room. Walk up to the cat. Pet the cat with your hand.",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'food_pizza', 'juice', 'crayon', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'mat', 'tvstand', 'faucet', 'wall', 'powersocket', 'bench', 'tape', 'photoframe', 'clothes_gloves', 'food_donut', 'after_shave', 'doorjamb', 'dishrack', 'door', 'sink', 'bathroom_cabinet', 'soap']
Task:Clean sink
response:
{
"thoughts": Take a premoistened cleaning wipe and wipe down top of sink and faucet. Next clean the sink bowl. Let air dry.,
"actions": ['[WALK] <bathroom>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[WIPE] <faucet>', '[WIPE] <sink>', '[PUTOBJBACK] <rag>']
}
|
Scene_Objects:['trashcan', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'folder', 'keyboard', 'remote_control', 'alcohol', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'couch', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'curtain', 'food_steak', 'napkin', 'table', 'clothes_shirt', 'creditcard']
Task:Change TV channel
response:
| {
"thoughts": "Take TV remote to change TV Channel. Press channel/program +/- button on TV remote.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <button>",
"[TOUCH] <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:['tablelamp', 'chair', 'freezer', 'dough', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'stovefan', 'mat', 'window', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'coffe_maker', 'curtain', 'doorjamb', 'door', 'sink', 'light', 'laser_pointer']
Task:Read book
response:
{
"thoughts": I go to the bedroom and turn on the light. I lie in bed. I grab my book from the nightstand, and look for the bookmark to check where I last left off. I read for a while. When I'm done, I put the bookmark on the page I stop at and place the book back on the nightstand.,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[READ] <novel>', '[PUTBACK] <bookmark> <novel>', '[FIND] <nightstand>', '[PUTBACK] <novel> <nightstand>']
}
|
Scene_Objects:['food_bread', 'freezer', 'walllamp', 'trashcan', 'food_carrot', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bedroom', 'character', 'ceilinglamp', 'tvstand', 'faucet', 'dustpan', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'photoframe', 'bed', 'food_food', 'television', 'food_donut', 'food_rice', 'doorjamb', 'shaving_cream', 'table', 'vase']
Task:Put groceries in Fridge
response:
| {
"thoughts": "walk to kitchen and seprate the groceries and arrange in fridge.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[PUTIN] <food_food> <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'drawing', 'floor', 'ceiling', 'bedroom', 'alcohol', 'toaster', 'stovefan', 'mat', 'shower', 'faucet', 'deck_of_cards', 'shoe-shine_kit', 'pillow', 'wall', 'oven', 'cup', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'table', 'dishwasher']
Task:Drink
response:
{
"thoughts": Turn on the faucet. Place glass under tap and fill with water. Turn off faucet. Drink water.,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']
}
|
Scene_Objects:['sponge', 'water_glass', 'pot', 'glue', 'walllamp', 'trashcan', 'knifeblock', 'ceiling', 'clothes_jacket', 'stovefan', 'toaster', 'mat', 'faucet', 'microphone', 'wall', 'cup', 'bed', 'food_food', 'check', 'water', 'food_donut', 'curtain', 'kitchen_counter', 'chessboard', 'cupboard', 'laundry_detergent', 'sink', 'spoon', 'bathroom_cabinet', 'dirt']
Task:Drink
response:
| {
"thoughts": "I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <water_glass>",
"[GRAB] <water_glass>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <water_glass>",
"[DRINK] <water_glass>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'juice', 'toilet', 'chair', 'bathroom', 'drawing', 'orchid', 'bathroom_counter', 'phone', 'character', 'bedroom', 'toaster', 'mat', 'stereo', 'faucet', 'floor_lamp', 'shower', 'couch', 'dining_room', 'pasta', 'oven', 'powersocket', 'love_seat', 'newspaper', 'photoframe', 'coffe_maker', 'tray', 'dresser', 'bathtub', 'soap']
Task:Read
response:
{
"thoughts": Sit on an easy chair. Turn on music. Take a book and read. Turn on lamp at night.,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <newspaper>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'ceilingfan', 'drawing', 'needle', 'bills', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'candle', 'wall', 'nightstand', 'photoframe', 'mouthwash', 'razor', 'television', 'food_rice', 'curtain', 'towel_rack', 'headset', 'table', 'vase']
Task:Relax on sofa
response:
| {
"thoughts": "Go into the living room. Walk over to the sofa. Lie down on the sofa. Turn on and watch TV.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[LIE] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'toilet', 'dog', 'band-aids', 'walllamp', 'ground_coffee', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'phone', 'food_cake', 'computer', 'toaster', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'table', 'light', 'scrabble']
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:['spectacles', 'pot', 'beer', 'microwave', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'button', 'toaster', 'dustpan', 'dining_room', 'bowl', 'wall', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'kitchen_counter', 'chessboard', 'vacuum_cleaner', 'headset', 'controller', 'clothes_scarf', 'coffee_cup', 'dishwasher', 'vase', 'coffee']
Task:Make coffee
response:
| {
"thoughts": "Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffee>",
"[GRAB] <coffee>",
"[OPEN] <coffe_maker>",
"[POUR] <coffee> <coffe_maker>",
"[FIND] <coffee_cup>",
"[GRAB] <coffee_cup>",
"[PUTBACK] <coffee_cup> <coffe_maker>",
"[FIND] <button>",
"[PUSH] <button>",
"[GRAB] <coffee_cup>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'mat', 'window', 'clothes_socks', 'couch', 'pillow', 'towel', 'broom', 'wall', 'bench', 'oven', 'toy', 'bed', 'coffe_maker', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'food_onion', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table', 'scrabble']
Task:Relax on sofa
response:
{
"thoughts": Walk to living room. Find couch. Sit on couch,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'freezer', 'bathroom', 'detergent', 'food_butter', 'longboard', 'bookshelf', 'stovefan', 'shower', 'pillow', 'towel', 'dining_room', 'nightstand', 'powersocket', 'toy', 'basket_for_clothes', 'newspaper', 'light_bulb', 'photoframe', 'food_food', 'coin', 'doorjamb', 'headset', 'shoes', 'hairbrush', 'cupboard', 'napkin', 'home_office']
Task:Listen to music
response:
| {
"thoughts": "I walk into my room and turn the radio on so that I can listen to music.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'foundation', 'homework', 'closetdrawer', 'couch', 'pillow', 'broom', 'nightstand', 'wall', 'oven', 'light_bulb', 'television', 'curtain', 'dresser', 'bathroom_cabinet', 'table', 'dishwasher', 'creditcard']
Task:Watch TV
response:
{
"thoughts": I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch.,
"actions": ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>']
}
|
Scene_Objects:['toilet', 'chair', 'freezer', 'cat', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'iron', 'balanceball', 'mousepad', 'dustpan', 'pillow', 'broom', 'wall', 'oven', 'coffee_table', 'novel', 'food_food', 'coffe_maker', 'curtain', 'doorjamb', 'mouse', 'pencil', 'light', 'board_game']
Task:Read book
response:
| {
"thoughts": "I walk to the living room and pick up a book from the coffee table. I find my favorite chair. I sit in the armchair and open the book. I read.",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[FIND] <novel>",
"[WALK] <coffee_table>",
"[GRAB] <novel>",
"[WALK] <chair>",
"[SIT] <chair>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'food_pizza', 'filing_cabinet', 'microwave', 'chair', 'walllamp', 'orchid', 'knifeblock', 'bathroom_counter', 'ceiling', 'phone', 'stamp', 'keyboard', 'thread', 'computer', 'stovefan', 'toaster', 'plate', 'shower', 'mousepad', 'form', 'wall', 'food_cheese', 'bed', 'console', 'headset', 'dresser', 'spoon', 'bathroom_cabinet', 'bag']
Task:Walk to room
response:
{
"thoughts": Leave the living room and enter the hall,
"actions": ['[WALK] <home_office>', '[WALK] <home_office>']
}
|
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'laptop', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'tape', 'cup', 'photoframe', 'food_food', 'mouse', 'vacuum_cleaner', 'chessboard', 'napkin', 'table', 'soap']
Task:Work
response:
| {
"thoughts": "first ill go to my home office adn ill switch on my laptop and with the use of mouse and keyboard il run my computer",
"actions": [
"[WALK] <home_office>",
"[WALK] <laptop>",
"[FIND] <laptop>",
"[SWITCHON] <laptop>",
"[FIND] <keyboard>",
"[GRAB] <keyboard>",
"[FIND] <mouse>",
"[TOUCH] <mouse>",
"[RUN] <laptop>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'bookmark', 'toaster', 'mat', 'tvstand', 'faucet', 'shower', 'laptop', 'mousepad', 'wall', 'oven', 'powersocket', 'towel_rack', 'kitchen_counter', 'headset', 'door', 'sink', 'bathtub', 'home_office', 'bathroom_cabinet', 'light']
Task:Go to toilet
response:
{
"thoughts": I go to the bathroom. I locate the toilet. I walk to the toilet.,
"actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[WALK] <toilet>']
}
|
Scene_Objects:['pot', 'food_salt', 'freezer', 'walllamp', 'trashcan', 'ceilingfan', 'cpuscreen', 'clothes_underwear', 'food_egg', 'phone', 'character', 'bedroom', 'envelope', 'clothes_jacket', 'mat', 'tvstand', 'couch', 'clothes_pants', 'newspaper', 'television', 'console', 'dishrack', 'cupboard', 'laundry_detergent', 'door', 'maindoor', 'bathroom_cabinet', 'instrument_guitar', 'soap', 'washing_machine']
Task:Wash clothes
response:
| {
"thoughts": "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.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <washing_machine>",
"[FIND] <washing_machine>",
"[OPEN] <washing_machine>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[PUTBACK] <clothes_pants> <washing_machine>",
"[CLOSE] <washing_machine>",
"[FIND] <laundry_detergent>",
"[GRAB] <laundry_detergent>",
"[OPEN] <washing_machine>",
"[PUTBACK] <laundry_detergent> <washing_machine>",
"[CLOSE] <washing_machine>",
"[SWITCHON] <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:['spectacles', 'tablelamp', 'beer', 'toilet', 'band-aids', 'nail_polish', 'ceilingfan', 'food_carrot', 'toothbrush', 'knife', 'shampoo', 'ceiling', 'bedroom', 'stamp', 'tea_bag', 'mop_bucket', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'homework', 'food_noodles', 'dining_room', 'bed', 'ice', 'mouse', 'spoon', 'home_office', 'bathroom_cabinet', 'vase', 'colander']
Task:Shut front door
response:
{
"thoughts": Close the storm door. Lock the storm door.,
"actions": ['[WALK] <home_office>']
}
|
Scene_Objects:['food_salt', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'folder', 'faucet', 'couch', 'food_peanut_butter', 'wall', 'cup', 'photoframe', 'bed', 'check', 'oven_mitts', 'after_shave', 'coffee_pot', 'mouse', 'kitchen_counter', 'cd', 'conditioner', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'light', 'soap', 'tooth_paste', 'hands_both']
Task:Wash hands
response:
| {
"thoughts": "You walk to the bathroom and turn to the sink. Grab the soap and wash your hands, put the soap back.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <sink>",
"[TURNTO] <sink>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[FIND] <hands_both>",
"[WASH] <hands_both>",
"[PUTOBJBACK] <soap>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_ice_cream', 'freezer', 'walllamp', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'oven', 'powersocket', 'cup', 'ice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']
Task:Get something to drink
response:
{
"thoughts": Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[CLOSE] <freezer>', '[POUR] <milk> <cup>', '[DRINK] <cup>']
}
|
Scene_Objects:['sponge', 'juice', 'chair', 'jelly', 'nail_polish', 'cat', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'iron', 'clothes_pants', 'food_kiwi', 'wall', 'photoframe', 'food_food', 'water', 'wooden_spoon', 'curtain', 'doorjamb', 'sink', 'bathroom_cabinet', 'teeth']
Task:Wash teeth
response:
| {
"thoughts": "Wash the teeth",
"actions": [
"[WALK] <bathroom>",
"[WALK] <faucet>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <water>",
"[TURNTO] <water>",
"[POINTAT] <water>",
"[FIND] <teeth>",
"[WASH] <teeth>",
"[SWITCHOFF] <faucet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'food_salt', 'chair', 'wallshelf', 'character', 'keyboard', 'food_cake', 'mop_bucket', 'stovefan', 'toaster', 'iron', 'shower', 'window', 'clothes_socks', 'closetdrawer', 'dining_room', 'broom', 'box', 'coffe_maker', 'television', 'tray', 'centerpiece', 'doorjamb', 'kettle', 'mouse', 'headset', 'cupboard', 'bag', 'table', 'light']
Task:Shut front door
response:
{
"thoughts": Close the storm door. Lock the storm door.,
"actions": ['[WALK] <home_office>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'ground_coffee', 'walllamp', 'food_butter', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'thread', 'stovefan', 'toaster', 'tvstand', 'faucet', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'coffe_maker', 'food_food', 'oven_mitts', 'coffee_filter', 'water', 'wine', 'wooden_spoon', 'controller', 'bathroom_cabinet', 'home_office', 'dishwasher']
Task:Make coffee
response:
| {
"thoughts": "Walk to kitchen, open coffee maker, find coffee filter, grab coffee filter, put coffee filter in coffee maker, find ground coffee, put ground coffee in coffee maker, pour water in coffee maker, close coffee maker and switch on coffee maker.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[OPEN] <coffe_maker>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <coffe_maker>",
"[CLOSE] <coffe_maker>",
"[SWITCHON] <coffe_maker>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'water_glass', 'toilet', 'jelly', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'stovefan', 'mat', 'shower', 'food_kiwi', 'wall', 'nightstand', 'oven', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'water', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'spoon', 'light', 'dishwasher']
Task:Drink
response:
{
"thoughts": I need to go to Kitchen. Get a cup. Fill cup. Drink,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}
|
Scene_Objects:['spectacles', 'food_pizza', 'mop', 'bathroom', 'toothbrush', 'drawing', 'knifeblock', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'mop_bucket', 'brush', 'toaster', 'faucet', 'stereo', 'couch', 'towel', 'wall', 'powersocket', 'cup', 'photoframe', 'bed', 'mouse', 'dresser', 'sink', 'bathroom_cabinet', 'soap', 'tooth_paste']
Task:Wash teeth
response:
| {
"thoughts": "Upon entering the restroom, walk to the sink. Take a toothbrush and apply enough toothpaste so that 1/4 of the brush is covered (this is the appropriate amount). Proceed to \"brush\" your teeth using an up and down motion with the brush in your mouth. Brush for 2 minutes covering all areas of the teeth. Rinse with water and clean toothbrush with water too.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <tooth_paste>",
"[FIND] <tooth_paste>",
"[SCRUB] <tooth_paste>",
"[FIND] <toothbrush>",
"[WASH] <toothbrush>",
"[FIND] <sink>",
"[RINSE] <sink>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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:['jelly', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'brush', 'stovefan', 'faucet', 'iron', 'couch', 'towel', 'wall', 'powersocket', 'cutting_board', 'photoframe', 'bed', 'television', 'lighter', 'console', 'dresser', 'pajamas', 'door', 'sink', 'bathroom_cabinet', 'table', 'clothes_skirt', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:
| {
"thoughts": "I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <faucet>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <hands_both>",
"[RINSE] <hands_both>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[SCRUB] <soap>",
"[PUTOBJBACK] <soap>",
"[SCRUB] <hands_both>",
"[RINSE] <hands_both>",
"[SWITCHOFF] <faucet>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[WIPE] <hands_both>",
"[PUTOBJBACK] <towel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'scissors', 'chair', 'freezer', 'trashcan', 'knife', 'longboard', 'floor', 'shampoo', 'computer', 'button', 'tvstand', 'stereo', 'window', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'nightstand', 'bed', 'novel', 'check', 'wine', 'curtain', 'cupboard', 'hair', 'sink', 'bathroom_cabinet', 'soap', 'creditcard']
Task:Read book
response:
{
"thoughts": I would go lie down in my bed and open the book and start reading.,
"actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['pot', 'tablelamp', 'toilet', 'chair', 'walllamp', 'ceilingfan', 'toothbrush', 'drawing', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'shower', 'faucet', 'window', 'mousepad', 'oil', 'couch', 'wall', 'nightstand', 'photoframe', 'novel', 'video_game_controller', 'television', 'mouse', 'table']
Task:Read book
response:
| {
"thoughts": "Find book, grab book, fin bookmark, sit down somewhere comfortable, open book, read book, close book after reading.",
"actions": [
"[WALK] <desk>",
"[FIND] <novel>",
"[FIND] <bookmark>",
"[GRAB] <bookmark>",
"[FIND] <couch>",
"[SIT] <couch>",
"[GRAB] <novel>",
"[READ] <novel>",
"[PUTBACK] <bookmark> <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'floor', 'desk', 'bookshelf', 'plate', 'faucet', 'picture', 'iron', 'window', 'dish_soap', 'food_jam', 'wall', 'nightstand', 'toy', 'cutting_board', 'food_food', 'television', 'curtain', 'pajamas', 'conditioner', 'light', 'dishwasher', 'tooth_paste', 'shoe_rack']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Go to the kitchen. Find the dishwasher. Open the dishwasher. Find the plates. Load the plates into the dishwasher. Find the soap. Load the soap into the dishwasher. Close the dishwasher. Turn on the dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['fork', 'filing_cabinet', 'mop', 'freezer', 'walllamp', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'keyboard', 'remote_control', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dining_room', 'wall', 'wall_clock', 'photoframe', 'food_food', 'television', 'curtain', 'console', 'pencil', 'table', 'light', 'clothes_skirt']
Task:Change TV channel
response:
| {
"thoughts": "I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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:['detergent', 'food_butter', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'remote_control', 'thread', 'brush', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'faucet', 'mousepad', 'couch', 'dining_room', 'wall', 'bed', 'food_food', 'television', 'food_donut', 'curtain', 'lighter', 'doorjamb', 'cards', 'sink', 'table', 'scrabble']
Task:Watch TV
response:
| {
"thoughts": "turn tv on, watch TV",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[TURNTO] <remote_control>",
"[FIND] <television>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'microwave', 'ground_coffee', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'toaster', 'plate', 'faucet', 'foundation', 'mousepad', 'food_jam', 'food_kiwi', 'wall', 'pasta', 'powersocket', 'food_food', 'coffe_maker', 'rag', 'shaving_cream', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Take a dish and put it in the dishwasher to be washed,
"actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['pot', 'scissors', 'chair', 'freezer', 'trashcan', 'knife', 'longboard', 'floor', 'shampoo', 'computer', 'button', 'tvstand', 'stereo', 'window', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'nightstand', 'bed', 'novel', 'check', 'wine', 'curtain', 'cupboard', 'hair', 'sink', 'bathroom_cabinet', 'soap', 'creditcard']
Task:Read book
response:
| {
"thoughts": "I would go lie down in my bed and open the book and start reading.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <bed>",
"[FIND] <bed>",
"[LIE] <bed>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'crayon', 'chair', 'walllamp', 'bathroom', 'ceiling', 'bedroom', 'keyboard', 'bookshelf', 'clothes_jacket', 'toaster', 'deck_of_cards', 'faucet', 'mousepad', 'microphone', 'wall', 'tape', 'novel', 'food_food', 'check', 'food_donut', 'tray', 'towel_rack', 'dresser', 'pajamas', 'clothes_dress', 'hairdryer', 'bathroom_cabinet', 'home_office', 'table']
Task:Grab things
response:
{
"thoughts": The robot will need some kind of hands or grabbing device to transport objects.,
"actions": ['[WALK] <novel>', '[TURNTO] <novel>', '[GRAB] <novel>']
}
|
Scene_Objects:['tablelamp', 'walllamp', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'bed', 'television', 'curtain', 'pencil', 'dresser', 'clothes_dress', 'conditioner', 'table', 'board_game', 'coffee']
Task:Change TV channel
response:
| {
"thoughts": "Change the channel on the TV in the living room",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'drawing', 'orchid', 'food_egg', 'floor', 'ceiling', 'phone', 'character', 'remote_control', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'shower', 'couch', 'clothes_hat', 'wall', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'television', 'food_onion', 'doorjamb', 'controller', 'door', 'table']
Task:Change TV channel
response:
{
"thoughts": Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control,
"actions": ['[WALK] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[TOUCH] <button>', '[TURNTO] <television>', '[WATCH] <television>', '[PUTOBJBACK] <remote_control>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'toaster', 'shower', 'food_noodles', 'oil', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']
Task:Cook some food
response:
{
"thoughts": 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.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <oven>', '[PUTBACK] <pot> <oven>', '[PUTBACK] <food_chicken> <oven>']
}
|
Scene_Objects:['dry_pasta', 'tablelamp', 'scissors', 'food_salt', 'toilet', 'chair', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'mail', 'toaster', 'homework', 'mousepad', 'clothes_pants', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'coffee_pot', 'mouse', 'home_office', 'table', 'dishwasher', 'vase', 'tooth_paste']
Task:Go to toilet
response:
| {
"thoughts": "Walk to the bathroom. Pull down pants. Use the toilet.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <clothes_pants>",
"[FIND] <clothes_pants>",
"[PULL] <clothes_pants>",
"[FIND] <toilet>",
"[SIT] <toilet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'food_carrot', 'drawing', 'orchid', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'computer', 'mat', 'plate', 'ceilinglamp', 'stereo', 'couch', 'candle', 'food_orange', 'pillow', 'wall', 'oven', 'food_vegetable', 'novel', 'food_food', 'razor', 'television', 'console', 'kitchen_counter', 'cupboard', 'controller', 'table']
Task:Fix snack
response:
{
"thoughts": Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge.,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[PUTBACK] <food_carrot> <plate>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[PUTBACK] <food_vegetable> <plate>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <plate> <table>']
}
|
Scene_Objects:['scissors', 'mop', 'dog', 'cat', 'knifeblock', 'longboard', 'folder', 'keyboard', 'food_cake', 'alcohol', 'table_cloth', 'mat', 'window', 'pillow', 'bench', 'toy', 'clothes_gloves', 'novel', 'coffe_maker', 'coin', 'towel_rack', 'vacuum_cleaner', 'dresser', 'cupboard', 'maindoor', 'door', 'table', 'dishwasher', 'laser_pointer', 'creditcard']
Task:Browse internet
response:
| {
"thoughts": "I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites.",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>",
"[GRAB] <phone>",
"[TOUCH] <phone>",
"[TURNTO] <phone>",
"[LOOKAT] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'freezer', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'mousepad', 'wall', 'powersocket', 'food_food', 'food_donut', 'tray', 'after_shave', 'doorjamb', 'cards', 'mouse', 'shoes', 'dresser', 'food_steak', 'door', 'bathroom_cabinet', 'light', 'clothes_skirt']
Task:Cook some food
response:
{
"thoughts": Go kitchen and make something for eat,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>']
}
|
Scene_Objects:['sheets', 'food_ice_cream', 'measuring_cup', 'knife', 'orchid', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'alcohol', 'computer', 'table_cloth', 'mat', 'deck_of_cards', 'stereo', 'window', 'pillow', 'powersocket', 'cup', 'newspaper', 'check', 'ice', 'after_shave', 'lighter', 'diary', 'cd', 'cupboard', 'maindoor', 'colander', 'board_game']
Task:Listen to music
response:
| {
"thoughts": "Find radio, turn it on",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <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:['sheets', 'toilet', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'bathroom_counter', 'purse', 'alcohol', 'bookmark', 'stovefan', 'toaster', 'stereo', 'food_jam', 'dining_room', 'powersocket', 'food_food', 'mouthwash', 'tray', 'after_shave', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office', 'laser_pointer']
Task:Walk through
response:
{
"thoughts": Walk through the hallway.,
"actions": ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>']
}
|
Scene_Objects:['tablelamp', 'beer', 'cat', 'trashcan', 'milk', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'character', 'desk', 'bookshelf', 'food_cake', 'computer', 'brush', 'ceilinglamp', 'plate', 'deck_of_cards', 'wall', 'powersocket', 'toy', 'newspaper', 'bed', 'coffe_maker', 'curtain', 'pencil', 'hair', 'door', 'light']
Task:Give milk to cat
response:
| {
"thoughts": "Grab milk and pour it into the plate so that the cat can drink",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TURNTO] <cat>",
"[POINTAT] <cat>",
"[PULL] <cat>",
"[FIND] <milk>",
"[GRAB] <milk>",
"[FIND] <plate>",
"[POUR] <milk> <plate>",
"[TOUCH] <cat>",
"[SCRUB] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'blender', 'beer', 'freezer', 'band-aids', 'walllamp', 'orchid', 'food_egg', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'button', 'ceilinglamp', 'mousepad', 'food_peanut_butter', 'wall', 'powersocket', 'food_food', 'doorjamb', 'mouse', 'door', 'sink', 'napkin', 'light']
Task:Put groceries in Fridge
response:
{
"thoughts": I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}
|
Scene_Objects:['sheets', 'pot', 'food_pizza', 'tablelamp', 'microwave', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'envelope', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'deck_of_cards', 'window', 'couch', 'wall', 'nightstand', 'novel', 'television', 'curtain', 'hairdryer', 'sink', 'home_office', 'table', 'bathroom_cabinet']
Task:Change TV channel
response:
| {
"thoughts": "Walk to the living room. Find the television. Switch on the television. Find the remote control. Grab the remote control. Point at television. Find the button. Push button.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[TURNTO] <television>",
"[POINTAT] <television>",
"[FIND] <button>",
"[PUSH] <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:['pot', 'filing_cabinet', 'toilet', 'chair', 'cat', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'food_bacon', 'stovefan', 'ceilinglamp', 'iron', 'dustpan', 'pillow', 'wall', 'toy', 'box', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cd', 'dresser', 'cupboard', 'light', 'table']
Task:Vacuum
response:
{
"thoughts": Plug in the vacuum. Turn it on. Push it back and forth across the floor until all the debris is gone.,
"actions": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']
}
|
Scene_Objects:['sheets', 'microwave', 'dog', 'chair', 'bathroom', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'mat', 'ceilinglamp', 'shower', 'candle', 'wall', 'bed', 'clothes_gloves', 'food_food', 'water', 'food_rice', 'wooden_spoon', 'curtain', 'console', 'dishrack', 'pajamas', 'light', 'clothes_skirt', 'soap', 'dirt']
Task:Take shower
response:
| {
"thoughts": "go to a bathroom, open the shower, let water wash your body",
"actions": [
"[WALK] <bathroom>",
"[WALK] <shower>",
"[FIND] <soap>",
"[SCRUB] <soap>",
"[FIND] <water>",
"[RINSE] <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:['dry_pasta', 'scissors', 'chair', 'hanger', 'phone', 'keyboard', 'bookshelf', 'plate', 'faucet', 'window', 'mousepad', 'food_noodles', 'oil', 'food_peanut_butter', 'clothes_pants', 'dining_room', 'bench', 'oven', 'cutting_board', 'toy', 'basket_for_clothes', 'cup', 'photoframe', 'keys', 'food_food', 'laundry_detergent', 'bathroom_cabinet', 'instrument_violin', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine.,
"actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['sheets', 'beer', 'measuring_cup', 'toilet', 'drawing', 'knife', 'hanger', 'floor', 'desk', 'tea_bag', 'keyboard', 'piano_bench', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'foundation', 'clothes_pants', 'towel', 'wall', 'nightstand', 'novel', 'television', 'tray', 'curtain', 'bag', 'table', 'vase', 'soap']
Task:Wash hands
response:
| {
"thoughts": "BEFORE EATING",
"actions": [
"[WALK] <bathroom>",
"[WALK] <soap>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[FIND] <towel>",
"[WIPE] <towel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'crayon', 'ceilingfan', 'drawing', 'needle', 'floor', 'ceiling', 'shampoo', 'keyboard', 'remote_control', 'thread', 'food_bacon', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'photoframe', 'bed', 'television', 'coffee_filter', 'curtain', 'mouse', 'table', 'light', 'laser_pointer']
Task:Watch TV
response:
{
"thoughts": I go into the living room. I find the remote. I turn on the tv. I sit on the couch and watch tv.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['sheets', 'tablelamp', 'crayon', 'mop', 'toilet', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'desk', 'computer', 'ceilinglamp', 'deck_of_cards', 'faucet', 'mousepad', 'microphone', 'towel', 'wall', 'oven', 'tape', 'photoframe', 'novel', 'toothbrush_holder', 'towel_rack', 'cupboard', 'sink', 'bathroom_cabinet', 'home_office', 'table', 'tooth_paste']
Task:Brush teeth
response:
| {
"thoughts": "getting ready for bed",
"actions": [
"[WALK] <bathroom_counter>",
"[FIND] <toothbrush>",
"[GRAB] <toothbrush>",
"[PUTBACK] <toothbrush> <bathroom_counter>",
"[FIND] <tooth_paste>",
"[SQUEEZE] <tooth_paste>",
"[GRAB] <toothbrush>",
"[SCRUB] <toothbrush>",
"[RINSE] <toothbrush>",
"[FIND] <toothbrush_holder>",
"[PUTBACK] <toothbrush> <toothbrush_holder>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'food_bread', 'tablelamp', 'crayon', 'tea', 'toilet', 'walllamp', 'knife', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'dish_soap', 'couch', 'wall', 'oven', 'novel', 'coffe_maker', 'drinking_glass', 'tray', 'doorjamb', 'kettle', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'dishwasher', 'clothes_shirt']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into the dishwasher. Turn on the dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[TURNTO] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['food_bread', 'tablelamp', 'chair', 'nail_polish', 'detergent', 'ceilingfan', 'knifeblock', 'orchid', 'cpuscreen', 'hanger', 'character', 'keyboard', 'computer', 'homework', 'window', 'towel', 'cutting_board', 'bed', 'photoframe', 'curtain', 'rag', 'towel_rack', 'mouse', 'kitchen_counter', 'headset', 'dresser', 'controller', 'maindoor', '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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'food_salt', 'measuring_cup', 'toilet', 'jelly', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'alcohol', 'mat', 'shower', 'foundation', 'electric_shaver', 'mousepad', 'wall', 'toy', 'basket_for_clothes', 'photoframe', 'wine', 'dresser', 'laundry_detergent', 'food_steak', 'door', 'napkin', 'bathroom_cabinet', 'dishwasher']
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:['fork', 'chair', 'walllamp', 'knife', 'food_egg', 'floor', 'food_cake', 'toaster', 'plate', 'tvstand', 'window', 'dish_soap', 'wall', 'nightstand', 'oven', 'cutting_board', 'coffe_maker', 'check', 'razor', 'television', 'food_donut', 'tray', 'centerpiece', 'doorjamb', 'dishrack', 'food_steak', 'spoon', 'light', 'dishwasher', 'colander']
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>"
]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.