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:['dry_pasta', 'food_pizza', 'filing_cabinet', 'scissors', 'chair', 'ceilingfan', 'dough', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'coffee_table', 'television', 'coin', 'wooden_spoon', 'curtain', 'maindoor', 'table']
Task:Watch TV
response:
{
"thoughts": I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>']
}
|
Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'folder', 'bookshelf', 'remote_control', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'door', 'bathroom_cabinet', 'light', 'table', 'tooth_paste']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'tvstand', 'faucet', 'stereo', 'window', 'couch', 'form', 'wall', 'powersocket', 'light_bulb', 'razor', 'vacuum_cleaner', 'controller', 'door', 'home_office', 'light', 'dishwasher', 'bathroom_cabinet', 'colander']
Task:Go to toilet
response:
| {
"thoughts": "I walk into the bath room and go to the toilet",
"actions": [
"[WALK] <bathroom>",
"[WALK] <toilet>",
"[FIND] <toilet>",
"[SIT] <toilet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'blow_dryer', 'bathroom', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'stamp', 'keyboard', 'computer', 'food_bacon', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'coffe_maker', 'wooden_spoon', 'towel_rack', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'controller', 'light', 'soap']
Task:Vacuum
response:
{
"thoughts": Plug in vacuum. Walk around with vacuum, covering all of the floor. Unplug vacuum.,
"actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <dresser>', '[PUTIN] <vacuum_cleaner> <dresser>', '[CLOSE] <dresser>']
}
|
Scene_Objects:['fork', 'spectacles', 'chair', 'freezer', 'walllamp', 'knife', 'wallshelf', 'floor', 'alcohol', 'bookmark', 'toaster', 'plate', 'candle', 'wall', 'nightstand', 'novel', 'coffe_maker', 'food_food', 'television', 'water', 'curtain', 'after_shave', 'diary', 'kitchen_counter', 'dresser', 'cupboard', 'bathtub', 'spoon', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "first i will take all the dishes to the dish washer and with the help of dishwasher and water i will clean all the dishes",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[PUTBACK] <fork> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <spoon>",
"[GRAB] <spoon>",
"[PUTBACK] <spoon> <dishwasher>",
"[FIND] <water>",
"[TURNTO] <water>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'sheets', 'food_salt', 'tea', 'blow_dryer', 'wallshelf', 'ceiling', 'character', 'food_cake', 'computer', 'tvstand', 'window', 'mousepad', 'cutting_board', 'basket_for_clothes', 'cup', 'newspaper', 'light_bulb', 'novel', 'photoframe', 'coin', 'food_donut', 'rag', 'cards', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'maindoor', 'bag', 'creditcard']
Task:Clean
response:
{
"thoughts": Clean the welcome mat,
"actions": ['[WALK] <home_office>', '[WALK] <vacuum_cleaner>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']
}
|
Scene_Objects:['fork', 'crayon', 'microwave', 'chair', 'cloth_napkin', 'freezer', 'walllamp', 'drawing', 'knife', 'floor', 'phone', 'character', 'food_cake', 'mat', 'ceilinglamp', 'plate', 'window', 'mousepad', 'microphone', 'pillow', 'wall', 'nightstand', 'bench', 'cup', 'video_game_controller', 'doorjamb', 'controller', 'door', 'table', 'teeth']
Task:Set up table
response:
| {
"thoughts": "Walk to dining room, walk to dining table, arrange chairs, set napkin, set plate, set knife, set fork and glass on table.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <table>",
"[FIND] <chair>",
"[PULL] <chair>",
"[FIND] <cloth_napkin>",
"[GRAB] <cloth_napkin>",
"[PUTBACK] <cloth_napkin> <table>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <table>",
"[FIND] <knife>",
"[GRAB] <knife>",
"[PUTBACK] <knife> <table>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[PUTBACK] <fork> <table>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[PUTBACK] <cup> <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:['glue', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'microwave', 'chair', 'dog', 'toothbrush', 'knifeblock', 'hanger', 'ceiling', 'bedroom', 'man', 'keyboard', 'ceilinglamp', 'stereo', 'shower', 'couch', 'food_jam', 'pillow', 'pasta', 'powersocket', 'coffe_maker', 'kettle', 'pencil', 'napkin', 'table', 'scrabble', 'creditcard']
Task:Greet guests
response:
{
"thoughts": When someone knocks I n the door walk through the hallway and greet them.,
"actions": ['[RUN] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']
}
|
Scene_Objects:['fork', 'microwave', 'nail_polish', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'bedroom', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'dining_room', 'wall', 'tape', 'cup', 'bed', 'mouthwash', 'after_shave', 'dishrack', 'cupboard', 'door', 'sink', 'table', 'light', 'tooth_paste', 'clothes_shirt']
Task:Turn on light
response:
| {
"thoughts": "Turning on lights",
"actions": [
"[WALK] <bedroom>",
"[WALK] <floor_lamp>",
"[FIND] <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:['milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'desk', 'brush', 'mat', 'ceilinglamp', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'cup', 'photoframe', 'coffee_filter', 'food_rice', 'doorjamb', 'towel_rack', 'dresser', 'clothes_dress', 'door', 'light', 'table']
Task:Change clothes
response:
{
"thoughts": Switch your clothes.,
"actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[CLOSE] <dresser>']
}
|
Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine']
Task:Wash clothes
response:
| {
"thoughts": "Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <basket_for_clothes>",
"[FIND] <basket_for_clothes>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[FIND] <washing_machine>",
"[WALK] <washing_machine>",
"[OPEN] <washing_machine>",
"[PUTBACK] <clothes_dress> <washing_machine>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[PUTBACK] <soap> <washing_machine>",
"[CLOSE] <washing_machine>",
"[SWITCHON] <washing_machine>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'toaster', 'closetdrawer', 'couch', 'food_jam', 'pillow', 'wall', 'cup', 'photoframe', 'coffee_table', 'novel', 'television', 'doorjamb', 'shoes', 'comb', 'dresser', 'instrument_violin']
Task:Watch TV
response:
{
"thoughts": I sit down on the couch, get the tv remote, click the on button, and change the channel to the show i want to watch,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'toothbrush', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'food_noodles', 'form', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'keys', 'toothbrush_holder', 'rag', 'doorjamb', 'sink', 'bathroom_cabinet', 'instrument_guitar', 'dishwasher', 'tooth_paste', 'teeth']
Task:Wash teeth
response:
{
"thoughts": I walk in to the bathroom. I turn on the faucet. I find the toothbrush and toothpaste. I grab the toothbrush and toothpaste. I rinse off the toothbrush. I add toothpaste to the toothbrush. I put back the toothpaste. I wash my teeth with the toothbrush. I rinse off the toothbrush. I put the toothbrush back. I rinse my mouth out. I turn the faucet off.,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[RINSE] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>', '[PUTOBJBACK] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>', '[RINSE] <toothbrush>', '[PUTOBJBACK] <toothbrush>', '[RINSE] <teeth>', '[SWITCHOFF] <faucet>']
}
|
Scene_Objects:['toilet', 'detergent', 'knifeblock', 'knife', 'bills', 'clothes_underwear', 'shampoo', 'desk', 'piano_bench', 'toaster', 'ceilinglamp', 'window', 'food_peanut_butter', 'clothes_pants', 'clothes_hat', 'basket_for_clothes', 'bed', 'coffe_maker', 'tray', 'doorjamb', 'cards', 'mouse', 'dresser', 'clothes_dress', 'bathtub', 'table', 'dishwasher', 'soap', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
| {
"thoughts": "I need to get the dirty clothes basket. Walk to bathroom. Put all the clothes in washing machine. Add soap. Turn on machine.",
"actions": [
"[WALK] <basket_for_clothes>",
"[WALK] <bathroom>",
"[WALK] <washing_machine>",
"[FIND] <washing_machine>",
"[OPEN] <washing_machine>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[PUTBACK] <clothes_dress> <washing_machine>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[PUTBACK] <clothes_pants> <washing_machine>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUTBACK] <clothes_shirt> <washing_machine>",
"[FIND] <clothes_underwear>",
"[GRAB] <clothes_underwear>",
"[PUTBACK] <clothes_underwear> <washing_machine>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[PUTBACK] <soap> <washing_machine>",
"[CLOSE] <washing_machine>",
"[SWITCHON] <washing_machine>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light']
Task:Greet guests
response:
{
"thoughts": Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,
"actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']
}
|
Scene_Objects:['spectacles', 'tablelamp', 'food_salt', 'microwave', 'toilet', 'freezer', 'walllamp', 'blow_dryer', 'bathroom', 'orchid', 'knifeblock', 'drawing', 'desk', 'bedroom', 'bookshelf', 'mat', 'foundation', 'oil', 'pillow', 'dining_room', 'bench', 'oven', 'novel', 'mouthwash', 'television', 'kitchen_counter', 'shoes', 'controller', 'bathtub', 'home_office']
Task:Write an email
response:
| {
"thoughts": "Find the computer. Turn on the computer. Open the e-mail program. Create a new message. Write the message.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'food_pizza', 'filing_cabinet', 'toilet', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'folder', 'keyboard', 'faucet', 'iron', 'mousepad', 'pillow', 'dining_room', 'tape', 'cutting_board', 'cup', 'food_food', 'video_game_controller', 'food_rice', 'food_donut', 'rag', 'kettle', 'mouse', 'kitchen_counter', 'controller', 'food_steak', 'sink', 'dishwasher']
Task:Listen to music
response:
{
"thoughts": I walk to the living room. I find a radio there and switch it on to listen to music.,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['microwave', 'chair', 'detergent', 'wallshelf', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'alcohol', 'table_cloth', 'toaster', 'tvstand', 'shower', 'faucet', 'mousepad', 'clothes_hat', 'powersocket', 'oven', 'bench', 'box', 'photoframe', 'novel', 'coffe_maker', 'toilet_paper', 'doorjamb', 'mouse', 'cupboard', 'napkin', 'bathroom_cabinet']
Task:Pet cat
response:
| {
"thoughts": "I go looking for the cat in the living room where he usually sleeps. Once I find the cat I just pet him for a few minutes.",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door', 'teeth', 'printing_paper']
Task:Print out papers
response:
{
"thoughts": Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.,
"actions": ['[WALK] <home_office>', '[WALK] <fax_machine>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[PUTBACK] <printing_paper> <fax_machine>', '[FIND] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <printing_paper>']
}
|
Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'toaster', 'plate', 'faucet', 'stereo', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bathtub', 'dishwasher', 'clothes_skirt', 'laser_pointer']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Take a dish and put it in the dishwasher to be washed",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'sheets', 'ground_coffee', 'walllamp', 'trashcan', 'drawing', 'orchid', 'needle', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'toaster', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'check', 'food_food', 'television', 'food_onion', 'doorjamb', 'pencil', 'door', 'home_office', 'table', 'light', 'coffee']
Task:Relax on sofa
response:
{
"thoughts": Walk to the living room. Walk to the sofa and sit on the sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'door', 'table', 'light']
Task:Watch TV
response:
| {
"thoughts": "I walk into my living room, find the remote and sit on my sofa. I look at the remote and switch on the television. I look at the Television.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[FIND] <couch>",
"[SIT] <couch>",
"[TURNTO] <remote_control>",
"[LOOKAT] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'jelly', 'drawing', 'floor', 'bedroom', 'table_cloth', 'stovefan', 'mat', 'plate', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'cutting_board', 'bed', 'novel', 'tray', 'curtain', 'doorjamb', 'diary', 'mouse', 'pencil', 'cd', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'vase', 'laser_pointer']
Task:Read book
response:
{
"thoughts": I would go lie down in my bed and open the book and start reading.,
"actions": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'pencil', 'door', 'light', 'table']
Task:Change TV channel
response:
| {
"thoughts": "I push my body to be near to the table in front of me, without stand up. I move my right hand to near the TV remote control on the table. I take the TV remote control. I look the number on the remote control. I touch number 3 button. I put back the remote control to the table. I put my body back to the sofa",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[PLUGIN] <television>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[TURNTO] <remote_control>",
"[LOOKAT] <remote_control>",
"[GRAB] <remote_control>",
"[TOUCH] <remote_control>",
"[PUTOBJBACK] <remote_control>",
"[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:['chair', 'walllamp', 'bathroom', 'detergent', 'food_butter', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'button', 'table_cloth', 'stovefan', 'mat', 'brush', 'stereo', 'picture', 'mousepad', 'couch', 'clothes_pants', 'food_jam', 'powersocket', 'oven', 'newspaper', 'cards', 'shoes', 'controller', 'clothes_skirt', 'board_game']
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>']
}
|
Scene_Objects:['filing_cabinet', 'bathroom', 'detergent', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'tvstand', 'faucet', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'food_food', 'coffe_maker', 'doorjamb', 'dresser', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'light', 'home_office']
Task:Relax on sofa
response:
| {
"thoughts": "Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'mop', 'chair', 'freezer', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'shower', 'window', 'food_orange', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'spoon', 'table', 'light', 'coffee']
Task:Put groceries in Fridge
response:
{
"thoughts": I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing 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:['microwave', 'freezer', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'character', 'bookshelf', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'couch', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'lighter', 'dresser', 'sink', 'light']
Task:Change TV channel
response:
| {
"thoughts": "Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[WALK] <television>",
"[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:['sheets', 'microwave', 'dog', 'chair', 'bathroom', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'mat', 'ceilinglamp', 'shower', 'candle', 'wall', 'bed', 'clothes_gloves', 'food_food', 'water', 'food_rice', 'wooden_spoon', 'curtain', 'console', 'dishrack', 'pajamas', 'light', 'clothes_skirt', 'soap', 'dirt']
Task:Take shower
response:
{
"thoughts": go to a bathroom, open the shower, let water wash your body,
"actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']
}
|
Scene_Objects:['pot', 'tea', 'microwave', 'chair', 'freezer', 'band-aids', 'orchid', 'drawing', 'floor', 'ceiling', 'shampoo', 'alcohol', 'toaster', 'shower', 'mousepad', 'oil', 'couch', 'wall', 'nightstand', 'bench', 'cutting_board', 'tape', 'cup', 'food_donut', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard']
Task:Put groceries in Fridge
response:
| {
"thoughts": "Find groceries. Grab groceries. Walk to refrigerator. Open refrigerator door. Place groceries into refrigerator. Close refrigerator door.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'phone', 'bookshelf', 'table_cloth', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'cup', 'photoframe', 'check', 'television', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'sink', 'light', 'tooth_paste']
Task:Pet dog
response:
{
"thoughts": Pet my dog in hall,
"actions": ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']
}
|
Scene_Objects:['sheets', 'microwave', 'dog', 'chair', 'walllamp', 'detergent', 'knifeblock', 'needle', 'character', 'bookmark', 'mat', 'ceilinglamp', 'faucet', 'pillow', 'powersocket', 'oven', 'tape', 'cutting_board', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt', 'dirt']
Task:Change TV channel
response:
| {
"thoughts": "I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[GRAB] <remote_control>",
"[TURNTO] <remote_control>",
"[POINTAT] <remote_control>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'desk', 'envelope', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'oven_mitts', 'curtain', 'controller', 'home_office', 'table']
Task:Relax on sofa
response:
{
"thoughts": I walk into the living room. I cross the room to the couch. I sit down and relax.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'ground_coffee', 'walllamp', 'nail_polish', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'toaster', 'stovefan', 'iron', 'couch', 'form', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'hairdryer', 'bathtub', 'dishwasher', 'dirt']
Task:Make coffee
response:
| {
"thoughts": "I walk into the kitchen. I find the coffee maker and open it. I find the coffee filter, grab it and put it into the coffee maker. I find ground coffee, grab it and put it into the coffee maker. I find some water, then I pour it into the coffee maker. I close the coffee maker, I plug it in and I 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>",
"[PLUGIN] <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:['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:['spectacles', 'scissors', 'food_ice_cream', 'chair', 'orchid', 'drawing', 'bills', 'knifeblock', 'floor', 'character', 'alcohol', 'mat', 'window', 'couch', 'microphone', 'pillow', 'dining_room', 'wall', 'pasta', 'clothes_gloves', 'check', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'table', 'dishwasher', 'colander', 'coffee']
Task:Set up table
response:
| {
"thoughts": "walk to entrance hall. find a table. pull table. walk to living rook. push table.",
"actions": [
"[WALK] <home_office>",
"[WALK] <table>",
"[FIND] <table>",
"[PULL] <table>",
"[WALK] <home_office>",
"[WALK] <table>",
"[PUSH] <table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mop_bucket', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'mouse', 'pencil', 'controller', 'door', 'table', 'teeth']
Task:Work
response:
{
"thoughts": walk to home office ,find computer ,switch on computer and work,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['filing_cabinet', 'crayon', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'floor', 'ceiling', 'stamp', 'table_cloth', 'toaster', 'ceilinglamp', 'plate', 'shower', 'dish_soap', 'wall', 'nightstand', 'basket_for_clothes', 'keys', 'light_bulb', 'coffe_maker', 'novel', 'television', 'curtain', 'kitchen_counter', 'dishrack', 'cupboard', 'home_office', 'dishwasher', 'scrabble']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Walk to the kitchen. Open the dishwasher. Put plates into the dishwasher. Put dish soap into the dishwasher. Close the dishwasher. Turn on the dishwasher.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'walllamp', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'laptop', 'plate', 'stovefan', 'shower', 'dish_soap', 'wall', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher', 'coffee']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Put the dishes on dinner table in the dishwasher and wash them,
"actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[WALK] <table>', '[FIND] <pot>', '[GRAB] <pot>', '[WALK] <dishwasher>', '[PUTBACK] <pot> <dishwasher>', '[CLOSE] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'microwave', 'detergent', 'knifeblock', 'floor', 'ceiling', 'character', 'computer', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'wall', 'cup', 'check', 'mouthwash', 'water', 'wine', 'after_shave', 'curtain', 'food_onion', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'conditioner', 'sink', 'napkin', 'bathroom_cabinet']
Task:Drink
response:
{
"thoughts": I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it.,
"actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']
}
|
Scene_Objects:['sponge', 'dry_pasta', 'tablelamp', 'walllamp', 'detergent', 'milk', 'orchid', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'wall', 'box', 'basket_for_clothes', 'keys', 'coffe_maker', 'food_food', 'curtain', 'food_sugar', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'bathtub', 'sink', 'home_office', 'coffee_cup', 'dishwasher', 'clothes_skirt']
Task:Make coffee
response:
| {
"thoughts": "walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[TURNTO] <coffe_maker>",
"[LOOKAT] <coffe_maker>",
"[OPEN] <coffe_maker>",
"[FIND] <milk>",
"[GRAB] <milk>",
"[PUTBACK] <milk> <coffe_maker>",
"[FIND] <food_sugar>",
"[FIND] <coffee_cup>",
"[GRAB] <coffee_cup>",
"[PUTBACK] <coffee_cup> <coffe_maker>",
"[SWITCHON] <coffe_maker>",
"[FIND] <button>",
"[PUSH] <button>",
"[GRAB] <coffee_cup>",
"[DRINK] <coffee_cup>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', '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>']
}
|
Scene_Objects:['food_pizza', 'dog', 'bathroom', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'shower', 'electric_shaver', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'newspaper', 'bed', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light']
Task:Relax on sofa
response:
| {
"thoughts": "I walk to the living room and find the sofa. I sit on the sofa and get comfortable.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'tablelamp', 'chair', 'walllamp', 'detergent', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'check', 'television', 'tray', 'wooden_spoon', 'kettle', 'controller', 'food_steak', 'sink']
Task:Relax on sofa
response:
{
"thoughts": go to the living room and sit on the couch, ease into the sofa and relax.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'tablelamp', 'jelly', 'ceilingfan', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'bookshelf', 'computer', 'clothes_jacket', 'piano_bench', 'stovefan', 'toaster', 'tvstand', 'ceilinglamp', 'balanceball', 'stereo', 'brush', 'food_jam', 'clothes_hat', 'nightstand', 'pasta', 'powersocket', 'bench', 'bed', 'oven_mitts', 'tray', 'towel_rack', 'home_office']
Task:Listen to music
response:
{
"thoughts": I walk to the radio. I switch on the radio and listen,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'floor', 'phone', 'ceiling', 'keyboard', 'computer', 'toaster', 'mat', 'tvstand', 'couch', 'dustpan', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'newspaper', 'novel', 'doorjamb', 'mouse', 'pencil', 'cupboard', 'bathtub', 'bathroom_cabinet', 'light']
Task:Turn on light
response:
| {
"thoughts": "I walk into the kitchen, I find the light switch, and then i switch on the lights in the kitchen.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'chair', 'walllamp', 'bathroom', 'drawing', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'toaster', 'mat', 'ceilinglamp', 'plate', 'stovefan', 'dish_soap', 'broom', 'wall', 'bench', 'food_food', 'coffe_maker', 'tray', 'wooden_spoon', 'towel_rack', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'table', 'dishwasher', 'instrument_violin']
Task:Wash dishes with dishwasher
response:
{
"thoughts": I go the in kitchen then grab the plate on the table. I put the plate and dish soap in the dishwasher. Finally, I turn on the dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['filing_cabinet', 'food_salt', 'chair', 'bathroom', 'knifeblock', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'desk', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'homework', 'mousepad', 'form', 'powersocket', 'bench', 'light_bulb', 'check', 'television', 'tray', 'curtain', 'chessboard', 'cupboard', 'home_office']
Task:Pick up phone
response:
| {
"thoughts": "I walk to the home office, find where the phone is and lift the reciever.",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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>']
}
|
Scene_Objects:['food_pizza', 'chair', 'walllamp', 'orchid', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'powersocket', 'oven', 'bench', 'photoframe', 'television', 'curtain', 'food_onion', 'doorjamb', 'towel_rack', 'bathroom_cabinet', 'light', 'home_office']
Task:Watch TV
response:
| {
"thoughts": "Walk to living room. Find remote control. Find television. Point remote at television. Press \"on\" button. Watch.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[FIND] <remote_control>",
"[TURNTO] <television>",
"[POINTAT] <television>",
"[FIND] <button>",
"[PUSH] <button>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'toilet', 'dog', 'band-aids', 'walllamp', 'ground_coffee', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'phone', 'food_cake', 'computer', 'toaster', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'table', 'light', 'scrabble']
Task:Relax on sofa
response:
{
"thoughts": I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['tablelamp', 'crayon', 'detergent', 'trashcan', 'orchid', 'wallshelf', 'bathroom_counter', 'ceiling', 'keyboard', 'stovefan', 'tvstand', 'shower', 'window', 'mousepad', 'dining_room', 'wall', 'basket_for_clothes', 'television', 'centerpiece', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'clothes_dress', 'laundry_detergent', 'door', 'sink', 'table', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
| {
"thoughts": "Walk to the kitchen. Find the washing machine. Open the washing machine. Find the basket for clothes. Find the clothes_dress. Grab the clothes_dress. Put the clothes_dress into the washing machine. Find the clothes_shirt. Grab the clothes_shirt. Put the clothes_shirt into the washing machine. Close the washing machine. Switch on the washing machine.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <washing_machine>",
"[FIND] <washing_machine>",
"[OPEN] <washing_machine>",
"[FIND] <basket_for_clothes>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[PUTBACK] <clothes_dress> <washing_machine>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUTBACK] <clothes_shirt> <basket_for_clothes>",
"[CLOSE] <washing_machine>",
"[SWITCHON] <washing_machine>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table', 'clothes_skirt']
Task:Write an email
response:
{
"thoughts": enter office, find computer, turn it on,,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TOUCH] <keyboard>', '[TYPE] <keyboard>']
}
|
Scene_Objects:['sheets', 'freezer', 'detergent', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'bookshelf', 'mail', 'toaster', 'ceilinglamp', 'faucet', 'window', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'pencil', 'vacuum_cleaner', 'light']
Task:Turn on light
response:
| {
"thoughts": "switching on light in an area",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['jelly', 'trashcan', 'food_carrot', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'keyboard', 'bookshelf', 'mop_bucket', 'tvstand', 'iron', 'oil', 'food_noodles', 'mousepad', 'dustpan', 'towel', 'nightstand', 'cup', 'light_bulb', 'razor', 'food_donut', 'rag', 'shaving_cream', 'towel_rack', 'pencil', 'kitchen_counter', 'bag', 'bathroom_cabinet', 'dishwasher']
Task:Listen to music
response:
{
"thoughts": I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'knife', 'knifeblock', 'wallshelf', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'bedroom', 'desk', 'bookshelf', 'toaster', 'stovefan', 'faucet', 'dustpan', 'wall', 'oven', 'food_food', 'food_donut', 'tray', 'after_shave', 'pencil', 'kitchen_counter', 'cupboard', 'food_steak', 'sink']
Task:Cook some food
response:
| {
"thoughts": "Walk into kitchen. Open fridge. Take food from fridge. Close fridge. Put food on kitchen counter. Prepare food. Turn on stove. Open kitchen cabinet. Take pot. Close cabinet. Put food in pot. Put pot on stove. Cook food.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[FIND] <kitchen_counter>",
"[PUTBACK] <food_food> <kitchen_counter>",
"[CLOSE] <freezer>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <pot>",
"[GRAB] <pot>",
"[CLOSE] <kitchen_cabinet>",
"[FIND] <oven>",
"[PUTBACK] <pot> <oven>",
"[GRAB] <food_food>",
"[PUTBACK] <food_food> <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:['walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_pants', 'form', 'pillow', 'towel', 'wall', 'powersocket', 'bench', 'newspaper', 'television', 'curtain', 'doorjamb', 'mouse', 'hair', 'door', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Watch TV
response:
{
"thoughts": SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['food_pizza', 'freezer', 'band-aids', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stamp', 'desk', 'stovefan', 'shoe-shine_kit', 'couch', 'pillow', 'wall', 'bench', 'coffe_maker', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'cupboard', 'door', 'sink', 'bathtub', 'instrument_guitar', 'light', 'home_office', 'clothes_skirt']
Task:Turn on light
response:
| {
"thoughts": "I walk to room. I enter room. I find where the lightswitch is. I turn on the lights with the lightswitch.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <light>",
"[FIND] <light>",
"[TURNTO] <light>",
"[LOOKAT] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'picture', 'tooth_paste', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'check', 'television', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'bathroom_cabinet', 'board_game']
Task:Put groceries in Fridge
response:
{
"thoughts": Walk to the kitchen. Open the fridge, take the groceries and put in it. Closed 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:['pot', 'food_salt', 'measuring_cup', 'microwave', 'freezer', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'phone', 'bedroom', 'desk', 'button', 'stereo', 'faucet', 'picture', 'pillow', 'dining_room', 'nightstand', 'wall', 'bed', 'check', 'toothbrush_holder', 'tray', 'dresser', 'sink', 'home_office', 'table', 'dishwasher']
Task:Listen to music
response:
| {
"thoughts": "Find the radio; switch on the radio and listen to music.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'crayon', 'detergent', 'ceilingfan', 'food_carrot', 'milk', 'drawing', 'knifeblock', 'food_egg', 'floor', 'phone', 'desk', 'bookshelf', 'envelope', 'ceilinglamp', 'window', 'mousepad', 'couch', 'wall', 'food_cheese', 'novel', 'television', 'food_rice', 'after_shave', 'towel_rack', 'kitchen_counter', 'comb', 'table', 'dishwasher', 'creditcard']
Task:Relax on sofa
response:
{
"thoughts": I walk to the living room and find the sofa. I sit on the sofa and get comfortable.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['pot', 'tablelamp', 'blender', 'freezer', 'detergent', 'food_carrot', 'food_egg', 'wallshelf', 'floor', 'ceiling', 'food_cake', 'computer', 'ceilinglamp', 'stereo', 'shower', 'foundation', 'faucet', 'oil', 'broom', 'nightstand', 'oven', 'powersocket', 'newspaper', 'coffe_maker', 'television', 'cupboard', 'bathtub', 'napkin', 'bathroom_cabinet', 'light']
Task:Listen to music
response:
| {
"thoughts": "Go to the living room. Find the radio. Turn on the radio.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'chair', 'band-aids', 'bathroom_counter', 'character', 'desk', 'keyboard', 'purse', 'mat', 'tvstand', 'faucet', 'stereo', 'shower', 'oven', 'cup', 'clothes_gloves', 'novel', 'television', 'oven_mitts', 'wooden_spoon', 'curtain', 'pencil', 'kitchen_counter', 'paper_towel', 'coffee', 'cupboard', 'laundry_detergent', 'dishwasher', 'hands_both']
Task:Go to toilet
response:
{
"thoughts": Walking towards Toilet room, And dispose of human waste. Cleaning your hands with tissue paper or water.,
"actions": ['[WALK] <bathroom>', '[WALK] <paper_towel>', '[FIND] <paper_towel>', '[TURNTO] <paper_towel>', '[LOOKAT] <paper_towel>', '[GRAB] <paper_towel>', '[FIND] <hands_both>', '[WIPE] <hands_both>']
}
|
Scene_Objects:['food_pizza', 'tablelamp', 'food_oatmeal', 'chair', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'toaster', 'window', 'clothes_hat', 'dining_room', 'food_cereal', 'wall', 'food_vegetable', 'food_food', 'television', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'pajamas']
Task:Put groceries in Fridge
response:
| {
"thoughts": "Walk to kitchen, find groceries in cabinet and move them to fridge and close fridge.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[PUTIN] <food_vegetable> <freezer>",
"[FIND] <food_carrot>",
"[GRAB] <food_carrot>",
"[PUTIN] <food_carrot> <freezer>",
"[FIND] <food_cereal>",
"[GRAB] <food_cereal>",
"[PUTIN] <food_cereal> <freezer>",
"[FIND] <food_oatmeal>",
"[GRAB] <food_oatmeal>",
"[PUTIN] <food_oatmeal> <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTIN] <food_food> <freezer>",
"[FIND] <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'jelly', 'walllamp', 'bathroom', 'knife', 'wallshelf', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'television', 'toothbrush_holder', 'wooden_spoon', 'kettle', 'shoes', 'cupboard', 'conditioner', 'clothes_dress', 'door', 'napkin', 'light']
Task:Read book
response:
{
"thoughts": Pick up a book and open to the last page you were on. Read the book.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <bookmark>', '[READ] <novel>']
}
|
Scene_Objects:['chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'stereo', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light']
Task:Watch TV
response:
| {
"thoughts": "go to living room, sit on couch, get remote, switch on tv, watch tv",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'freezer', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'mat', 'shower', 'mousepad', 'wall', 'powersocket', 'oven', 'bench', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'table', 'light', 'coffee']
Task:Browse internet
response:
{
"thoughts": I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser.,
"actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Scene_Objects:['spectacles', 'filing_cabinet', 'tablelamp', 'juice', 'food_salt', 'microwave', 'chair', 'freezer', 'detergent', 'trashcan', 'toothbrush', 'floor', 'ceiling', 'bookshelf', 'toaster', 'shower', 'stereo', 'mousepad', 'clothes_pants', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'food_food', 'check', 'food_donut', 'kitchen_counter', 'cupboard', 'door', 'home_office']
Task:Cook some food
response:
| {
"thoughts": "Go kitchen and make something for eat",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <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:['dog', 'food_egg', 'bathroom_counter', 'folder', 'bedroom', 'computer', 'table_cloth', 'piano_bench', 'stovefan', 'tvstand', 'faucet', 'foundation', 'homework', 'couch', 'nightstand', 'powersocket', 'oven', 'basket_for_clothes', 'cup', 'keys', 'food_food', 'mouthwash', 'after_shave', 'doorjamb', 'shoes', 'controller', 'maindoor', 'bag', 'dirt', 'coffee']
Task:Get ready to leave
response:
{
"thoughts": Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave,
"actions": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <keys>', '[GRAB] <keys>']
}
|
Scene_Objects:['sheets', 'pot', 'food_bread', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'shower', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'console', 'dresser', 'hair', 'door', 'bathroom_cabinet', 'table', 'light', 'soap']
Task:Relax on sofa
response:
| {
"thoughts": "I go to the living room and sit in the sofa",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[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:['spectacles', 'sheets', 'filing_cabinet', 'food_salt', 'toilet', 'band-aids', 'walllamp', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'phone', 'computer', 'mop_bucket', 'stovefan', 'tvstand', 'deck_of_cards', 'closetdrawer', 'newspaper', 'coffe_maker', 'doorjamb', 'dresser', 'cupboard', 'door', 'food_steak', 'bag', 'sink', 'table', 'dishwasher', 'bathroom_cabinet']
Task:Put umbrella away
response:
{
"thoughts": Place the umbrella in the umbrella bucket point first.,
"actions": ['[WALK] <home_office>', '[WALK] <mop_bucket>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'faucet', 'couch', 'food_jam', 'pillow', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'table', 'light']
Task:Watch TV
response:
| {
"thoughts": "you go into the living room, sit on a chair/sofa, grab remote control, turn on tv, change channels, then watch somethign fun.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'food_salt', 'walllamp', 'bathroom', 'trashcan', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'tvstand', 'shower', 'faucet', 'towel', 'wall', 'cup', 'keys', 'food_food', 'television', 'water', 'curtain', 'lighter', 'kitchen_counter', 'shoes', 'door', 'table', 'light', 'soap', 'teeth']
Task:Take shower
response:
{
"thoughts": go to a bathroom, open the shower, let water wash your body,
"actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']
}
|
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'jelly', 'freezer', 'bathroom', 'drawing', 'orchid', 'character', 'folder', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'food_noodles', 'couch', 'clothes_hat', 'towel', 'nightstand', 'powersocket', 'rag', 'towel_rack', 'pencil', 'kitchen_counter', 'cupboard', 'pajamas', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']
Task:Wash hands
response:
| {
"thoughts": "I walk to the kitchen and get the soap and wash my both hand using the soap and rinse my hands and use towel.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <soap>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[SCRUB] <soap>",
"[FIND] <towel>",
"[RINSE] <towel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'microwave', 'toilet', 'walllamp', 'drawing', 'bills', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'television', 'tray', 'curtain', 'towel_rack', 'pencil', 'kitchen_counter', 'bathtub', 'spoon', 'table']
Task:Watch TV
response:
{
"thoughts": Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['pot', 'tablelamp', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'food_cake', 'mat', 'faucet', 'mousepad', 'couch', 'wall', 'oven', 'bench', 'toilet_paper', 'television', 'water', 'drinking_glass', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'table']
Task:Drink
response:
| {
"thoughts": "I go to the kitchen to get a glass from the cabinet. I turn on the faucet and fill up the glass. I take a drink.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <drinking_glass>",
"[GRAB] <drinking_glass>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[PUTBACK] <drinking_glass> <sink>",
"[FIND] <water>",
"[GRAB] <drinking_glass>",
"[PUTBACK] <drinking_glass> <sink>",
"[GRAB] <drinking_glass>",
"[DRINK] <drinking_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:['sponge', 'chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'tvstand', 'shower', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'oven', 'bench', 'shelf', 'check', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'light', 'table', 'vase']
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>']
}
|
Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'foundation', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'door', 'table', 'light', 'coffee']
Task:Watch TV
response:
| {
"thoughts": "I walk into the living room and sit on the sofa to watch tv",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'pot', 'tablelamp', 'blender', 'microwave', 'toilet', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'shampoo', 'character', 'desk', 'keyboard', 'computer', 'mousepad', 'wall', 'bench', 'powersocket', 'photoframe', 'television', 'tray', 'mouse', 'dresser', 'controller', 'maindoor', 'home_office', 'clothes_skirt']
Task:Go to toilet
response:
{
"thoughts": Walk to bathroom, find toilet.,
"actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>']
}
|
Scene_Objects:['sponge', 'filing_cabinet', 'microwave', 'freezer', 'trashcan', 'bathroom_counter', 'ceiling', 'desk', 'stovefan', 'stereo', 'shower', 'mousepad', 'dustpan', 'clothes_pants', 'dining_room', 'powersocket', 'bench', 'bed', 'toilet_paper', 'food_food', 'wine', 'mouse', 'pencil', 'kitchen_counter', 'cd', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Listen to music
response:
| {
"thoughts": "walk to living room ,find radio ,switch on radio ,listen to music 4",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'tvstand', 'faucet', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'food_orange', 'wall', 'powersocket', 'shelf', 'food_food', 'oven_mitts', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'vacuum_cleaner', 'dresser', 'light', 'table']
Task:Turn on light
response:
{
"thoughts": approach the light switch, raise hand to the switch, flip the switch,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['tablelamp', 'freezer', 'bathroom', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'bookshelf', 'shower', 'homework', 'wall', 'powersocket', 'box', 'bed', 'coffe_maker', 'television', 'after_shave', 'doorjamb', 'towel_rack', 'mouse', 'cards', 'cupboard', 'home_office', 'light', 'dishwasher']
Task:Turn on light
response:
| {
"thoughts": "Walk into living room. Find wall. Find light button. Switch on light button.",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'clothes_jacket', 'table_cloth', 'mat', 'floor_lamp', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'light_bulb', 'novel', 'mouthwash', 'television', 'ice', 'curtain', 'after_shave', 'doorjamb', 'console', 'kettle', 'conditioner', 'bathtub', 'sink', 'table', 'vase']
Task:Read book
response:
{
"thoughts": A person brings a book into the living room and sits down in a comfortable chair. If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read. The person begins reading the book until they need to stop for some reason.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <novel>']
}
|
Scene_Objects:['freezer', 'drawing', 'orchid', 'knifeblock', 'hanger', 'floor', 'ceiling', 'dvd_player', 'stamp', 'bedroom', 'desk', 'keyboard', 'toaster', 'faucet', 'shower', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'bed', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'home_office', 'table', 'light', 'dishwasher']
Task:Listen to music
response:
| {
"thoughts": "walk to living room, look at the DVD player, switch on the dvd player, look at the sofa, sit on the sofa and listen the music",
"actions": [
"[WALK] <home_office>",
"[WALK] <dvd_player>",
"[FIND] <dvd_player>",
"[TURNTO] <dvd_player>",
"[LOOKAT] <dvd_player>",
"[SWITCHON] <dvd_player>",
"[FIND] <couch>",
"[TURNTO] <couch>",
"[LOOKAT] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'television', 'oven_mitts', 'tray', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Watch TV
response:
{
"thoughts": Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <chair>', '[SIT] <chair>', '[TURNTO] <television>', '[WATCH] <television>', '[SWITCHOFF] <television>']
}
|
Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'character', 'bookshelf', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'bed', 'novel', 'television', 'tray', 'doorjamb', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'light', 'table', 'laser_pointer']
Task:Pick up phone
response:
| {
"thoughts": "My friend is calling and I want to pick up the phone and chat with him for a little while on the couch.",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[FIND] <phone>",
"[GRAB] <phone>",
"[WALK] <couch>",
"[SIT] <couch>",
"[LIE] <couch>",
"[TYPE] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'plate', 'faucet', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'powersocket', 'box', 'photoframe', 'novel', 'food_food', 'television', 'food_donut', 'curtain', 'doorjamb', 'bathroom_cabinet']
Task:Read book
response:
{
"thoughts": Sit on couch. Grab book. Open book. Read book.,
"actions": ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['water_glass', 'food_bread', 'food_ice_cream', 'crayon', 'microwave', 'chair', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'tvstand', 'window', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'water', 'tray', 'cupboard', 'sink', 'bathroom_cabinet', 'table', 'light', 'instrument_violin']
Task:Drink
response:
| {
"thoughts": "walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass",
"actions": [
"[WALK] <dining_room>",
"[WALK] <table>",
"[FIND] <table>",
"[FIND] <water_glass>",
"[GRAB] <water_glass>",
"[FIND] <water>",
"[GRAB] <water>",
"[WALK] <water>",
"[POUR] <water> <water_glass>",
"[DRINK] <water_glass>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'freezer', 'walllamp', 'bathroom', 'dough', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'bookmark', 'stovefan', 'brush', 'deck_of_cards', 'faucet', 'window', 'closetdrawer', 'dining_room', 'wall', 'oven', 'cutting_board', 'cup', 'bed', 'coffe_maker', 'food_food', 'tray', 'shaving_cream', 'kitchen_counter', 'chessboard', 'clothes_dress', 'conditioner']
Task:Drink
response:
{
"thoughts": Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup,
"actions": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[TURNTO] <cup>', '[LOOKAT] <cup>', '[WALK] <cup>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[WALK] <freezer>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>']
}
|
Scene_Objects:['pot', 'blender', 'tea', 'microwave', 'walllamp', 'bathroom', 'knifeblock', 'floor', 'desk', 'tea_bag', 'bookshelf', 'computer', 'bookmark', 'toaster', 'faucet', 'stereo', 'dish_soap', 'dining_room', 'wall', 'nightstand', 'bench', 'coffe_maker', 'razor', 'tray', 'kitchen_counter', 'cupboard', 'controller', 'sink', 'bathtub', 'dishwasher']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "Walk to Kitchen. Look at sink. Grab dish soap. Open dishwasher. Put dish soap in dishwasher. Close dishwasher. Switch on dishwasher.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <sink>",
"[TURNTO] <sink>",
"[LOOKAT] <sink>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['toilet', 'freezer', 'food_butter', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'mop_bucket', 'ceilinglamp', 'tvstand', 'iron', 'window', 'mousepad', 'microphone', 'towel', 'dining_room', 'bowl', 'wall', 'powersocket', 'bench', 'cup', 'novel', 'television', 'coin', 'rag', 'doorjamb', 'headset', 'light']
Task:Turn on light
response:
| {
"thoughts": "I walk in to the living room. I find the light switch. I turn on the lights.",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'chair', 'walllamp', 'cat', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'box', 'photoframe', 'television', 'doorjamb', 'dresser', 'conditioner', 'door', 'coffee']
Task:Watch TV
response:
{
"thoughts": We sit all around the television and watch a program.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUTBACK] <remote_control> <couch>', '[WATCH] <television>']
}
|
Scene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'faucet', 'stereo', 'shower', 'candle', 'wall', 'oven', 'cup', 'photoframe', 'water', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'bathroom_cabinet', 'light']
Task:Drink
response:
| {
"thoughts": "Walk to kitchen, walk to cupboard, open cupboard, grab cup, walk to sink, pour water in cup, drink water.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[WALK] <sink>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <cup>",
"[DRINK] <cup>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'freezer', 'walllamp', 'blow_dryer', 'milk', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'food_cake', 'alcohol', 'stovefan', 'homework', 'closetdrawer', 'pillow', 'broom', 'wall', 'oven', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'kitchen_counter', 'shoes', 'sink', 'light', 'table']
Task:Drink
response:
{
"thoughts": Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']
}
|
Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'phone', 'ceiling', 'bookshelf', 'computer', 'table_cloth', 'toaster', 'mat', 'picture', 'wall', 'powersocket', 'bench', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'sink', 'bathroom_cabinet', 'light']
Task:Turn on light
response:
| {
"thoughts": "I walk into the dining room and turn on the lights",
"actions": [
"[WALK] <dining_room>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'toilet', 'trashcan', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'thread', 'computer', 'piano_bench', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'oven', 'bed', 'novel', 'check', 'television', 'curtain', 'towel_rack', 'dresser', 'vase']
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>']
}
|
Scene_Objects:['glue', 'tablelamp', 'microwave', 'drawing', 'knife', 'bedroom', 'tea_bag', 'computer', 'brush', 'ceilinglamp', 'plate', 'faucet', 'mousepad', 'oil', 'pillow', 'wall', 'powersocket', 'tape', 'photoframe', 'light_bulb', 'novel', 'check', 'television', 'wooden_spoon', 'curtain', 'tray', 'shaving_cream', 'clothes_scarf', 'sink', 'dishwasher']
Task:Browse internet
response:
| {
"thoughts": "Go to home office, turn on the computer, open the internet and browse around the internet.",
"actions": [
"[WALK] <home_office>",
"[WALK] <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', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'oven', 'photoframe', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light', 'table']
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:['band-aids', 'trashcan', 'wallshelf', 'clothes_underwear', 'desk', 'keyboard', 'mail', 'computer', 'tvstand', 'shower', 'window', 'clothes_socks', 'couch', 'food_peanut_butter', 'pillow', 'basket_for_clothes', 'keys', 'coffe_maker', 'television', 'food_donut', 'tray', 'rag', 'headset', 'clothes_scarf', 'bathtub', 'sink', 'light', 'dishwasher', 'soap', 'washing_machine']
Task:Wash clothes
response:
| {
"thoughts": "Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine",
"actions": [
"[WALK] <bedroom>",
"[WALK] <basket_for_clothes>",
"[FIND] <basket_for_clothes>",
"[OPEN] <basket_for_clothes>",
"[GRAB] <basket_for_clothes>",
"[WALK] <bathroom>",
"[WALK] <washing_machine>",
"[FIND] <washing_machine>",
"[OPEN] <washing_machine>",
"[PUTBACK] <basket_for_clothes> <washing_machine>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[PUTBACK] <soap> <washing_machine>",
"[FIND] <washing_machine>",
"[CLOSE] <washing_machine>",
"[SWITCHON] <washing_machine>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'console', 'dresser', 'cupboard', 'home_office', 'table', 'clothes_skirt', 'vase']
Task:Watch TV
response:
{
"thoughts": Watch the television,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[SWITCHON] <television>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['tablelamp', 'beer', 'toilet', 'freezer', 'cpuscreen', 'clothes_underwear', 'wallshelf', 'shampoo', 'character', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'clothes_pants', 'dining_room', 'bench', 'powersocket', 'photoframe', 'coffe_maker', 'mouse', 'paper_towel', 'dresser', 'door', 'bathtub', 'bathroom_cabinet', 'light', 'hands_both']
Task:Go to toilet
response:
| {
"thoughts": "Walking towards Toilet room, And dispose of human waste. Cleaning your hands with tissue paper or water.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <paper_towel>",
"[FIND] <paper_towel>",
"[TURNTO] <paper_towel>",
"[LOOKAT] <paper_towel>",
"[GRAB] <paper_towel>",
"[FIND] <hands_both>",
"[WIPE] <hands_both>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'computer', 'mat', 'shower', 'mousepad', 'couch', 'form', 'pillow', 'wall', 'wall_clock', 'powersocket', 'bench', 'oven', 'tape', 'bed', 'check', 'doorjamb', 'cd', 'hair', 'door', 'table', 'light']
Task:Relax on sofa
response:
| {
"thoughts": "I sit on the sofa. I put my legs on the sofa and recline.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[LIE] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'scissors', 'toilet', 'jelly', 'ground_coffee', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'clothes_jacket', 'faucet', 'mousepad', 'wall', 'oven', 'cup', 'photoframe', 'video_game_controller', 'television', 'tray', 'doorjamb', 'mouse', 'conditioner', 'sink', 'bathroom_cabinet', 'home_office', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Go to the bathroom and wash hands.,
"actions": ['[RUN] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <sink>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[GRAB] <soap>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']
}
|
Scene_Objects:['drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'mat', 'tvstand', 'shower', 'shoe-shine_kit', 'window', 'mousepad', 'clothes_socks', 'couch', 'food_noodles', 'pillow', 'wall', 'bed', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'bathtub', 'sink', 'home_office', 'light', 'table']
Task:Turn on light
response:
| {
"thoughts": "Walk into the bedroom and walk to the light switch. Flip the switch.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'cat', 'trashcan', 'milk', 'hanger', 'bathroom_counter', 'desk', 'mousepad', 'closetdrawer', 'clothes_pants', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'tray', 'curtain', 'chessboard', 'shoes', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'table']
Task:Pet cat
response:
{
"thoughts": Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <milk>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[TURNTO] <cat>', '[POINTAT] <cat>']
}
|
Scene_Objects:['walllamp', 'trashcan', 'phone', 'ceiling', 'character', 'desk', 'bookmark', 'toaster', 'stovefan', 'shoe-shine_kit', 'shower', 'window', 'wall', 'pasta', 'oven', 'powersocket', 'clothes_gloves', 'novel', 'coffe_maker', 'check', 'coin', 'curtain', 'doorjamb', 'cards', 'towel_rack', 'kitchen_counter', 'chessboard', 'napkin', 'bathroom_cabinet', 'light']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'detergent', 'food_butter', 'trashcan', 'hanger', 'floor', 'phone', 'ceiling', 'bedroom', 'computer', 'button', 'mat', 'laptop', 'plate', 'window', 'wall', 'nightstand', 'bed', 'check', 'curtain', 'doorjamb', 'dresser', 'cupboard', 'controller', 'door', 'light', 'dishwasher', 'laser_pointer', 'shoe_rack']
Task:Pick up phone
response:
{
"thoughts": first i will go to home office and switch on the lights and answer the call after then i will put back it and switch off the lights and close the door,
"actions": ['[RUN] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <phone>', '[GRAB] <phone>', '[PUTOBJBACK] <phone>', '[SWITCHOFF] <light>']
}
|
Scene_Objects:['pot', 'beer', 'mop', 'chair', 'freezer', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'shower', 'window', 'food_orange', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'spoon', 'table', 'light', 'coffee']
Task:Put groceries in Fridge
response:
| {
"thoughts": "I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'food_salt', 'microwave', 'walllamp', 'dough', 'hanger', 'ceiling', 'phone', 'character', 'keyboard', 'bookmark', 'toaster', 'mat', 'tvstand', 'stereo', 'window', 'oil', 'food_peanut_butter', 'tape', 'check', 'video_game_controller', 'razor', 'oven_mitts', 'food_rice', 'curtain', 'kitchen_counter', 'hairbrush', 'food_steak', 'bathroom_cabinet', 'home_office']
Task:Listen to music
response:
{
"thoughts": I walk into the bedroom. I walk to stereo. I turn on stereo.,
"actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['filing_cabinet', 'bathroom', 'detergent', 'food_carrot', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'thread', 'stereo', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'cup', 'coffe_maker', 'curtain', 'doorjamb', 'kitchen_counter', 'hair', 'door', 'sink', 'spoon', 'table', 'light']
Task:Relax on sofa
response:
| {
"thoughts": "Walk to the living room, turn to the sofa. Sit on the sofa and relax.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[TURNTO] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'ground_coffee', 'walllamp', 'knife', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bedroom', 'button', 'stovefan', 'mat', 'shower', 'clothes_socks', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'bed', 'light_bulb', 'check', 'video_game_controller', 'mouthwash', 'food_onion', 'vacuum_cleaner', 'pajamas', 'cupboard', 'hair', 'instrument_guitar']
Task:Go to sleep
response:
{
"thoughts": go to bedroom, put pajamas on, lie in bed, sleep,
"actions": ['[WALK] <bedroom>', '[WALK] <pajamas>', '[FIND] <pajamas>', '[GRAB] <pajamas>', '[PUTON] <pajamas>', '[FIND] <bed>', '[LIE] <bed>']
}
|
Scene_Objects:['pot', 'blender', 'toilet', 'bathroom', 'detergent', 'trashcan', 'drawing', 'knife', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'button', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'bench', 'food_cheese', 'bed', 'television', 'doorjamb', 'mouse', 'pencil', 'door', 'bathtub', 'napkin', 'light', 'table']
Task:Turn on light
response:
| {
"thoughts": "Walk to the bedroom and use the button on the wall, next to the door to turn on the lights.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[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', 'filing_cabinet', 'tablelamp', 'crayon', 'microwave', 'toilet', 'detergent', 'milk', 'folder', 'bedroom', 'toaster', 'stovefan', 'balanceball', 'stereo', 'window', 'mousepad', 'food_noodles', 'dining_room', 'nightstand', 'box', 'newspaper', 'tray', 'lighter', 'headset', 'controller', 'door', 'maindoor', 'instrument_guitar', 'table', 'soap']
Task:Walk through
response:
{
"thoughts": Walk through the entrance hall,
"actions": ['[WALK] <home_office>', '[WALK] <home_office>']
}
|
Scene_Objects:['chair', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'button', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'faucet', 'mousepad', 'dining_room', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'rag', 'doorjamb', 'kitchen_counter', 'light', 'table']
Task:Change TV channel
response:
| {
"thoughts": "walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[SWITCHON] <television>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <button>",
"[GRAB] <button>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'dustpan', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door']
Task:Watch youtube
response:
{
"thoughts": Go to youtube.Com watch videos,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}
|
Scene_Objects:['microwave', 'toilet', 'walllamp', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'wallshelf', 'food_egg', 'floor', 'ceiling', 'character', 'stovefan', 'tvstand', 'couch', 'candle', 'pillow', 'dining_room', 'wall', 'novel', 'check', 'video_game_controller', 'coffe_maker', 'doorjamb', 'towel_rack', 'cupboard', 'controller', 'door', 'table', 'light']
Task:Read book
response:
| {
"thoughts": "Sit on couch. Grab book. Open book. Read book.",
"actions": [
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'floor', 'character', 'bookshelf', 'computer', 'toaster', 'mat', 'plate', 'window', 'food_noodles', 'food_orange', 'wall', 'oven', 'photoframe', 'keys', 'bed', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'clothes_dress', 'napkin', 'home_office', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['freezer', 'floor', 'ceiling', 'character', 'computer', 'brush', 'mat', 'tvstand', 'iron', 'foundation', 'mousepad', 'couch', 'food_kiwi', 'oven', 'powersocket', 'bench', 'toilet_paper', 'coin', 'food_rice', 'after_shave', 'doorjamb', 'kitchen_counter', 'dresser', 'conditioner', 'bathtub', 'home_office', 'dishwasher', 'soap', 'dirt', '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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'food_pizza', 'juice', 'board_game', 'dog', 'food_butter', 'orchid', 'drawing', 'bathroom_counter', 'bookshelf', 'stovefan', 'mat', 'laptop', 'tvstand', 'picture', 'window', 'couch', 'nightstand', 'wall_clock', 'toy', 'clothes_gloves', 'toilet_paper', 'television', 'ice', 'bathroom_cabinet', 'table', 'light', 'vase', 'instrument_violin']
Task:Set up table
response:
{
"thoughts": Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room,
"actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <home_office>', '[DROP] <plate>', '[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <home_office>', '[DROP] <cup>', '[WALK] <dining_room>', '[WALK] <fork>', '[FIND] <fork>', '[GRAB] <fork>', '[WALK] <home_office>', '[DROP] <fork>']
}
|
Scene_Objects:['tablelamp', 'beer', 'microwave', 'chair', 'freezer', 'ground_coffee', 'detergent', 'bills', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'alcohol', 'table_cloth', 'toaster', 'stovefan', 'wall', 'oven', 'bench', 'food_food', 'wooden_spoon', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'home_office', 'light', 'soap', 'scrabble']
Task:Put groceries in Fridge
response:
| {
"thoughts": "Walk to kitchen counter, grab a grocery, walk to fridge, open fridge, put the grocery into fridge, and close fridge",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_counter>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'dresser', 'hairbrush', 'clothes_dress', 'door', 'sink', 'spoon', 'table', 'light']
Task:Change TV channel
response:
{
"thoughts": I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'plate', 'mousepad', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'television', 'wine', 'curtain', 'doorjamb', 'light']
Task:Watch TV
response:
| {
"thoughts": "Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'cd_player', 'blow_dryer', 'bathroom', 'detergent', 'orchid', 'bills', 'bathroom_counter', 'phone', 'bedroom', 'remote_control', 'thread', 'button', 'mat', 'ceilinglamp', 'couch', 'pillow', 'dining_room', 'broom', 'wall_clock', 'powersocket', 'bench', 'box', 'coffe_maker', 'razor', 'towel_rack', 'vacuum_cleaner', 'bathtub', 'dishwasher', 'soap']
Task:Listen to music
response:
{
"thoughts": I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton,
"actions": ['[WALK] <home_office>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[PLUGIN] <cd_player>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']
}
|
Scene_Objects:['chair', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'shower', 'window', 'homework', 'mousepad', 'pillow', 'powersocket', 'photoframe', 'coffe_maker', 'doorjamb', 'kettle', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'clothes_dress', 'door', 'bag', 'light', 'washing_machine']
Task:Wash clothes
response:
| {
"thoughts": "Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <clothes_pants>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[WALK] <home_office>",
"[WALK] <washing_machine>",
"[FIND] <washing_machine>",
"[OPEN] <washing_machine>",
"[PUTBACK] <clothes_pants> <washing_machine>",
"[FIND] <laundry_detergent>",
"[GRAB] <laundry_detergent>",
"[PUTBACK] <laundry_detergent> <washing_machine>",
"[CLOSE] <washing_machine>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'freezer', 'walllamp', 'detergent', 'cat', 'knife', 'drawing', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'phone', 'ceiling', 'character', 'faucet', 'window', 'foundation', 'closetdrawer', 'food_orange', 'dining_room', 'coffe_maker', 'check', 'television', 'food_food', 'tray', 'curtain', 'mouse', 'pajamas', 'door', 'bathroom_cabinet']
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:['filing_cabinet', 'chair', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'food_cake', 'button', 'toaster', 'tvstand', 'faucet', 'foundation', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'food_cheese', 'bed', 'toilet_paper', 'coffe_maker', 'doorjamb', 'kettle', 'dresser', 'clothes_dress', 'door', 'table', 'light']
Task:Relax on sofa
response:
| {
"thoughts": "I'm tired and want to relax on the sofa",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'novel', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Browse internet
response:
{
"thoughts": I walk to the home office. I sit on the chair. I switch on the computer. I look at my monitor. I open the browsing application by click the application using mouse. I type the book that I need to searching for (using keyboard). I found the book that I need. I read the book. I switch on the printer. I print the information that I get. I read carefully the book information that I got. I switch off the printer. I switch of the computer.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[SWITCHOFF] <fax_machine>', '[SWITCHOFF] <computer>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'freezer', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'table_cloth', 'ceilinglamp', 'faucet', 'couch', 'clothes_hat', 'pillow', 'wall', 'oven', 'bed', 'photoframe', 'television', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'bathtub', 'bathroom_cabinet', 'table', 'light']
Task:Pet cat
response:
| {
"thoughts": "I would walk into the living room. Then sit on the couch and pet the cat.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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:['pot', 'microwave', 'toilet', 'chair', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'piano_bench', 'ceilinglamp', 'tvstand', 'stereo', 'couch', 'pillow', 'dining_room', 'wall', 'bed', 'food_donut', 'tray', 'curtain', 'doorjamb', 'coffee_pot', 'dresser', 'pajamas', 'door', 'home_office', 'table', 'light', 'instrument_violin']
Task:Relax on sofa
response:
| {
"thoughts": "walk to living room, walk to sofa, sit in sofa",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'freezer', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'envelope', 'computer', 'stereo', 'mousepad', 'closetdrawer', 'oil', 'clothes_pants', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coin', 'rag', 'kettle', 'mouse', 'chessboard', 'dresser', 'light', 'clothes_shirt']
Task:Get dressed
response:
{
"thoughts": Find dresser, grab pants, grab shirt, put on pants, put on shirt,
"actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[CLOSE] <dresser>']
}
|
Scene_Objects:['filing_cabinet', 'mop', 'cd_player', 'chair', 'knifeblock', 'music_stand', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'envelope', 'food_bacon', 'mop_bucket', 'stovefan', 'ceilinglamp', 'shower', 'nightstand', 'bed', 'photoframe', 'coffe_maker', 'tray', 'curtain', 'lighter', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'bathroom_cabinet', '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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'walllamp', 'trashcan', 'dough', 'toothbrush', 'floor', 'dvd_player', 'bedroom', 'stovefan', 'mat', 'tvstand', 'window', 'food_noodles', 'dining_room', 'nightstand', 'powersocket', 'oven', 'cutting_board', 'cup', 'light_bulb', 'coffe_maker', 'mouthwash', 'oven_mitts', 'doorjamb', 'diary', 'bag', 'home_office', 'scrabble']
Task:Pick up phone
response:
{
"thoughts": go to living room, find phone, pick up phone,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['mop', 'microwave', 'freezer', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'piano_bench', 'shoe-shine_kit', 'shower', 'mousepad', 'couch', 'pillow', 'wall', 'tape', 'food_food', 'doorjamb', 'headset', 'cupboard', 'door', 'home_office', 'table', 'light', 'bathroom_cabinet', 'board_game']
Task:Relax on sofa
response:
| {
"thoughts": "I get home from work and walk into the living room. I see the couch and go to sit on it.",
"actions": [
"[WALK] <home_office>",
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[TURNTO] <couch>",
"[LOOKAT] <couch>",
"[WALK] <couch>",
"[SIT] <couch>",
"[LIE] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'toothbrush', 'knife', 'drawing', 'desk', 'bookshelf', 'purse', 'computer', 'table_cloth', 'brush', 'tvstand', 'shoe-shine_kit', 'picture', 'faucet', 'wall', 'bench', 'cutting_board', 'shelf', 'light_bulb', 'razor', 'after_shave', 'doorjamb', 'diary', 'kitchen_counter', 'dishrack', 'dresser', 'home_office', 'table', 'vase', 'dirt']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['pot', 'tablelamp', 'freezer', 'trashcan', 'orchid', 'drawing', 'bills', 'wallshelf', 'cpuscreen', 'knife', 'ceiling', 'character', 'stamp', 'keyboard', 'computer', 'ceilinglamp', 'couch', 'pillow', 'pasta', 'bench', 'oven', 'keys', 'novel', 'mouthwash', 'ice', 'tray', 'towel_rack', 'mouse', 'cupboard', 'bathtub']
Task:Change TV channel
response:
| {
"thoughts": "I walk to the living room. I find the TV remote. I change the channel.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'fork', 'tablelamp', 'food_salt', 'microwave', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'nightstand', 'bed', 'novel', 'television', 'curtain', 'lighter', 'mouse', 'door', 'table', 'dishwasher']
Task:Admire art
response:
{
"thoughts": Looking at painting, art,
"actions": ['[WALK] <home_office>', '[WALK] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']
}
|
Scene_Objects:['spectacles', 'filing_cabinet', 'microwave', 'chair', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'desk', 'keyboard', 'window', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'bed', 'newspaper', 'photoframe', 'food_rice', 'doorjamb', 'mouse', 'cupboard', 'door', 'hairdryer', 'sink', 'table', 'light', 'soap']
Task:Relax on sofa
response:
| {
"thoughts": "go to the living room and sit on the couch, ease into the sofa and relax.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[LIE] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'freezer', 'bathroom', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'light_bulb', 'check', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'clothes_dress', 'door', 'table', 'clothes_shirt']
Task:Pick up phone
response:
{
"thoughts": Walk to living room. Go near telephone. take the receiver and then talk to other person on that side.,
"actions": ['[WALK] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['sheets', 'sponge', 'food_salt', 'tea', 'bathroom', 'detergent', 'knifeblock', 'wallshelf', 'clothes_underwear', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'toaster', 'faucet', 'window', 'clothes_socks', 'clothes_pants', 'pillow', 'bench', 'basket_for_clothes', 'coffe_maker', 'towel_rack', 'clothes_dress', 'laundry_detergent', 'table', 'clothes_skirt', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
| {
"thoughts": "I go to the bathroom, take the dirt clothes and put into the washing machine, then put the soap, set the cleaning program and switch on the machine",
"actions": [
"[WALK] <bathroom>",
"[WALK] <washing_machine>",
"[FIND] <washing_machine>",
"[OPEN] <washing_machine>",
"[FIND] <basket_for_clothes>",
"[OPEN] <basket_for_clothes>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[PUTBACK] <clothes_dress> <washing_machine>",
"[FIND] <clothes_pants>",
"[GRAB] <clothes_pants>",
"[PUTBACK] <clothes_pants> <washing_machine>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUTBACK] <clothes_shirt> <washing_machine>",
"[FIND] <clothes_skirt>",
"[GRAB] <clothes_skirt>",
"[PUTBACK] <clothes_skirt> <washing_machine>",
"[FIND] <clothes_underwear>",
"[GRAB] <clothes_underwear>",
"[PUTBACK] <clothes_underwear> <washing_machine>",
"[FIND] <clothes_socks>",
"[GRAB] <clothes_socks>",
"[PUTBACK] <clothes_socks> <washing_machine>",
"[CLOSE] <basket_for_clothes>",
"[WALK] <laundry_detergent>",
"[FIND] <laundry_detergent>",
"[GRAB] <laundry_detergent>",
"[POUR] <laundry_detergent> <washing_machine>",
"[CLOSE] <washing_machine>",
"[SWITCHON] <washing_machine>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'food_salt', 'detergent', 'orchid', 'bathroom_counter', 'character', 'keyboard', 'remote_control', 'bookshelf', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'dustpan', 'nightstand', 'bench', 'tape', 'cup', 'bed', 'coffee_table', 'wooden_spoon', 'doorjamb', 'towel_rack', 'pencil', 'kitchen_counter', 'cd', 'dresser', 'hair']
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:['dog', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'bathtub', 'sink', 'table', 'light', 'dishwasher']
Task:Relax on sofa
response:
| {
"thoughts": "walk into living room and go to sofa and turn on tv",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[WALK] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <couch>",
"[WALK] <couch>",
"[LIE] <couch>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[DROP] <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:['tablelamp', 'walllamp', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'bed', 'television', 'curtain', 'pencil', 'dresser', 'clothes_dress', 'conditioner', 'table', 'board_game', 'coffee']
Task:Change TV channel
response:
{
"thoughts": Change the channel on the TV in the living room,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>']
}
|
Scene_Objects:['sheets', 'tablelamp', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'stereo', 'faucet', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_food', 'food_donut', 'towel_rack', 'mouse', 'shoes', 'dishrack', 'sink', 'spoon', 'light', 'coffee']
Task:Go to toilet
response:
| {
"thoughts": "Walk to bathroom, find toilet.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <toilet>",
"[FIND] <toilet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'walllamp', 'bathroom', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'pencil', 'door', 'light', 'table']
Task:Change TV channel
response:
{
"thoughts": I push my body to be near to the table in front of me, without stand up. I move my right hand to near the TV remote control on the table. I take the TV remote control. I look the number on the remote control. I touch number 3 button. I put back the remote control to the table. I put my body back to the sofa,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[GRAB] <remote_control>', '[TOUCH] <remote_control>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['pot', 'mop', 'chair', 'freezer', 'walllamp', 'knifeblock', 'clothes_underwear', 'floor', 'ceiling', 'character', 'stovefan', 'toaster', 'plate', 'ceilinglamp', 'faucet', 'pillow', 'wall', 'pasta', 'oven', 'cup', 'food_cheese', 'food_food', 'tray', 'curtain', 'kitchen_counter', 'sauce_pan', 'cupboard', 'sink', 'spoon', 'coffee']
Task:Cook some food
response:
| {
"thoughts": "I pull a sauce pan from the cupboard. I turn the stove on. I take my ingredients from the pantry and fridge. I put the ingredients in the pan and I mix them with a spoon. I cook until the food is finished and transfer my food to a plate.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[FIND] <pot>",
"[GRAB] <pot>",
"[FIND] <spoon>",
"[GRAB] <spoon>",
"[FIND] <sauce_pan>",
"[PUTBACK] <spoon> <sauce_pan>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <plate>",
"[PUTBACK] <pot> <plate>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'mop', 'microwave', 'trashcan', 'food_egg', 'keyboard', 'mop_bucket', 'bookmark', 'mat', 'tvstand', 'mousepad', 'tooth_paste', 'food_noodles', 'food_jam', 'form', 'pillow', 'dining_room', 'food_kiwi', 'toy', 'keys', 'check', 'mouthwash', 'coffee_filter', 'shaving_cream', 'comb', 'maindoor', 'light', 'board_game', 'teeth', 'creditcard']
Task:Pick up phone
response:
{
"thoughts": walk to living room, walk to the phone reach for the phone and pick up the phone.,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TOUCH] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['dog', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'coffe_maker', 'television', 'coin', 'curtain', 'doorjamb', 'coffee_pot', 'door', 'table', 'light']
Task:Watch TV
response:
| {
"thoughts": "I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TOUCH] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'pot', 'jelly', 'freezer', 'bathroom', 'trashcan', 'milk', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'alcohol', 'table_cloth', 'faucet', 'shower', 'form', 'powersocket', 'bench', 'bed', 'food_food', 'kitchen_counter', 'headset', 'vacuum_cleaner', 'cupboard', 'door', 'clothes_scarf', 'food_steak', 'soap']
Task:Grab things
response:
{
"thoughts": The robot will need some kind of hands or grabbing device to transport objects.,
"actions": ['[WALK] <novel>', '[TURNTO] <novel>', '[GRAB] <novel>']
}
|
Scene_Objects:['beer', 'mop', 'walllamp', 'knife', 'wallshelf', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'stamp', 'keyboard', 'toaster', 'plate', 'shower', 'faucet', 'dish_soap', 'wall', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'check', 'towel_rack', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'conditioner', 'bathtub', 'dishwasher']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet..",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>",
"[GRAB] <plate>",
"[WIPE] <plate>",
"[FIND] <dishrack>",
"[GRAB] <dishrack>",
"[PUTOBJBACK] <dishrack>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['toilet', 'chair', 'freezer', 'detergent', 'hanger', 'bathroom_counter', 'shampoo', 'ceiling', 'desk', 'bedroom', 'computer', 'stovefan', 'toaster', 'tvstand', 'shower', 'homework', 'closetdrawer', 'bench', 'oven', 'toy', 'cup', 'bed', 'photoframe', 'toilet_paper', 'coffe_maker', 'oven_mitts', 'pencil', 'dresser', 'bag', 'bathroom_cabinet']
Task:Pet cat
response:
{
"thoughts": I enter the room where the cat is. I look for the cat. I find the cat. I walk over to the cat. I use my hand to pet the cat.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['water_glass', 'pot', 'bathroom', 'detergent', 'trashcan', 'keyboard', 'button', 'tvstand', 'stereo', 'food_jam', 'dining_room', 'wall', 'nightstand', 'oven', 'powersocket', 'tape', 'newspaper', 'bed', 'coffe_maker', 'water', 'ice', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'table', 'dishwasher', 'tooth_paste', 'laser_pointer']
Task:Drink
response:
| {
"thoughts": "walk to kitchen, look at the water glass, grab that glass, find the water cane, open the water cane tap, drink water",
"actions": [
"[WALK] <dining_room>",
"[WALK] <water_glass>",
"[FIND] <water_glass>",
"[TURNTO] <water_glass>",
"[LOOKAT] <water_glass>",
"[GRAB] <water_glass>",
"[FIND] <water>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'milk', 'floor', 'ceiling', 'shampoo', 'purse', 'ceilinglamp', 'mat', 'faucet', 'oil', 'wall', 'pasta', 'tape', 'novel', 'food_food', 'food_donut', 'wooden_spoon', 'mouse', 'kitchen_counter', 'door', 'home_office', 'bathroom_cabinet', 'vase', 'soap', 'instrument_violin', 'creditcard']
Task:Put groceries in Fridge
response:
{
"thoughts": I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}
|
Scene_Objects:['spectacles', 'pot', 'chair', 'freezer', 'ground_coffee', 'bathroom', 'food_carrot', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'mail', 'button', 'computer', 'toaster', 'tvstand', 'window', 'wall', 'nightstand', 'cup', 'check', 'television', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'dishwasher']
Task:Put groceries in Fridge
response:
| {
"thoughts": "In the kitchen where I left the bags of groceries, I grab cheese from the grocery bag, I walk over to the refrigerator, open it up, neatly put cheese in the fridge, Close the fridge",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'food_bread', 'dry_pasta', 'tablelamp', 'filing_cabinet', 'measuring_cup', 'microwave', 'toilet', 'chair', 'walllamp', 'floor', 'bookshelf', 'toaster', 'mat', 'faucet', 'shower', 'closetdrawer', 'bowl', 'dining_room', 'wall', 'newspaper', 'coffe_maker', 'oven_mitts', 'diary', 'kitchen_counter', 'cupboard', 'clothes_dress', 'sink', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Walk to Kitchen. Take the dishes from the sink. Apply dish washer, scrub and then wash with water.,
"actions": ['[WALK] <sink>', '[FIND] <bowl>', '[GRAB] <bowl>', '[FIND] <dishwasher>', '[SCRUB] <dishwasher>', '[RINSE] <bowl>', '[OPEN] <dishwasher>', '[WASH] <bowl>']
}
|
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'home_office', 'table', 'light']
Task:Read book
response:
| {
"thoughts": "Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading.",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[FIND] <couch>",
"[SIT] <couch>",
"[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', 'beer', 'microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'keyboard', 'food_cake', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'photoframe', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'dishwasher']
Task:Relax on sofa
response:
{
"thoughts": Walk to living room. Sit on sofa. Lie down on sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['water_glass', 'tablelamp', 'chair', 'freezer', 'detergent', 'food_carrot', 'knife', 'cpuscreen', 'kitchen_cabinet', 'character', 'bedroom', 'mail', 'stovefan', 'laptop', 'form', 'pillow', 'nightstand', 'bench', 'oven', 'cup', 'keys', 'toothbrush_holder', 'water', 'food_rice', 'curtain', 'controller', 'sink', 'bathtub', 'dishwasher', 'dirt']
Task:Drink
response:
| {
"thoughts": "Get a glass of water to drink",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[FIND] <water>",
"[GRAB] <water>",
"[FIND] <water_glass>",
"[POUR] <water> <water_glass>",
"[GRAB] <water_glass>",
"[DRINK] <water_glass>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'food_salt', 'toilet', 'bills', 'hanger', 'bathroom_counter', 'floor', 'character', 'stovefan', 'tvstand', 'faucet', 'mousepad', 'towel', 'dining_room', 'wall', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'water', 'tray', 'curtain', 'doorjamb', 'sink', 'bathroom_cabinet', 'table', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Walk to bathroom. Walk to sink and turn on the water. Grab the soap and wash the hands.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <water>', '[TURNTO] <water>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>']
}
|
Scene_Objects:['sheets', 'tablelamp', 'scissors', 'chair', 'freezer', 'knifeblock', 'clothes_underwear', 'bookshelf', 'mop_bucket', 'stovefan', 'shower', 'window', 'couch', 'dining_room', 'nightstand', 'wall_clock', 'powersocket', 'photoframe', 'keys', 'bed', 'towel_rack', 'cd', 'dresser', 'cupboard', 'sink', 'napkin', 'bathroom_cabinet', 'home_office', 'dishwasher', 'board_game']
Task:Pet cat
response:
| {
"thoughts": "Find the cat. Pet the cat.",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'filing_cabinet', 'tea', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'trashcan', 'toothbrush', 'orchid', 'needle', 'shampoo', 'tea_bag', 'alcohol', 'mat', 'shower', 'mousepad', 'towel', 'wall', 'cup', 'bed', 'light_bulb', 'coffe_maker', 'wooden_spoon', 'shoes', 'home_office', 'vase', 'soap']
Task:Pick up phone
response:
{
"thoughts": Walk into the living room, walk over to phone, grab the phone, put it to your ear .,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['pot', 'food_ice_cream', 'microwave', 'freezer', 'walllamp', 'nail_polish', 'bathroom', 'knifeblock', 'floor', 'character', 'desk', 'computer', 'toaster', 'stovefan', 'plate', 'mat', 'dish_soap', 'clothes_hat', 'wall', 'photoframe', 'coffe_maker', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'home_office', 'dishwasher', 'dirt']
Task:Wash dishes with dishwasher
response:
| {
"thoughts": "walk into kitchen, find dishwasher, put plates in dishwasher, put soap in dishwasher, turn on dishwasher",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[FIND] <dishwasher>",
"[OPEN] <dishwasher>",
"[FIND] <dish_soap>",
"[GRAB] <dish_soap>",
"[PUTBACK] <dish_soap> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[PUTBACK] <plate> <dishwasher>",
"[CLOSE] <dishwasher>",
"[SWITCHON] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'thread', 'computer', 'stovefan', 'mat', 'tvstand', 'toaster', 'couch', 'pillow', 'wall', 'photoframe', 'check', 'television', 'doorjamb', 'laundry_detergent', 'conditioner', 'sink', 'door', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Do homework
response:
{
"thoughts": Sit on the couch in the Living room and pick u some papers,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <check>', '[GRAB] <check>', '[DROP] <check>']
}
|
Scene_Objects:['spectacles', 'chair', 'bills', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'bookshelf', 'brush', 'ceilinglamp', 'tvstand', 'stereo', 'stovefan', 'mat', 'mousepad', 'wall', 'powersocket', 'bed', 'television', 'doorjamb', 'dresser', 'clothes_scarf', 'light', 'dishwasher', 'table', 'colander', 'clothes_shirt']
Task:Turn on light
response:
| {
"thoughts": "Walk to the Living Room. Switch on 1 light. Walk to dining room. Switch on 1 light. Walk to Entrance hall. Switch on 1 light.",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <dining_room>",
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'crayon', 'freezer', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'orchid', 'floor', 'ceiling', 'clothes_jacket', 'brush', 'ceilinglamp', 'mat', 'balanceball', 'clothes_socks', 'couch', 'microphone', 'form', 'wall', 'food_food', 'check', 'oven_mitts', 'wine', 'mouse', 'cupboard', 'food_steak', 'spoon', 'table', 'tooth_paste']
Task:Cook some food
response:
{
"thoughts": Go kitchen and make something for eat,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'thread', 'computer', 'alcohol', 'stovefan', 'ceilinglamp', 'couch', 'pillow', 'food_kiwi', 'nightstand', 'powersocket', 'check', 'food_food', 'pencil', 'dishrack', 'home_office', 'dishwasher']
Task:Browse internet
response:
| {
"thoughts": "Go find a computer, turn it on, click google, and browse the internet.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[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:['sponge', 'sheets', 'pot', 'blender', 'microwave', 'chair', 'nail_polish', 'detergent', 'milk', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'clothes_socks', 'broom', 'wall', 'food_kiwi', 'powersocket', 'cup', 'photoframe', 'keys', 'newspaper', 'curtain', 'lighter', 'pencil', 'pajamas', 'clothes_dress', 'sink', 'table', 'light']
Task:Sit in chair
response:
{
"thoughts": I sit in a chair to rest and eat.,
"actions": ['[WALK] <dining_room>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>']
}
|
Scene_Objects:['tablelamp', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'bookshelf', 'remote_control', 'button', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'sink', 'table', 'light']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'measuring_cup', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'bookmark', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'bench', 'cup', 'photoframe', 'novel', 'check', 'coffe_maker', 'television', 'tray', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light', 'table']
Task:Read book
response:
{
"thoughts": I go to the book case, I select a book, I go back and sit down, then I read.,
"actions": ['[WALK] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[READ] <novel>']
}
|
Scene_Objects:['walllamp', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'door', 'table', 'light', 'dishwasher']
Task:Change TV channel
response:
| {
"thoughts": "I go in the living room. Then I find the remote, sit on the couch and turn on the television. Then I use the remote the change the TV channel.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[SWITCHON] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'crayon', 'freezer', 'bathroom', 'trashcan', 'dough', 'knifeblock', 'orchid', 'floor', 'ceiling', 'clothes_jacket', 'brush', 'ceilinglamp', 'mat', 'balanceball', 'clothes_socks', 'couch', 'microphone', 'form', 'wall', 'food_food', 'check', 'oven_mitts', 'wine', 'mouse', 'cupboard', 'food_steak', 'spoon', 'table', 'tooth_paste']
Task:Cook some food
response:
{
"thoughts": Go kitchen and make something for eat,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>']
}
|
Scene_Objects:['fork', 'filing_cabinet', 'juice', 'food_ice_cream', 'bathroom', 'orchid', 'floor', 'ceiling', 'phone', 'shampoo', 'bookshelf', 'tvstand', 'stereo', 'shower', 'couch', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'food_food', 'television', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'controller', 'home_office', 'light', 'coffee']
Task:Pick up phone
response:
| {
"thoughts": "first i will go to home office and switch on the lights and answer the call after then i will put back it and switch off the lights and close the door",
"actions": [
"[RUN] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[FIND] <phone>",
"[GRAB] <phone>",
"[PUTOBJBACK] <phone>",
"[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:['food_pizza', 'tea', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'phone', 'keyboard', 'food_cake', 'toaster', 'stovefan', 'plate', 'mat', 'dish_soap', 'oil', 'pillow', 'wall', 'cup', 'photoframe', 'coffe_maker', 'curtain', 'centerpiece', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['sheets', 'sponge', 'tablelamp', 'measuring_cup', 'toilet', 'chair', 'jelly', 'freezer', 'ground_coffee', 'trashcan', 'toothbrush', 'drawing', 'clothes_underwear', 'phone', 'desk', 'keyboard', 'computer', 'mousepad', 'television', 'towel_rack', 'cd', 'hairbrush', 'pajamas', 'dresser', 'controller', 'door', 'bathtub', 'sink', 'bathroom_cabinet', 'tooth_paste']
Task:Wash teeth
response:
| {
"thoughts": "before going to bed or when wake up earily morning brush teeth",
"actions": [
"[WALK] <bathroom>",
"[WALK] <tooth_paste>",
"[FIND] <tooth_paste>",
"[GRAB] <tooth_paste>",
"[FIND] <toothbrush>",
"[GRAB] <toothbrush>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'milk', 'floor', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'tvstand', 'faucet', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'toy', 'basket_for_clothes', 'coffe_maker', 'video_game_controller', 'tray', 'doorjamb', 'kettle', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'table']
Task:Pick up toys
response:
{
"thoughts": Bend down and pick up the toys off of the floor.,
"actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[PUTIN] <toy> <dresser>', '[FIND] <toy>', '[WALK] <dresser>', '[GRAB] <toy>', '[PUTIN] <toy> <dresser>', '[CLOSE] <dresser>']
}
|
Scene_Objects:['chair', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'stovefan', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'towel', 'wall', 'powersocket', 'photoframe', 'coffee_filter', 'coin', 'tray', 'food_onion', 'doorjamb', 'towel_rack', 'dishrack', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Wash hands
response:
| {
"thoughts": "Go to the bathroom. Turn on the sink. Rinse hands. Apply soap and scrub your hands together. Rinse hands again. Turn off faucet. Dry hands on a towel.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <faucet>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <hands_both>",
"[RINSE] <hands_both>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[SCRUB] <hands_both>",
"[PUTOBJBACK] <soap>",
"[RINSE] <hands_both>",
"[SWITCHOFF] <faucet>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[WIPE] <hands_both>",
"[PUTOBJBACK] <towel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office']
Task:Check email
response:
{
"thoughts": Turn on the computer. Wait for it to load. Get online. Go to the email service. Open the email. Read the email.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>']
}
|
Scene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'dog', 'cpuscreen', 'keyboard', 'ceilinglamp', 'plate', 'laptop', 'faucet', 'window', 'stereo', 'oil', 'food_noodles', 'mousepad', 'dining_room', 'nightstand', 'food_food', 'check', 'wine', 'curtain', 'after_shave', 'comb', 'dresser', 'napkin', 'home_office', 'table', 'bathroom_cabinet', 'light']
Task:Listen to music
response:
| {
"thoughts": "I reach out arm. I put hand on radio. I turn on radio. I pick a station.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <stereo>",
"[TOUCH] <stereo>",
"[TURNTO] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'dough', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'window', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'check', 'curtain', 'mouse', 'pencil', 'dresser', 'light', 'table', 'vase', 'shoe_rack']
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>']
}
|
Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'trashcan', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'homework', 'pillow', 'wall', 'pasta', 'powersocket', 'photoframe', 'oven_mitts', 'doorjamb', 'kitchen_counter', 'comb', 'door', 'bathtub', 'light', 'dishwasher']
Task:Go to toilet
response:
| {
"thoughts": "I walk to bathroom, I open the door of the bathroom, and sit on the toilet.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <toilet>",
"[FIND] <toilet>",
"[SIT] <toilet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['measuring_cup', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'phone', 'character', 'stamp', 'tea_bag', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'brush', 'window', 'couch', 'food_orange', 'pillow', 'wall', 'bench', 'tray', 'curtain', 'after_shave', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'soap']
Task:Relax on sofa
response:
{
"thoughts": Sitting down and relaxing on the sofa,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'keyboard', 'brush', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'stovefan', 'shoe-shine_kit', 'pillow', 'wall', 'powersocket', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_ice_cream', 'mop', 'nail_polish', 'detergent', 'trashcan', 'food_carrot', 'drawing', 'hanger', 'longboard', 'floor', 'keyboard', 'ceilinglamp', 'plate', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'powersocket', 'bench', 'novel', 'food_food', 'television', 'wine', 'doorjamb', 'conditioner', 'bathroom_cabinet', 'table', 'clothes_skirt']
Task:Relax on sofa
response:
{
"thoughts": Walk into the living room. Walk up to the sofa. Sit down on the sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['sheets', 'pot', 'food_pizza', 'tablelamp', 'mop', 'chair', 'freezer', 'walllamp', 'dough', 'drawing', 'knifeblock', 'wallshelf', 'orchid', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'bowl', 'wall', 'oven', 'bench', 'toy', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink']
Task:Cook some food
response:
| {
"thoughts": "go to the kitchen and cook some thing to eat",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <oven>",
"[OPEN] <oven>",
"[FIND] <food_pizza>",
"[GRAB] <food_pizza>",
"[PUTIN] <food_pizza> <oven>",
"[SWITCHON] <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_bread', 'beer', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'toaster', 'mat', 'stovefan', 'shower', 'faucet', 'food_orange', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']
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>']
}
|
Scene_Objects:['walllamp', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'photoframe', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'home_office', 'table', 'light']
Task:Watch TV
response:
| {
"thoughts": "I walk to the Living Room. I find the remote. I grab the remote and take a seat on the couch. I switch on the TV with the remote and watch the television.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'blender', 'bathroom', 'detergent', 'food_carrot', 'cpuscreen', 'wallshelf', 'phone', 'bedroom', 'desk', 'remote_control', 'envelope', 'computer', 'mail', 'tvstand', 'shower', 'iron', 'mousepad', 'closetdrawer', 'oven', 'powersocket', 'newspaper', 'novel', 'food_food', 'curtain', 'dresser', 'food_steak', 'sink', 'table', 'shoe_rack']
Task:Watch TV
response:
{
"thoughts": I walk to the living room and sit on the couch. I grab the TV remote. I press the power button on the TV remote and the TV turns on. I grab the surround sound remote. I press the power button on the surround sound remote and the system turns on.,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[PUSH] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']
}
|
Scene_Objects:['pot', 'microwave', 'jelly', 'bathroom', 'detergent', 'food_butter', 'drawing', 'needle', 'cpuscreen', 'bathroom_counter', 'character', 'stovefan', 'plate', 'window', 'bowl', 'wall', 'bench', 'cup', 'bed', 'coffe_maker', 'check', 'tray', 'towel_rack', 'kitchen_counter', 'vacuum_cleaner', 'pajamas', 'sink', 'light', 'dishwasher', 'teeth']
Task:Listen to music
response:
| {
"thoughts": "Walk into living room. Turn on radio.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'juice', 'chair', 'blow_dryer', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'toaster', 'laptop', 'deck_of_cards', 'faucet', 'food_noodles', 'closetdrawer', 'food_orange', 'wall', 'nightstand', 'clothes_gloves', 'coffe_maker', 'toilet_paper', 'food_food', 'curtain', 'towel_rack', 'console', 'kitchen_counter', 'shoes', 'cupboard', 'sink', 'spoon', 'dishwasher']
Task:Make coffee
response:
{
"thoughts": Making coffee,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'bookshelf', 'mat', 'mousepad', 'dining_room', 'wall', 'nightstand', 'bench', 'basket_for_clothes', 'bed', 'photoframe', 'coffe_maker', 'food_food', 'wooden_spoon', 'mouse', 'dresser', 'sink', 'dishwasher']
Task:Go to sleep
response:
| {
"thoughts": "go t the bedroom and go to sleep",
"actions": [
"[WALK] <bedroom>",
"[WALK] <bed>",
"[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:['filing_cabinet', 'beer', 'crayon', 'freezer', 'walllamp', 'bathroom', 'detergent', 'wallshelf', 'floor', 'ceiling', 'purse', 'computer', 'mat', 'tvstand', 'shower', 'window', 'couch', 'food_peanut_butter', 'dining_room', 'wall', 'photoframe', 'bed', 'television', 'curtain', 'diary', 'cupboard', 'controller', 'bathroom_cabinet', 'table', 'dishwasher']
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>']
}
|
Scene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'table', 'light']
Task:Watch TV
response:
| {
"thoughts": "Go to the living room. Find the remote. Pick up the remote. Find the sofa. Sit on the sofa. Look at the television. Aim the remote at the television. Press the power button. Flip the channels.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[TURNTO] <television>",
"[POINTAT] <television>",
"[SWITCHON] <television>",
"[PUSH] <remote_control>",
"[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', 'walllamp', 'knife', 'knifeblock', 'cpuscreen', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'tea_bag', 'toaster', 'stovefan', 'plate', 'faucet', 'deck_of_cards', 'tvstand', 'bowl', 'wall', 'oven', 'cup', 'coffe_maker', 'drinking_glass', 'food_donut', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'dishwasher']
Task:Unload dishwasher
response:
{
"thoughts": Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[PUTBACK] <drinking_glass> <cupboard>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <fork> <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTIN] <knife> <kitchen_cabinet>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTIN] <spoon> <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>']
}
|
Scene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'shaving_cream', 'towel_rack', 'door', 'table', 'light']
Task:Watch TV
response:
| {
"thoughts": "I enter the living room and sit on the couch. I grab the remote and turn on the TV.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.