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