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:['pot', 'filing_cabinet', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'towel', 'wall', 'wall_clock', 'oven', 'television', 'tray', 'rag', 'doorjamb', 'dresser', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'laser_pointer']
Task:Take shower
response:
{
"thoughts": Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower.,
"actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <bathroom_cabinet>', '[FIND] <shower>', '[RINSE] <shower>']
}
|
Scene_Objects:['food_bread', 'filing_cabinet', 'microwave', 'toilet', 'freezer', 'dough', 'food_carrot', 'drawing', 'knife', 'clothes_underwear', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'keyboard', 'table_cloth', 'ceilinglamp', 'plate', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'bench', 'coffe_maker', 'toothbrush_holder', 'diary', 'laundry_detergent', 'table', 'coffee']
Task:Cut bread
response:
| {
"thoughts": "I get a slice of bread, grab a knife, and then cut the piece of bread in half.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <knife>",
"[GRAB] <knife>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[CLOSE] <kitchen_cabinet>",
"[FIND] <table>",
"[PUTBACK] <plate> <table>",
"[PUTBACK] <knife> <table>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_bread>",
"[GRAB] <food_bread>",
"[CLOSE] <freezer>",
"[PUTBACK] <food_bread> <plate>",
"[GRAB] <knife>",
"[CUT] <food_bread>",
"[PUTOBJBACK] <knife>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'bathroom', 'drawing', 'knifeblock', 'floor', 'character', 'keyboard', 'stovefan', 'mat', 'ceilinglamp', 'stereo', 'shower', 'window', 'toaster', 'wall', 'nightstand', 'box', 'food_cheese', 'bed', 'after_shave', 'lighter', 'diary', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'food_steak', 'light', 'dishwasher', 'clothes_shirt']
Task:Listen to music
response:
{
"thoughts": Turn on radio, put on favorite channel, listen to music.,
"actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[LIE] <bed>']
}
|
Scene_Objects:['pot', 'juice', 'freezer', 'walllamp', 'knifeblock', 'drawing', 'food_egg', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'laptop', 'faucet', 'oil', 'wall', 'bench', 'box', 'cup', 'food_food', 'check', 'coffee_filter', 'lighter', 'centerpiece', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'spoon', 'table', 'colander', 'board_game']
Task:Grab some juice
response:
| {
"thoughts": "I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[CLOSE] <cupboard>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <juice>",
"[GRAB] <juice>",
"[POUR] <juice> <cup>",
"[PUTOBJBACK] <juice>",
"[CLOSE] <freezer>",
"[FIND] <table>",
"[PUTBACK] <cup> <table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['spectacles', 'filing_cabinet', 'microwave', 'walllamp', 'ceilingfan', 'drawing', 'clothes_underwear', 'bathroom_counter', 'dvd_player', 'character', 'stamp', 'keyboard', 'food_cake', 'shower', 'picture', 'window', 'electric_shaver', 'couch', 'broom', 'box', 'food_food', 'toothbrush_holder', 'food_donut', 'after_shave', 'food_onion', 'mouse', 'hairdryer', 'sink', 'table', 'clothes_shirt']
Task:Open bathroom window
response:
| {
"thoughts": "Make sure bathroom window is unlocked. Lift up bathroom window so it is open.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <window>",
"[FIND] <window>",
"[OPEN] <window>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'mop', 'bathroom', 'food_egg', 'clothes_underwear', 'bathroom_counter', 'phone', 'ceiling', 'computer', 'toaster', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'clothes_pants', 'food_orange', 'food_kiwi', 'basket_for_clothes', 'coffe_maker', 'television', 'curtain', 'mouse', 'cd', 'comb', 'clothes_dress', 'clothes_skirt', 'soap', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": I need to get the dirty clothes basket. Walk to bathroom. Put all the clothes in washing machine. Add soap. Turn on machine.,
"actions": ['[WALK] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['tablelamp', 'juice', 'walllamp', 'bathroom', 'ceilingfan', 'trashcan', 'drawing', 'floor', 'ceiling', 'food_bacon', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'couch', 'wall', 'nightstand', 'wall_clock', 'bench', 'bed', 'food_food', 'television', 'coin', 'curtain', 'mouse', 'controller', 'table', 'vase', 'instrument_violin']
Task:Watch TV
response:
| {
"thoughts": "Sitting on the couch watching my favorite television show.",
"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:['pot', 'freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'ceiling', 'bookshelf', 'envelope', 'toaster', 'mat', 'food_orange', 'pillow', 'wall', 'wall_clock', 'powersocket', 'cutting_board', 'bed', 'oven_mitts', 'coin', 'doorjamb', 'lighter', 'pencil', 'kitchen_counter', 'dresser', 'pajamas', 'door', 'home_office', 'light', 'colander']
Task:Turn on light
response:
{
"thoughts": I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door.,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['dry_pasta', 'measuring_cup', 'toilet', 'freezer', 'walllamp', 'food_carrot', 'knife', 'bathroom_counter', 'stamp', 'food_bacon', 'tvstand', 'plate', 'couch', 'oven', 'cup', 'photoframe', 'check', 'television', 'coffee_filter', 'toothbrush_holder', 'food_rice', 'tray', 'kitchen_counter', 'shoes', 'hairbrush', 'napkin', 'spoon', 'table', 'vase', 'creditcard']
Task:Shut off alarm
response:
| {
"thoughts": "Shutting of the alarm clock",
"actions": [
"[WALK] <bedroom>",
"[WALK] <alarm_clock>",
"[FIND] <alarm_clock>",
"[GRAB] <alarm_clock>",
"[SWITCHOFF] <alarm_clock>",
"[PUTOBJBACK] <alarm_clock>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'chair', 'ground_coffee', 'bathroom', 'detergent', 'bathroom_counter', 'bedroom', 'bookshelf', 'button', 'toaster', 'mat', 'ceilinglamp', 'window', 'mousepad', 'couch', 'dining_room', 'photoframe', 'bed', 'novel', 'coffe_maker', 'food_food', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'sink', 'dishwasher', 'clothes_skirt', 'soap']
Task:Pick up phone
response:
{
"thoughts": walk to living room , find phone ,pick up phone 3,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>']
}
|
Scene_Objects:['pot', 'freezer', 'walllamp', 'detergent', 'ceilingfan', 'dough', 'milk', 'knifeblock', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'stovefan', 'ceilinglamp', 'faucet', 'iron', 'wall', 'nightstand', 'cup', 'food_food', 'tray', 'kitchen_counter', 'cd', 'cupboard', 'food_steak', 'sink', 'bag', 'dishwasher', 'vase']
Task:Get something to drink
response:
| {
"thoughts": "Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[CLOSE] <cupboard>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <milk>",
"[GRAB] <milk>",
"[CLOSE] <freezer>",
"[POUR] <milk> <cup>",
"[DRINK] <cup>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'stovefan', 'mat', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'dresser', 'napkin', 'bathroom_cabinet', 'light', 'table']
Task:Relax on sofa
response:
{
"thoughts": I want to relax on the sofa to some relaxing music in the living room.,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <stereo>', '[PLUGIN] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'dustpan', 'dining_room', 'wall', 'nightstand', 'pasta', 'tape', 'photoframe', 'tray', 'rag', 'doorjamb', 'towel_rack', 'mouse', 'bathroom_cabinet', 'light']
Task:Turn on computer
response:
| {
"thoughts": "Press the power button on the computer to turn it on",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[SWITCHON] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stovefan', 'window', 'mat', 'plate', 'couch', 'candle', 'microphone', 'dining_room', 'wall', 'powersocket', 'box', 'photoframe', 'coffe_maker', 'television', 'curtain', 'table', 'dishwasher']
Task:Watch TV
response:
{
"thoughts": Turn on the TV, sit on the couch, find a show, and watch it.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'video_game_console', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'candle', 'broom', 'wall', 'powersocket', 'check', 'video_game_controller', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'hairbrush', 'door', 'table', 'dishwasher', 'dirt']
Task:Play games
response:
{
"thoughts": Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video game remote controller.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['sheets', 'jelly', 'freezer', 'food_carrot', 'drawing', 'needle', 'knifeblock', 'longboard', 'floor', 'character', 'ceilinglamp', 'shower', 'window', 'foundation', 'couch', 'wall', 'nightstand', 'food_cheese', 'newspaper', 'coffee_table', 'food_food', 'check', 'television', 'ice', 'doorjamb', 'kettle', 'maindoor', 'table', 'vase', 'board_game']
Task:Read magazine
response:
| {
"thoughts": "Get magazine off coffee table. Sit in arm chair. Open magazine to first page. Read until finished.",
"actions": [
"[WALK] <home_office>",
"[WALK] <coffee_table>",
"[FIND] <newspaper>",
"[GRAB] <newspaper>",
"[FIND] <couch>",
"[SIT] <couch>",
"[READ] <newspaper>",
"[PUTBACK] <newspaper> <coffee_table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'blender', 'toilet', 'detergent', 'knife', 'hanger', 'floor', 'character', 'food_cake', 'brush', 'mat', 'plate', 'faucet', 'dish_soap', 'oil', 'closetdrawer', 'food_jam', 'dining_room', 'food_kiwi', 'oven', 'powersocket', 'cup', 'after_shave', 'kitchen_counter', 'dishrack', 'pajamas', 'spoon', 'dishwasher', 'vase']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Walk to kitchen. Find dishwasher. Open dishwasher. Find dishrack. Find plate 1. Grab plate 1. Put plate 1 in dishrack. Repeat for dish 2. Find dish soap. Grab dish soap. Put dish soap to dishwasher. Close dishwasher. Switch on dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['blender', 'chair', 'shampoo', 'ceiling', 'folder', 'face', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'oil', 'food_orange', 'dining_room', 'bench', 'box', 'newspaper', 'check', 'video_game_controller', 'mirror', 'curtain', 'towel_rack', 'hair', 'clothes_dress', 'laundry_detergent', 'bathroom_cabinet', 'table', 'clothes_skirt', 'vase', 'scrabble']
Task:Check appearance in mirror
response:
| {
"thoughts": "Walk to full-length mirror. Look in mirror. Make sure everything about your appearance is adequate. Adjust clothes as needed.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <mirror>",
"[FIND] <mirror>",
"[TURNTO] <mirror>",
"[LOOKAT] <mirror>",
"[FIND] <face>",
"[TURNTO] <face>",
"[LOOKAT] <face>",
"[FIND] <hair>",
"[TURNTO] <hair>",
"[LOOKAT] <hair>",
"[FIND] <clothes_dress>",
"[TURNTO] <clothes_dress>",
"[LOOKAT] <clothes_dress>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'pot', 'filing_cabinet', 'microwave', 'chair', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'face', 'toaster', 'stovefan', 'faucet', 'oil', 'towel', 'wall', 'facial_cleanser', 'check', 'coffe_maker', 'tray', 'rag', 'mouse', 'kitchen_counter', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap']
Task:Wash face
response:
{
"thoughts": Turn the faucet on. Wet the face. Take facial cleanser out of packaging. Lather on face. Rinse face with water. Turn off the faucet. Dry face with towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <face>', '[WASH] <face>', '[FIND] <rag>', '[GRAB] <rag>', '[RINSE] <rag>', '[FIND] <facial_cleanser>', '[GRAB] <facial_cleanser>', '[POUR] <facial_cleanser> <rag>', '[PUTOBJBACK] <facial_cleanser>', '[SCRUB] <face>', '[RINSE] <rag>', '[PUTOBJBACK] <rag>', '[RINSE] <face>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['trashcan', 'dough', 'drawing', 'needle', 'longboard', 'floor', 'desk', 'bedroom', 'computer', 'toaster', 'ceilinglamp', 'stovefan', 'shower', 'window', 'floor_lamp', 'mousepad', 'wall', 'nightstand', 'bed', 'television', 'coffee_filter', 'curtain', 'rag', 'doorjamb', 'cards', 'mouse', 'pencil', 'maindoor', 'sink', 'door']
Task:Turn on lights
response:
| {
"thoughts": "Walk to your lamp, switch it on, and lay on your bed",
"actions": [
"[WALK] <bedroom>",
"[WALK] <floor_lamp>",
"[FIND] <floor_lamp>",
"[TURNTO] <floor_lamp>",
"[SWITCHON] <floor_lamp>",
"[FIND] <bed>",
"[LIE] <bed>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['beer', 'walllamp', 'blow_dryer', 'knifeblock', 'hanger', 'floor', 'ceiling', 'piano_bench', 'ceilinglamp', 'faucet', 'stereo', 'oil', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'coffe_maker', 'toilet_paper', 'coffee_filter', 'water', 'wine', 'tray', 'curtain', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'dishwasher', 'laser_pointer', 'coffee']
Task:Make coffee
response:
{
"thoughts": Go to the kitchen and make coffee.,
"actions": ['[RUN] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[PUTOBJBACK] <coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['pot', 'food_pizza', 'bathroom', 'trashcan', 'food_butter', 'food_carrot', 'floor', 'dvd_player', 'desk', 'food_cake', 'button', 'mat', 'shower', 'stereo', 'clothes_socks', 'couch', 'oven', 'food_food', 'television', 'tray', 'food_onion', 'coffee_pot', 'pencil', 'kitchen_counter', 'cd', 'cupboard', 'clothes_dress', 'food_steak', 'electrical_outlet', 'creditcard']
Task:Turn on radio
response:
| {
"thoughts": "Go to the radio. Switch on the power button. Tune the station. Set the volume. Listen to the music.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[FIND] <electrical_outlet>",
"[TURNTO] <electrical_outlet>",
"[PLUGIN] <stereo>",
"[SWITCHON] <electrical_outlet>",
"[SWITCHON] <stereo>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'toilet', 'chair', 'freezer', 'detergent', 'food_butter', 'wallshelf', 'hanger', 'phone', 'character', 'desk', 'remote_control', 'button', 'piano_bench', 'toaster', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'clothes_pants', 'pillow', 'towel', 'wall', 'novel', 'razor', 'diary', 'conditioner', 'table', 'coffee']
Task:Change TV channel
response:
{
"thoughts": Take the Tv Remote Control in the Living Room table And Press the Channel Change Button to change the channel,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[PUTOBJBACK] <remote_control>']
}
|
Scene_Objects:['spectacles', 'tablelamp', 'beer', 'toilet', 'band-aids', 'nail_polish', 'ceilingfan', 'food_carrot', 'toothbrush', 'knife', 'shampoo', 'ceiling', 'bedroom', 'stamp', 'tea_bag', 'mop_bucket', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'homework', 'food_noodles', 'dining_room', 'bed', 'ice', 'mouse', 'spoon', 'home_office', 'bathroom_cabinet', 'vase', 'colander']
Task:Shut front door
response:
| {
"thoughts": "Close the storm door. Lock the storm door.",
"actions": [
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'walllamp', 'nail_polish', 'cat', 'drawing', 'knife', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'toilet_paper', 'check', 'television', 'doorjamb', 'towel_rack', 'mouse', 'vacuum_cleaner', 'dresser', 'cupboard', 'home_office']
Task:Pet cat
response:
{
"thoughts": I walk into the living room. I see my cat on the couch. I go sit next to the cat on the couch. I pet the cat on the back.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']
}
|
Scene_Objects:['pot', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'hanger', 'longboard', 'floor', 'phone', 'table_cloth', 'ceilinglamp', 'balanceball', 'window', 'couch', 'dustpan', 'powersocket', 'bench', 'cup', 'newspaper', 'photoframe', 'coin', 'console', 'mouse', 'comb', 'maindoor', 'spoon', 'light', 'shoe_rack']
Task:Leave home
response:
| {
"thoughts": "Put on shoes. Put on coat. Open door and exit through it. Lock door behind you.",
"actions": [
"[WALK] <home_office>",
"[WALK] <shoes>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PUTON] <shoes>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'freezer', 'band-aids', 'trashcan', 'dough', 'food_egg', 'cpuscreen', 'floor', 'ceiling', 'folder', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'pillow', 'wall', 'powersocket', 'newspaper', 'food_food', 'check', 'oven_mitts', 'food_donut', 'food_onion', 'doorjamb', 'kettle', 'mouse', 'pajamas', 'door', 'light']
Task:Put groceries in Fridge
response:
{
"thoughts": go to the kitchen and put the groceries in the fridge,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>']
}
|
Scene_Objects:['sheets', 'fork', 'crayon', 'tea', 'toilet', 'bathroom', 'orchid', 'hanger', 'floor', 'character', 'bedroom', 'tea_bag', 'keyboard', 'purse', 'toaster', 'mat', 'deck_of_cards', 'window', 'food_orange', 'pillow', 'photoframe', 'food_food', 'coffe_maker', 'food_donut', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'sink']
Task:Open door
response:
| {
"thoughts": "Open the door when leaving or coming in.",
"actions": [
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'measuring_cup', 'chair', 'trashcan', 'toothbrush', 'cpuscreen', 'hanger', 'ceiling', 'character', 'keyboard', 'alcohol', 'mat', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'oven', 'bench', 'bed', 'photoframe', 'food_food', 'coffe_maker', 'toothbrush_holder', 'tray', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'home_office', 'tooth_paste']
Task:Wash teeth
response:
{
"thoughts": WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR TEETH,
"actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']
}
|
Scene_Objects:['chair', 'bills', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'table_cloth', 'oil', 'mousepad', 'couch', 'microphone', 'dining_room', 'wall', 'coffe_maker', 'coin', 'tray', 'centerpiece', 'console', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'vase', 'teeth']
Task:Put in chair
response:
| {
"thoughts": "Take a comfortable chair. Place it in the entrance hall",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[GRAB] <chair>",
"[WALK] <home_office>",
"[WALK] <floor>",
"[FIND] <floor>",
"[PUTBACK] <chair> <floor>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'chair', 'cat', 'drawing', 'wallshelf', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'bookshelf', 'computer', 'food_bacon', 'bookmark', 'brush', 'mat', 'mousepad', 'clothes_hat', 'wall', 'nightstand', 'powersocket', 'wall_clock', 'cup', 'oven_mitts', 'doorjamb', 'door', 'sink', 'light']
Task:Turn on light
response:
{
"thoughts": push any ligth button to turn it on, for example in the living room,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']
}
|
Scene_Objects:['tablelamp', 'blender', 'crayon', 'microwave', 'nail_polish', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'couch', 'dining_room', 'wall', 'nightstand', 'oven', 'novel', 'television', 'curtain', 'dresser', 'pajamas', 'table', 'instrument_violin']
Task:Turn off TV
response:
| {
"thoughts": "Walk over to tv and press power button",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[SWITCHOFF] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'toothbrush', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'bedroom', 'thread', 'stovefan', 'mat', 'ceilinglamp', 'faucet', 'plate', 'dining_room', 'wall', 'wall_clock', 'oven', 'toothbrush_holder', 'tray', 'doorjamb', 'towel_rack', 'chessboard', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'tooth_paste', 'teeth']
Task:Brush teeth
response:
{
"thoughts": getting ready for bed,
"actions": ['[WALK] <bathroom_counter>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <toothbrush> <bathroom_counter>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[GRAB] <toothbrush>', '[SCRUB] <toothbrush>', '[RINSE] <toothbrush>', '[FIND] <toothbrush_holder>', '[PUTBACK] <toothbrush> <toothbrush_holder>']
}
|
Scene_Objects:['filing_cabinet', 'chair', 'dog', 'ceilingfan', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'table_cloth', 'stovefan', 'electric_shaver', 'dining_room', 'wall', 'nightstand', 'bench', 'powersocket', 'coffe_maker', 'ice', 'lighter', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'home_office', 'table', 'light', 'vase']
Task:Push all chairs in
response:
| {
"thoughts": "Go around the dining room table, going to each chair, and push all the chairs in neatly.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <table>",
"[FIND] <chair>",
"[PUSH] <chair>",
"[FIND] <chair>",
"[PUSH] <chair>",
"[FIND] <chair>",
"[PUSH] <chair>",
"[FIND] <chair>",
"[PUSH] <chair>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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:['filing_cabinet', 'tablelamp', 'freezer', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'mop_bucket', 'shower', 'homework', 'candle', 'clothes_pants', 'pillow', 'wall', 'oven', 'bed', 'keys', 'check', 'coffe_maker', 'tray', 'centerpiece', 'pajamas', 'bag', 'spoon', 'soap', 'laser_pointer', 'scrabble']
Task:Put away keys
response:
| {
"thoughts": "Return keys into a bag",
"actions": [
"[WALK] <home_office>",
"[WALK] <keys>",
"[FIND] <keys>",
"[GRAB] <keys>",
"[FIND] <bag>",
"[OPEN] <bag>",
"[PUTBACK] <keys> <bag>",
"[CLOSE] <bag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'drawing', 'orchid', 'clothes_underwear', 'hanger', 'desk', 'clothes_jacket', 'mop_bucket', 'bookmark', 'shower', 'electric_shaver', 'clothes_socks', 'clothes_pants', 'food_kiwi', 'bench', 'basket_for_clothes', 'photoframe', 'bed', 'coffe_maker', 'food_rice', 'shaving_cream', 'dishrack', 'cupboard', 'clothes_dress', 'laundry_detergent', 'clothes_skirt', 'soap', 'board_game', '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>']
}
|
Scene_Objects:['sheets', 'food_ice_cream', 'food_salt', 'toilet', 'chair', 'detergent', 'orchid', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'phone', 'bookshelf', 'computer', 'clothes_jacket', 'piano_bench', 'pillow', 'wall', 'powersocket', 'photoframe', 'doorjamb', 'cd', 'dishrack', 'dresser', 'cupboard', 'door', 'home_office', 'light', 'bathroom_cabinet', 'table']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'button', 'mat', 'ceilinglamp', 'tvstand', 'homework', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:
{
"thoughts": I walk to the office. I push the on button on the computer. I sit down in the chair. I work on the computer.,
"actions": ['[WALK] <home_office>', '[WALK] <button>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}
|
Scene_Objects:['food_bread', 'food_ice_cream', 'food_salt', 'crayon', 'microwave', 'freezer', 'walllamp', 'milk', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'foundation', 'food_noodles', 'wall', 'oven', 'cup', 'bed', 'food_food', 'coffe_maker', 'toilet_paper', 'coin', 'tray', 'food_onion', 'kettle', 'light', 'dishwasher', 'electrical_outlet']
Task:Toast bread
response:
| {
"thoughts": "Place two slices of bread in the toaster. Select medium toast on toaster. Push down button to begin toasting.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_bread>",
"[GRAB] <food_bread>",
"[CLOSE] <freezer>",
"[WALK] <electrical_outlet>",
"[FIND] <toaster>",
"[PLUGIN] <toaster>",
"[PUTBACK] <food_bread> <toaster>",
"[SWITCHON] <electrical_outlet>",
"[TURNTO] <toaster>",
"[LOOKAT] <toaster>",
"[SWITCHON] <toaster>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'chair', 'walllamp', 'bills', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bathroom_counter', 'computer', 'tvstand', 'form', 'towel', 'wall', 'oven', 'photoframe', 'clothes_gloves', 'bed', 'food_food', 'doorjamb', 'towel_rack', 'dishrack', 'dresser', 'cupboard', 'door', 'light', 'table', 'colander', 'instrument_violin']
Task:Pick up phone
response:
{
"thoughts": I walk over to the phone and pick it up.,
"actions": ['[WALK] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['sheets', 'toilet', 'chair', 'jelly', 'walllamp', 'cat', 'trashcan', 'hanger', 'floor', 'ceiling', 'phone', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'clothes_socks', 'couch', 'wall', 'oven', 'bed', 'tray', 'kitchen_counter', 'shoes', 'dishrack', 'dresser', 'cupboard', 'bathroom_cabinet', 'light', 'teeth']
Task:Put away shoes
response:
| {
"thoughts": "Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door.",
"actions": [
"[WALK] <home_office>",
"[WALK] <shoes>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[FIND] <dresser>",
"[OPEN] <dresser>",
"[PUTIN] <shoes> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'cpuscreen', 'phone', 'desk', 'cleaning_solution', 'keyboard', 'purse', 'table_cloth', 'stovefan', 'tvstand', 'shower', 'stereo', 'food_noodles', 'towel', 'pillow', 'wall', 'wall_clock', 'oven', 'basket_for_clothes', 'photoframe', 'novel', 'food_rice', 'rag', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'napkin', 'table']
Task:Clean mirror
response:
{
"thoughts": GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR,
"actions": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']
}
|
Scene_Objects:['glue', 'mop', 'toilet', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'floor', 'ceiling', 'computer', 'clothes_jacket', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'food_food', 'mouthwash', 'television', 'food_donut', 'curtain', 'after_shave', 'dresser', 'table']
Task:Look at painting
response:
| {
"thoughts": "Walk to the painting. Look up at the painting. Admire it on the wall.",
"actions": [
"[WALK] <home_office>",
"[WALK] <drawing>",
"[FIND] <drawing>",
"[TURNTO] <drawing>",
"[LOOKAT] <drawing>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'ceilinglamp', 'floor_lamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'broom', 'wall', 'oven', 'photoframe', 'novel', 'television', 'doorjamb', 'dresser', 'cupboard', 'light']
Task:Read book
response:
{
"thoughts": A person brings a book into the living room and sits down in a comfortable chair. If it is dark in the room the person turns on the lamp. The book is opened to the next page to be read. The person begins reading the book until they need to stop for some reason.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[READ] <novel>']
}
|
Scene_Objects:['measuring_cup', 'microwave', 'chair', 'freezer', 'nail_polish', 'bathroom', 'food_butter', 'knifeblock', 'cpuscreen', 'hanger', 'ceiling', 'dvd_player', 'stamp', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'iron', 'nightstand', 'oven', 'cutting_board', 'check', 'television', 'coin', 'tray', 'doorjamb', 'bathroom_cabinet', 'teeth']
Task:Answer door
response:
| {
"thoughts": "Walk up to the door. Open the door and greet whomever is out side",
"actions": [
"[WALK] <home_office>",
"[WALK] <man>",
"[FIND] <man>",
"[GREET] <man>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'drawing', 'hanger', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'foundation', 'oil', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'novel', 'television', 'curtain', 'after_shave', 'door', 'napkin', 'home_office', 'table']
Task:Turn off TV
response:
{
"thoughts": Walk over to tv and press power button,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHOFF] <television>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'scissors', 'freezer', 'band-aids', 'blow_dryer', 'bathroom', 'ceilingfan', 'drawing', 'bathroom_counter', 'ceiling', 'food_cake', 'toaster', 'mat', 'faucet', 'shower', 'mousepad', 'food_jam', 'clothes_pants', 'bowl', 'wall', 'photoframe', 'keys', 'novel', 'toilet_paper', 'tray', 'controller', 'sink', 'bathroom_cabinet', 'table']
Task:Get toilet paper
response:
| {
"thoughts": "There are extra toilet papers in the bottom cabinet.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <bathroom_cabinet>",
"[FIND] <bathroom_cabinet>",
"[OPEN] <bathroom_cabinet>",
"[FIND] <toilet_paper>",
"[GRAB] <toilet_paper>",
"[CLOSE] <bathroom_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'tablelamp', 'juice', 'scissors', 'beer', 'chair', 'freezer', 'bathroom', 'ceilingfan', 'hanger', 'floor', 'computer', 'food_bacon', 'mat', 'couch', 'creditcard', 'dining_room', 'oven', 'tape', 'bed', 'light_bulb', 'novel', 'food_food', 'mouse', 'cupboard', 'conditioner', 'home_office', 'table', 'scrabble', 'shoe_rack']
Task:Pet dog
response:
{
"thoughts": Pet my dog in hall,
"actions": ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']
}
|
Scene_Objects:['juice', 'food_salt', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'drawing', 'floor', 'stamp', 'table_cloth', 'plate', 'faucet', 'deck_of_cards', 'clothes_pants', 'wall', 'bench', 'powersocket', 'tape', 'photoframe', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee']
Task:Bring dirty plate to sink
response:
| {
"thoughts": "Stand up from the table. Pick up dirty plate. Walk to sink. Put plate in sink.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <table>",
"[FIND] <table>",
"[TURNTO] <table>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <dining_room>",
"[WALK] <sink>",
"[FIND] <sink>",
"[PUTBACK] <plate> <sink>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'love_seat', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'clothes_scarf']
Task:Watch TV
response:
{
"thoughts": Sit and watch the television,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['chair', 'freezer', 'trashcan', 'food_carrot', 'orchid', 'floor', 'ceiling', 'thread', 'mail', 'button', 'food_bacon', 'bookmark', 'ceilinglamp', 'stereo', 'faucet', 'mousepad', 'wall', 'bench', 'cup', 'food_food', 'razor', 'television', 'food_donut', 'towel_rack', 'console', 'kitchen_counter', 'hairbrush', 'cupboard', 'sink', 'vase']
Task:Added meat to freezer
response:
| {
"thoughts": "After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTBACK] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'bookshelf', 'mat', 'shower', 'faucet', 'wall', 'powersocket', 'oven', 'light_bulb', 'novel', 'check', 'television', 'food_donut', 'curtain', 'doorjamb', 'kitchen_counter', 'spoon', 'home_office', 'light', 'dishwasher']
Task:Turn on light
response:
{
"thoughts": Switch on light in home office,
"actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[SWITCHON] <light>', '[WALK] <home_office>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'microwave', 'toilet', 'chair', 'walllamp', 'cpuscreen', 'hanger', 'phone', 'computer', 'stereo', 'faucet', 'window', 'couch', 'dining_room', 'wall_clock', 'bench', 'pasta', 'coffe_maker', 'food_food', 'doorjamb', 'mouse', 'pajamas', 'controller', 'sink', 'napkin', 'light', 'table', 'dishwasher']
Task:Walk to room
response:
| {
"thoughts": "Leave the living room and enter the hall",
"actions": [
"[WALK] <home_office>",
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'microphone', 'form', 'pillow', 'wall', 'nightstand', 'oven', 'cup', 'coffe_maker', 'television', 'curtain', 'vacuum_cleaner', 'dishrack', 'dresser', 'hairbrush', 'door', 'table', 'soap']
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>']
}
|
Scene_Objects:['sheets', 'mop', 'toilet', 'freezer', 'walllamp', 'food_carrot', 'knife', 'ceiling', 'purse', 'computer', 'table_cloth', 'faucet', 'clothes_pants', 'bench', 'photoframe', 'check', 'food_food', 'television', 'toilet_paper', 'ice', 'curtain', 'rag', 'lighter', 'mouse', 'pencil', 'vacuum_cleaner', 'door', 'clothes_scarf', 'sink', 'clothes_skirt']
Task:Look at mirror
response:
| {
"thoughts": "I look at my reflection to check my cleanliness.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <mirror>",
"[FIND] <mirror>",
"[TURNTO] <mirror>",
"[LOOKAT] <mirror>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'toilet', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'bathroom_counter', 'purse', 'alcohol', 'bookmark', 'stovefan', 'toaster', 'stereo', 'food_jam', 'dining_room', 'powersocket', 'food_food', 'mouthwash', 'tray', 'after_shave', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office', 'laser_pointer']
Task:Walk through
response:
{
"thoughts": Walk through the hallway.,
"actions": ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>']
}
|
Scene_Objects:['beer', 'crayon', 'freezer', 'detergent', 'orchid', 'drawing', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'faucet', 'window', 'electric_shaver', 'couch', 'clothes_pants', 'wall', 'photoframe', 'newspaper', 'food_food', 'television', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'shaving_cream', 'comb', 'hair', 'home_office', 'table', 'vase']
Task:Drink
response:
| {
"thoughts": "Get a can of beer, open it, sit on couch, relax",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <beer>",
"[GRAB] <beer>",
"[CLOSE] <freezer>",
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[DRINK] <beer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'blender', 'toilet', 'bathroom', 'detergent', 'food_butter', 'cpuscreen', 'floor', 'ceiling', 'toaster', 'mousepad', 'couch', 'food_kiwi', 'wall', 'oven', 'toy', 'coffe_maker', 'television', 'oven_mitts', 'coffee_filter', 'ice', 'coffee_pot', 'shaving_cream', 'kitchen_counter', 'cd', 'cupboard', 'sink', 'home_office', 'dishwasher', 'coffee']
Task:Make coffee
response:
{
"thoughts": Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on.,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[WALK] <coffee>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['food_pizza', 'beer', 'chair', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'dvd_player', 'stamp', 'bookshelf', 'toaster', 'ceilinglamp', 'faucet', 'homework', 'floor_lamp', 'window', 'food_orange', 'dining_room', 'nightstand', 'bench', 'food_cheese', 'television', 'doorjamb', 'lighter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer']
Task:Turn off light
response:
| {
"thoughts": "Walk to the lamp. Find the switch. Click the switch off.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <floor_lamp>",
"[SWITCHOFF] <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:['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>']
}
|
Scene_Objects:['beer', 'microwave', 'drawing', 'floor', 'purse', 'computer', 'plate', 'balanceball', 'shower', 'stereo', 'dustpan', 'clothes_hat', 'microphone', 'bench', 'basket_for_clothes', 'cup', 'bed', 'check', 'coffe_maker', 'food_onion', 'after_shave', 'cards', 'pencil', 'chessboard', 'maindoor', 'napkin', 'table', 'board_game', 'clothes_shirt', 'coffee']
Task:Set up table
response:
| {
"thoughts": "Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <plate>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <plate> <table>",
"[WALK] <dining_room>",
"[WALK] <plate>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <plate> <table>",
"[WALK] <dining_room>",
"[WALK] <plate>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <plate> <table>",
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <food_food> <table>",
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <food_food> <table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'chair', 'walllamp', 'knifeblock', 'drawing', 'floor', 'phone', 'keyboard', 'toaster', 'stovefan', 'plate', 'shower', 'tvstand', 'dish_soap', 'couch', 'wall', 'coffe_maker', 'video_game_controller', 'food_onion', 'rag', 'towel_rack', 'mouse', 'kettle', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['sponge', 'pot', 'toilet', 'detergent', 'orchid', 'longboard', 'floor', 'desk', 'food_bacon', 'stovefan', 'ceilinglamp', 'toaster', 'faucet', 'balanceball', 'window', 'bed', 'oven_mitts', 'ice', 'curtain', 'after_shave', 'lighter', 'towel_rack', 'cards', 'controller', 'laundry_detergent', 'maindoor', 'door', 'sink', 'home_office', 'table']
Task:Turn on light
response:
| {
"thoughts": "Twist the lamp switch until the light goes on.",
"actions": [
"[WALK] <home_office>",
"[WALK] <floor_lamp>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'fork', 'pot', 'sheets', 'food_salt', 'detergent', 'food_butter', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'shampoo', 'desk', 'food_cake', 'mat', 'faucet', 'food_kiwi', 'wall', 'powersocket', 'toy', 'novel', 'food_food', 'curtain', 'dresser', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Going to the sink and scrubbing hands,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>']
}
|
Scene_Objects:['pot', 'toilet', 'chair', 'freezer', 'walllamp', 'blow_dryer', 'toothbrush', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'character', 'bedroom', 'keyboard', 'ceilinglamp', 'stereo', 'shower', 'foundation', 'food_peanut_butter', 'towel', 'wall', 'clothes_gloves', 'food_food', 'toilet_paper', 'tray', 'after_shave', 'dresser', 'cupboard', 'door', 'light']
Task:Look in refrigerator
response:
| {
"thoughts": "Approach the refrigerator. Use the handle to open the refrigerator door. Look at each shelf of the refrigerator. Look in each refrigerator drawer. Close the refrigerator door.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[TURNTO] <freezer>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[TURNTO] <freezer>",
"[LOOKAT] <freezer>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <food_food>",
"[CLOSE] <kitchen_cabinet>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'jelly', 'freezer', 'chair', 'blow_dryer', 'bathroom', 'walllamp', 'knife', 'phone', 'keyboard', 'stovefan', 'homework', 'couch', 'food_jam', 'bench', 'oven', 'toy', 'box', 'food_cheese', 'oven_mitts', 'food_rice', 'tray', 'curtain', 'after_shave', 'dresser', 'clothes_dress', 'conditioner', 'hairdryer', 'vase', 'board_game']
Task:Pet cat
response:
{
"thoughts": I walk to my living room, find my cat, scrub it using my hand.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[SCRUB] <cat>']
}
|
Scene_Objects:['tablelamp', 'crayon', 'tea', 'mop', 'microwave', 'toilet', 'toothbrush', 'drawing', 'knifeblock', 'orchid', 'phone', 'ceiling', 'computer', 'stovefan', 'toaster', 'tvstand', 'window', 'floor_lamp', 'couch', 'clothes_hat', 'photoframe', 'after_shave', 'food_onion', 'headset', 'chessboard', 'cupboard', 'controller', 'door', 'bathroom_cabinet', 'clothes_skirt']
Task:Switch on lamp
response:
| {
"thoughts": "Press the button so the light comes on.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <floor_lamp>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_salt', 'beer', 'chair', 'freezer', 'knifeblock', 'bathroom_counter', 'longboard', 'phone', 'keyboard', 'computer', 'food_bacon', 'tvstand', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'nightstand', 'bench', 'bed', 'photoframe', 'novel', 'television', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'food_steak', 'sink', 'hairdryer', 'vase']
Task:Read book
response:
{
"thoughts": Go to the book shelf, get a book, open the book and read the book.,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']
}
|
Scene_Objects:['sheets', 'chair', 'blow_dryer', 'trashcan', 'orchid', 'knifeblock', 'drawing', 'longboard', 'floor', 'ceiling', 'desk', 'cleaning_solution', 'computer', 'window', 'oil', 'clothes_socks', 'couch', 'pillow', 'wall', 'bed', 'newspaper', 'novel', 'toilet_paper', 'food_donut', 'curtain', 'rag', 'doorjamb', 'maindoor', 'napkin', 'bathroom_cabinet']
Task:Dust
response:
| {
"thoughts": "Gather wood cleaner and cleaning rag. Wipe baseboards and window sills with dry cloth, then spray with cleaner and buff",
"actions": [
"[WALK] <bedroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[POUR] <cleaning_solution> <rag>",
"[PUTOBJBACK] <cleaning_solution>",
"[WALK] <wall>",
"[WALK] <window>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'couch', 'candle', 'clothes_hat', 'pillow', 'wall', 'oven', 'coffe_maker', 'television', 'curtain', 'diary', 'towel_rack', 'mouse', 'dishrack', 'home_office', 'table']
Task:Relax on sofa
response:
{
"thoughts": I walk to the living room. I see the couch. I sit down on the couch, then lie down and put my feet up.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['sheets', 'pot', 'food_pizza', 'dry_pasta', 'walllamp', 'trashcan', 'food_carrot', 'dough', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'wall', 'wall_clock', 'oven', 'food_cheese', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher']
Task:Keep an eye on stove as something is cooking
response:
| {
"thoughts": "Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done",
"actions": [
"[WALK] <dining_room>",
"[WALK] <oven>",
"[FIND] <pot>",
"[TURNTO] <pot>",
"[LOOKAT] <pot>",
"[FIND] <wall_clock>",
"[TURNTO] <wall_clock>",
"[LOOKAT] <wall_clock>",
"[SWITCHOFF] <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'cat', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'television', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'sink', 'bathroom_cabinet', 'table']
Task:Turn on computer
response:
{
"thoughts": Press the power button on the computer to turn it on,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['fork', 'dry_pasta', 'microwave', 'knifeblock', 'knife', 'longboard', 'ceiling', 'purse', 'face', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'towel', 'pillow', 'nightstand', 'powersocket', 'photoframe', 'bed', 'clothes_gloves', 'mouthwash', 'after_shave', 'shoes', 'dishrack', 'dresser', 'hair', 'home_office', 'table', 'dishwasher']
Task:Rain welcome
response:
| {
"thoughts": "The robot would greet me and then hand me a towel. It would make an appropriate quip about the weather while I dried off. It would receive the wet towel when I was done.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <towel>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[FIND] <face>",
"[WIPE] <face>",
"[FIND] <hair>",
"[WIPE] <hair>",
"[PUTOBJBACK] <towel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'pot', 'band-aids', 'walllamp', 'drawing', 'wallshelf', 'floor', 'character', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'bench', 'photoframe', 'television', 'tray', 'curtain', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'home_office', 'table', 'clothes_shirt']
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:['scissors', 'tea', 'walllamp', 'knife', 'orchid', 'cpuscreen', 'hanger', 'character', 'desk', 'clothes_jacket', 'toaster', 'mat', 'tvstand', 'shower', 'clothes_hat', 'food_orange', 'bowl', 'bench', 'powersocket', 'oven', 'bed', 'light_bulb', 'coffe_maker', 'curtain', 'kitchen_counter', 'comb', 'pajamas', 'controller', 'sink', 'tooth_paste']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'rag', 'doorjamb', 'cards', 'dresser', 'sink', 'dishwasher']
Task:Watch TV
response:
{
"thoughts": Sit on my couch directly opposite my tv , switch on my tv with the remote control and watch,
"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:['sheets', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'bathroom', 'ceilingfan', 'clothes_underwear', 'bathroom_counter', 'character', 'thread', 'piano_bench', 'toaster', 'deck_of_cards', 'homework', 'couch', 'dustpan', 'powersocket', 'newspaper', 'clothes_gloves', 'novel', 'coffe_maker', 'doorjamb', 'chessboard', 'cd', 'napkin', 'home_office', 'instrument_guitar', 'clothes_skirt', 'light']
Task:Close door
response:
| {
"thoughts": "Push the door shut until it latches.",
"actions": [
"[RUN] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'woman', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'man', 'bookshelf', 'keyboard', 'piano_bench', 'stovefan', 'tvstand', 'shower', 'faucet', 'oil', 'dining_room', 'food_kiwi', 'nightstand', 'bench', 'oven', 'powersocket', 'coffe_maker', 'tray', 'curtain', 'towel_rack', 'cupboard', 'door', 'sink', 'light']
Task:Greet guests
response:
{
"thoughts": Stand next to the door. When the door opens from the outside, greet the guests.,
"actions": ['[RUN] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[FIND] <man>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>']
}
|
Scene_Objects:['juice', 'measuring_cup', 'toilet', 'nail_polish', 'trashcan', 'dough', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'bookmark', 'ceilinglamp', 'deck_of_cards', 'shoe-shine_kit', 'window', 'couch', 'wall', 'nightstand', 'check', 'mouthwash', 'television', 'hairbrush', 'sink', 'home_office', 'table', 'dishwasher', 'soap', 'teeth']
Task:Do homework
response:
| {
"thoughts": "Sit on the couch in the Living room and pick u some papers",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <check>",
"[GRAB] <check>",
"[DROP] <check>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'television', 'curtain', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'table']
Task:Watch TV
response:
{
"thoughts": Walk to Living room. Find Television. Walk to sofa. Sit on sofa. Find Remote. Grab remote. Turn to television. Look at television. Switch on Television.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'walllamp', 'detergent', 'milk', 'hanger', 'phone', 'toaster', 'tvstand', 'balanceball', 'electric_shaver', 'food_noodles', 'garbage_can', 'mousepad', 'clothes_hat', 'pillow', 'broom', 'food_kiwi', 'bench', 'food_vegetable', 'food_cheese', 'food_food', 'ice', 'wine', 'rag', 'shaving_cream', 'dresser', 'cupboard', 'napkin', 'pantry']
Task:Organize pantry
response:
| {
"thoughts": "Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <pantry>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>",
"[FIND] <garbage_can>",
"[PUTBACK] <food_food> <garbage_can>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[TURNTO] <food_vegetable>",
"[LOOKAT] <food_vegetable>",
"[PUTBACK] <food_vegetable> <garbage_can>",
"[FIND] <dry_pasta>",
"[GRAB] <dry_pasta>",
"[TURNTO] <dry_pasta>",
"[LOOKAT] <dry_pasta>",
"[PUTOBJBACK] <dry_pasta>",
"[FIND] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>",
"[PUSH] <food_food>",
"[FIND] <food_noodles>",
"[GRAB] <food_noodles>",
"[TURNTO] <food_noodles>",
"[LOOKAT] <food_noodles>",
"[PUTOBJBACK] <food_noodles>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'chair', 'orchid', 'bills', 'drawing', 'floor', 'ceiling', 'table_cloth', 'toaster', 'mat', 'faucet', 'mousepad', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'cup', 'keys', 'coffe_maker', 'food_food', 'check', 'water', 'wine', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'board_game']
Task:Drink
response:
{
"thoughts": Go to the kitchen and drink some water.,
"actions": ['[RUN] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <cup> <sink>', '[FIND] <water>', '[GRAB] <cup>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>', '[PUTBACK] <cup> <sink>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'beer', 'chair', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'cleaning_solution', 'bookmark', 'iron', 'mousepad', 'couch', 'dustpan', 'food_jam', 'tape', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'hairbrush', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'vase', 'colander', 'teeth']
Task:Clean mirror
response:
| {
"thoughts": "Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[POUR] <cleaning_solution> <rag>",
"[PUTOBJBACK] <cleaning_solution>",
"[WALK] <mirror>",
"[WIPE] <mirror>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'iron', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'video_game_controller', 'television', 'doorjamb', 'kettle', 'mouse', 'door', 'table']
Task:Browse internet
response:
{
"thoughts": Walk to home office. Walk to computer. Switch on Computer.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'chair', 'detergent', 'milk', 'drawing', 'orchid', 'cpuscreen', 'longboard', 'floor', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'laptop', 'window', 'mousepad', 'clothes_socks', 'couch', 'wall', 'nightstand', 'powersocket', 'television', 'console', 'mouse', 'pajamas', 'bathroom_cabinet', 'table', 'dishwasher']
Task:Use laptop
response:
| {
"thoughts": "Sit down on a couch and perform tasks such as navigating the internet on a laptop",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <laptop>",
"[SWITCHON] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>",
"[TURNTO] <keyboard>",
"[LOOKAT] <keyboard>",
"[TYPE] <keyboard>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'freezer', 'bathroom', 'detergent', 'food_butter', 'longboard', 'bookshelf', 'stovefan', 'shower', 'pillow', 'towel', 'dining_room', 'nightstand', 'powersocket', 'toy', 'basket_for_clothes', 'newspaper', 'light_bulb', 'photoframe', 'food_food', 'coin', 'doorjamb', 'headset', 'shoes', 'hairbrush', 'cupboard', 'napkin', 'home_office']
Task:Listen to music
response:
{
"thoughts": I walk into my room and turn the radio on so that I can listen to music.,
"actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['tablelamp', 'food_ice_cream', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'knife', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'balanceball', 'homework', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'light']
Task:Vacuum
response:
| {
"thoughts": "Keep my keyboard vacuumed and free of debris.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'glue', 'microwave', 'bathroom', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'purse', 'food_bacon', 'ceilinglamp', 'plate', 'laptop', 'deck_of_cards', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'photoframe', 'check', 'television', 'spoon', 'home_office', 'table', 'teeth']
Task:Relax on sofa
response:
{
"thoughts": I walk to the sofa, and lie down on the sofa.,
"actions": ['[WALK] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['glue', 'tablelamp', 'beer', 'mop', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'balanceball', 'electric_shaver', 'mousepad', 'wall', 'nightstand', 'bed', 'doorjamb', 'towel_rack', 'mouse', 'hairdryer', 'maindoor', 'light']
Task:Clean screen
response:
| {
"thoughts": "Use a soft rag to wipe the screen until there are no marks on it.",
"actions": [
"[WALK] <home_office>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <computer>",
"[WIPE] <computer>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'walllamp', 'dough', 'drawing', 'needle', 'food_egg', 'wallshelf', 'cpuscreen', 'orchid', 'floor', 'ceiling', 'computer', 'mail', 'mat', 'tvstand', 'shoe-shine_kit', 'couch', 'pillow', 'dining_room', 'wall', 'photoframe', 'food_food', 'television', 'coin', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'clothes_dress', 'tooth_paste']
Task:Relax on sofa
response:
{
"thoughts": Walk to the living room, turn to the sofa. Sit on the sofa and relax.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['pot', 'microwave', 'toilet', 'walllamp', 'woman', 'drawing', 'hanger', 'longboard', 'bathroom_counter', 'phone', 'character', 'man', 'food_cake', 'alcohol', 'stovefan', 'window', 'mousepad', 'microphone', 'powersocket', 'cup', 'food_cheese', 'check', 'food_food', 'after_shave', 'controller', 'maindoor', 'food_steak', 'hairdryer', 'bathroom_cabinet', 'dirt']
Task:Greet guests
response:
| {
"thoughts": "Stand next to the door. When the door opens from the outside, greet the guests.",
"actions": [
"[RUN] <home_office>",
"[WALK] <woman>",
"[FIND] <woman>",
"[TURNTO] <woman>",
"[LOOKAT] <woman>",
"[GREET] <woman>",
"[FIND] <man>",
"[TURNTO] <man>",
"[LOOKAT] <man>",
"[GREET] <man>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'walllamp', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'remote_control', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'pillow', 'wall', 'powersocket', 'photoframe', 'bed', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'sink', 'light', 'coffee']
Task:Watch TV
response:
{
"thoughts": walk to living room ,find television , switch on remote control,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[FIND] <remote_control>', '[SWITCHON] <remote_control>']
}
|
Scene_Objects:['sheets', 'spectacles', 'food_pizza', 'beer', 'ground_coffee', 'bathroom', 'walllamp', 'ceilingfan', 'orchid', 'character', 'desk', 'cleaning_solution', 'bookshelf', 'food_bacon', 'mat', 'mousepad', 'wall', 'pasta', 'oven', 'powersocket', 'novel', 'food_rice', 'wooden_spoon', 'curtain', 'rag', 'console', 'chessboard', 'headset', 'dresser', 'cupboard']
Task:Clean
response:
| {
"thoughts": "Spray counter tops with all purpose cleaner. Using towel, wipe counter, removing all dirt and grime until clean.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[PUTOBJBACK] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'tea', 'band-aids', 'walllamp', 'nail_polish', 'knifeblock', 'bills', 'cpuscreen', 'hanger', 'shampoo', 'phone', 'floor', 'bedroom', 'desk', 'toaster', 'stereo', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bowl', 'dining_room', 'bench', 'newspaper', 'clothes_gloves', 'coffe_maker', 'curtain', 'diary', 'hairbrush', 'bathroom_cabinet']
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:['mop', 'walllamp', 'toothbrush', 'cpuscreen', 'bathroom_counter', 'bookshelf', 'keyboard', 'mat', 'shower', 'faucet', 'couch', 'pillow', 'dining_room', 'photoframe', 'newspaper', 'novel', 'check', 'toilet_paper', 'coin', 'mirror', 'food_rice', 'rag', 'doorjamb', 'shoes', 'chessboard', 'dresser', 'hair', 'maindoor', 'table', 'clothes_shirt']
Task:Clean mirror
response:
| {
"thoughts": "Spray glass cleaner on mirror. Wipe with a clean cloth.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[WALK] <mirror>",
"[PUTOBJBACK] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <mirror>",
"[WIPE] <mirror>",
"[WIPE] <mirror>",
"[WIPE] <mirror>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'beer', 'microwave', 'ceilingfan', 'food_carrot', 'drawing', 'floor', 'ceiling', 'phone', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'plate', 'window', 'mat', 'oil', 'couch', 'dining_room', 'wall', 'bed', 'light_bulb', 'coffe_maker', 'television', 'curtain', 'kettle', 'door', 'napkin', 'table']
Task:Relax on sofa
response:
{
"thoughts": I walk to my living room and switch on the television, and lay on the sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'chair', 'bathroom', 'trashcan', 'ceilingfan', 'food_carrot', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'purse', 'computer', 'table_cloth', 'brush', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'doorjamb', 'mouse', 'napkin', 'light', 'vase']
Task:Wash monitor
response:
| {
"thoughts": "Clean the grime off of my monitor screen when not in use",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[SWITCHOFF] <computer>",
"[FIND] <brush>",
"[TURNTO] <brush>",
"[LOOKAT] <brush>",
"[GRAB] <brush>",
"[WIPE] <computer>",
"[DROP] <brush>",
"[FIND] <napkin>",
"[GRAB] <napkin>",
"[WASH] <napkin>",
"[WIPE] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'mat', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'food_food', 'television', 'doorjamb', 'mouse', 'cupboard', 'conditioner', 'door', 'bathroom_cabinet', 'light', 'table']
Task:Look at painting
response:
{
"thoughts": Walk to the painting. Look up at the painting. Admire it on the wall.,
"actions": ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']
}
|
Scene_Objects:['microwave', 'detergent', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'bookshelf', 'purse', 'food_cake', 'computer', 'ceilinglamp', 'mat', 'electric_shaver', 'pillow', 'dining_room', 'wall', 'toy', 'cup', 'television', 'vacuum_cleaner', 'shoes', 'comb', 'dresser', 'cupboard', 'food_steak', 'hairdryer', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Clean room
response:
| {
"thoughts": "Pick up his toys, vacuum the garbage off the floor.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <toy>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[PUTBACK] <toy> <dresser>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <dresser>",
"[PUTBACK] <toy> <dresser>",
"[CLOSE] <dresser>",
"[WALK] <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>",
"[OPEN] <dresser>",
"[PUTIN] <vacuum_cleaner> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['ironing_board', 'sheets', 'tablelamp', 'detergent', 'knifeblock', 'bathroom_counter', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'window', 'couch', 'pillow', 'bowl', 'nightstand', 'food_cheese', 'video_game_controller', 'tray', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'pajamas', 'bag', 'dishwasher', 'board_game', 'clothes_shirt']
Task:Iron shirt
response:
{
"thoughts": Set up an ironing board and an iron. Lay a shirt on board. Run iron over shirt until it is free of wrinkles.,
"actions": ['[WALK] <bedroom>', '[WALK] <ironing_board>', '[FIND] <ironing_board>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <ironing_board>', '[FIND] <iron>', '[GRAB] <iron>', '[PLUGIN] <iron>', '[PLUGOUT] <iron>', '[PUTOBJBACK] <iron>']
}
|
Scene_Objects:['filing_cabinet', 'blender', 'crayon', 'toilet', 'chair', 'freezer', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'window', 'pillow', 'wall', 'pasta', 'powersocket', 'toy', 'box', 'cup', 'check', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'dresser', 'door', 'light', 'scrabble']
Task:Pick up toys
response:
| {
"thoughts": "Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <toy>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[PUTBACK] <toy> <dresser>",
"[CLOSE] <dresser>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'crayon', 'microwave', 'dog', 'band-aids', 'walllamp', 'trashcan', 'knifeblock', 'orchid', 'floor', 'desk', 'bookshelf', 'computer', 'piano_bench', 'plate', 'faucet', 'dish_soap', 'food_jam', 'form', 'wall', 'photoframe', 'doorjamb', 'kettle', 'kitchen_counter', 'dishrack', 'cupboard', 'pajamas', 'sink', 'table']
Task:Wash dishes by hand
response:
{
"thoughts": Walk to the kitchen and turn to the sink. Put the plate into the sink. Grab and squeeze the dish soap. Scrub the plate then rinse it. Put the plate into the dish rack.,
"actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <sink>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[SQUEEZE] <dish_soap>', '[SCRUB] <plate>', '[RINSE] <plate>', '[GRAB] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>']
}
|
Scene_Objects:['filing_cabinet', 'chair', 'band-aids', 'freezer', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'envelope', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'towel', 'wall', 'powersocket', 'light_bulb', 'novel', 'curtain', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'board_game']
Task:Read to child
response:
| {
"thoughts": "Read a book out loud to a child",
"actions": [
"[WALK] <bedroom>",
"[WALK] <child>",
"[FIND] <child>",
"[GREET] <child>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[WALK] <chair>",
"[PULL] <chair>",
"[SIT] <chair>",
"[TURNTO] <novel>",
"[LOOKAT] <novel>",
"[TURNTO] <novel>",
"[POINTAT] <novel>",
"[TURNTO] <novel>",
"[POINTAT] <novel>",
"[READ] <novel>",
"[READ] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'mousepad', 'wall', 'nightstand', 'powersocket', 'coffe_maker', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'cupboard', 'controller', 'table']
Task:Browse internet
response:
{
"thoughts": I go to my desk. I turn on the computer. I open a web page and look at it.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}
|
Scene_Objects:['bathroom', 'detergent', 'cat', 'knife', 'food_egg', 'character', 'stamp', 'bedroom', 'desk', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'window', 'oil', 'mousepad', 'clothes_hat', 'towel', 'pillow', 'dining_room', 'powersocket', 'coin', 'console', 'towel_rack', 'dishrack', 'cupboard', 'maindoor', 'sink', 'bag']
Task:Keep cats out of room
response:
| {
"thoughts": "Stand in the doorway and create a loud noise so the cats will stay out.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <cat>",
"[FIND] <cat>",
"[TURNTO] <cat>",
"[LOOKAT] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'tablelamp', 'beer', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'mat', 'stereo', 'couch', 'pillow', 'bowl', 'wall', 'nightstand', 'powersocket', 'cup', 'toilet_paper', 'television', 'after_shave', 'rag', 'doorjamb', 'coffee_pot', 'dishrack', 'instrument_guitar', 'table', 'soap', 'laser_pointer']
Task:Relax on sofa
response:
{
"thoughts": walk to living room, walk to sofa, sit in sofa,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['glue', 'filing_cabinet', 'food_pizza', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'brush', 'toaster', 'tvstand', 'balanceball', 'window', 'food_noodles', 'mousepad', 'food_peanut_butter', 'clothes_hat', 'dining_room', 'pasta', 'bench', 'photoframe', 'oven_mitts', 'ice', 'rag', 'dresser', 'cupboard', 'food_steak', 'maindoor', 'table']
Task:Clean mirror
response:
| {
"thoughts": "GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR",
"actions": [
"[WALK] <bathroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[POUR] <cleaning_solution> <rag>",
"[PUTOBJBACK] <cleaning_solution>",
"[WALK] <mirror>",
"[WIPE] <mirror>",
"[WIPE] <mirror>",
"[WIPE] <mirror>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'detergent', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'broom', 'wall', 'pasta', 'powersocket', 'shelf', 'check', 'television', 'doorjamb', 'mouse', 'dresser', 'light', 'table']
Task:Work
response:
{
"thoughts": I walk to the living room. I find the computer and turn it on. I look at the computer screen. I move and click the mouse to select buttons on the screen.,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[PUSH] <mouse>', '[FIND] <button>', '[PUSH] <button>']
}
|
Scene_Objects:['sheets', 'tablelamp', 'toilet', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'pillow', 'broom', 'wall', 'nightstand', 'television', 'ice', 'curtain', 'mouse', 'maindoor', '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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'measuring_cup', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'floor_lamp', 'mousepad', 'wall', 'nightstand', 'novel', 'video_game_controller', 'television', 'mouse', 'door', 'napkin']
Task:Study
response:
{
"thoughts": Study norwegian,
"actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}
|
Scene_Objects:['toilet', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'cleaning_solution', 'faucet', 'balanceball', 'window', 'clothes_socks', 'food_orange', 'wall', 'powersocket', 'bench', 'cutting_board', 'photoframe', 'novel', 'check', 'rag', 'lighter', 'mouse', 'kitchen_counter', 'hair', 'sink', 'bathroom_cabinet', 'home_office', 'tooth_paste', 'scrabble', 'dirt']
Task:Wash sink
response:
| {
"thoughts": "Turn on faucet. Rub down sink.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[FIND] <sink>",
"[POUR] <cleaning_solution> <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[SCRUB] <sink>",
"[WASH] <sink>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'walllamp', 'wallshelf', 'ceiling', 'phone', 'keyboard', 'thread', 'piano_bench', 'brush', 'mat', 'ceilinglamp', 'window', 'oil', 'closetdrawer', 'mousepad', 'food_peanut_butter', 'candle', 'nightstand', 'powersocket', 'newspaper', 'novel', 'television', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'home_office', 'table', 'instrument_violin']
Task:Turn on light
response:
{
"thoughts": Twist the lamp switch until the light goes on.,
"actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}
|
Scene_Objects:['tablelamp', 'microwave', 'dog', 'blow_dryer', 'trashcan', 'orchid', 'bathroom_counter', 'longboard', 'ceiling', 'character', 'bedroom', 'computer', 'mop_bucket', 'stereo', 'shower', 'window', 'food_peanut_butter', 'food_orange', 'bench', 'oven', 'bed', 'toilet_paper', 'television', 'razor', 'curtain', 'towel_rack', 'cupboard', 'door', 'dishwasher', 'soap']
Task:Put umbrella away
response:
| {
"thoughts": "Place the umbrella in the umbrella bucket point first.",
"actions": [
"[WALK] <home_office>",
"[WALK] <mop_bucket>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'tablelamp', 'microwave', 'detergent', 'clothes_underwear', 'ceiling', 'character', 'desk', 'mail', 'table_cloth', 'bookmark', 'shoe-shine_kit', 'faucet', 'electric_shaver', 'mousepad', 'candle', 'food_jam', 'food_orange', 'nightstand', 'powersocket', 'newspaper', 'coin', 'food_onion', 'pencil', 'dresser', 'home_office', 'dishwasher', 'tooth_paste', 'coffee']
Task:Browse internet
response:
{
"thoughts": The task is browse and surf on the internet regarding a particular topic,
"actions": ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>']
}
|
Scene_Objects:['walllamp', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'bedroom', 'bookshelf', 'computer', 'ceilinglamp', 'deck_of_cards', 'pillow', 'dining_room', 'wall', 'bench', 'toy', 'box', 'photoframe', 'clothes_gloves', 'novel', 'video_game_controller', 'cards', 'vacuum_cleaner', 'dresser', 'controller', 'maindoor', 'napkin', 'dishwasher', 'instrument_violin']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'scissors', 'crayon', 'toilet', 'jelly', 'walllamp', 'nail_polish', 'detergent', 'food_cake', 'alcohol', 'piano_bench', 'toaster', 'food_noodles', 'garbage_can', 'pillow', 'broom', 'oven', 'toy', 'food_vegetable', 'food_food', 'television', 'oven_mitts', 'doorjamb', 'pencil', 'headset', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'pantry']
Task:Organize pantry
response:
{
"thoughts": Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.,
"actions": ['[WALK] <dining_room>', '[WALK] <pantry>', '[FIND] <food_food>', '[GRAB] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[FIND] <garbage_can>', '[PUTBACK] <food_food> <garbage_can>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <dry_pasta>', '[GRAB] <dry_pasta>', '[TURNTO] <dry_pasta>', '[LOOKAT] <dry_pasta>', '[PUTOBJBACK] <dry_pasta>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[PUSH] <food_food>', '[FIND] <food_noodles>', '[GRAB] <food_noodles>', '[TURNTO] <food_noodles>', '[LOOKAT] <food_noodles>', '[PUTOBJBACK] <food_noodles>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'bathroom', 'detergent', 'ceilingfan', 'milk', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'food_rice', 'mouse', 'pencil', 'pajamas', 'maindoor', 'board_game', 'teeth', 'shoe_rack']
Task:Wipe down baseboards please
response:
| {
"thoughts": "Use a rag to get all the dust off the baseboards please.",
"actions": [
"[WALK] <home_office>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <wall>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'button', 'mat', 'shower', 'mousepad', 'oil', 'closetdrawer', 'microphone', 'oven', 'cutting_board', 'check', 'centerpiece', 'diary', 'clothes_dress', 'clothes_scarf', 'napkin', 'tooth_paste']
Task:Pet cat
response:
{
"thoughts": Walk into the living room. Walk up to the cat. Pet the cat with your hand.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['tablelamp', 'measuring_cup', 'freezer', 'walllamp', 'bathroom', 'hanger', 'phone', 'desk', 'bookshelf', 'ceilinglamp', 'shoe-shine_kit', 'balanceball', 'faucet', 'couch', 'nightstand', 'wall', 'bench', 'powersocket', 'clothes_gloves', 'check', 'television', 'food_onion', 'after_shave', 'curtain', 'shaving_cream', 'mouse', 'maindoor', 'sink', 'bag', 'home_office']
Task:Open front door
response:
| {
"thoughts": "Walk over to the front door, turn the knob, and open the door.",
"actions": [
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'tea', 'microwave', 'chair', 'drawing', 'orchid', 'floor', 'computer', 'food_bacon', 'table_cloth', 'stovefan', 'toaster', 'homework', 'mousepad', 'couch', 'powersocket', 'oven', 'bench', 'check', 'oven_mitts', 'coffee_filter', 'curtain', 'rag', 'doorjamb', 'kitchen_counter', 'shoes', 'bathtub', 'dishwasher']
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:['pot', 'filing_cabinet', 'ground_coffee', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'shampoo', 'character', 'computer', 'ceilinglamp', 'mat', 'iron', 'plate', 'window', 'couch', 'dining_room', 'wall', 'powersocket', 'basket_for_clothes', 'photoframe', 'newspaper', 'video_game_controller', 'television', 'centerpiece', 'doorjamb', 'towel_rack', 'door', 'bathroom_cabinet', 'table']
Task:Read book
response:
| {
"thoughts": "Sit on a couch, grab a book, open it, and scan the pages",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TURNTO] <novel>",
"[LOOKAT] <novel>",
"[READ] <novel>",
"[READ] <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:['food_bread', 'scissors', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'knifeblock', 'orchid', 'hanger', 'floor', 'bedroom', 'tea_bag', 'envelope', 'clothes_jacket', 'toaster', 'balanceball', 'faucet', 'iron', 'bed', 'coffe_maker', 'wooden_spoon', 'cards', 'headset', 'dresser', 'napkin', 'spoon', 'vase', 'instrument_violin', 'laser_pointer', 'creditcard']
Task:Receive credit card
response:
{
"thoughts": hear the dooble, go to door, take de envelope, open it with a scissor, take the creditcard,
"actions": ['[WALK] <home_office>', '[WALK] <envelope>', '[FIND] <envelope>', '[GRAB] <envelope>', '[WALK] <home_office>', '[WALK] <scissors>', '[FIND] <scissors>', '[OPEN] <envelope>', '[FIND] <creditcard>', '[GRAB] <creditcard>']
}
|
Scene_Objects:['filing_cabinet', 'mop', 'chair', 'band-aids', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'laptop', 'toaster', 'foundation', 'pillow', 'wall', 'powersocket', 'bench', 'novel', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'napkin', 'light', 'soap', 'instrument_violin']
Task:Turn off light
response:
| {
"thoughts": "Grasp light switch, flip light switch.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <light>",
"[FIND] <light>",
"[TURNTO] <light>",
"[SWITCHOFF] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'computer', 'button', 'brush', 'mat', 'ceilinglamp', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'standingmirror', 'coffe_maker', 'television', 'food_rice', 'wine', 'curtain', 'doorjamb', 'diary', 'pencil', 'door', 'bathroom_cabinet', '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>']
}
|
Scene_Objects:['microwave', 'chair', 'detergent', 'trashcan', 'dough', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'thread', 'clothes_jacket', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'brush', 'wall', 'toilet_paper', 'television', 'wooden_spoon', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'cupboard', 'laundry_detergent', 'light', 'dishwasher', 'board_game', 'clothes_shirt', 'teeth']
Task:Sweep hallway please
response:
| {
"thoughts": "Vacuum all the way up and down the hallway. Get all the dirt and crumbs out of carpet please.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[WALK] <dresser>",
"[PUTIN] <vacuum_cleaner> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door']
Task:Work
response:
{
"thoughts": I need to complete work on my computer, so I will be pulling out my chair, turning on my computer and begin my task.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[PULL] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['blender', 'walllamp', 'bathroom', 'trashcan', 'food_carrot', 'drawing', 'floor', 'phone', 'bedroom', 'stamp', 'keyboard', 'table_cloth', 'stovefan', 'ceilinglamp', 'window', 'couch', 'towel', 'wall', 'oven', 'bed', 'photoframe', 'clothes_gloves', 'television', 'doorjamb', 'laundry_detergent', 'door', 'maindoor', 'home_office', 'table', 'clothes_shirt']
Task:Read magazine
response:
| {
"thoughts": "Please sit on the couch and read a magazine",
"actions": [
"[WALK] <home_office>",
"[WALK] <newspaper>",
"[FIND] <newspaper>",
"[GRAB] <newspaper>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TURNTO] <newspaper>",
"[LOOKAT] <newspaper>",
"[READ] <newspaper>",
"[READ] <newspaper>",
"[READ] <newspaper>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'newspaper', 'television', 'curtain', 'rag', 'doorjamb', 'mouse', 'door', 'bathtub', 'table']
Task:Use computer
response:
{
"thoughts": Browse reddit,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Scene_Objects:['filing_cabinet', 'microwave', 'freezer', 'orchid', 'drawing', 'knifeblock', 'floor', 'folder', 'envelope', 'table_cloth', 'mop_bucket', 'stovefan', 'brush', 'ceilinglamp', 'window', 'foundation', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'newspaper', 'light_bulb', 'food_donut', 'wooden_spoon', 'doorjamb', 'door', 'maindoor', 'napkin', 'light']
Task:Put toys away
response:
| {
"thoughts": "Pick up all the toys on the floor and put them in their correct storage bin or shelf.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <toy>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'spectacles', 'scissors', 'knife', 'hanger', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'keyboard', 'piano_bench', 'stovefan', 'stereo', 'window', 'wall', 'powersocket', 'cutting_board', 'cup', 'bed', 'console', 'pencil', 'shoes', 'door', 'bathtub', 'bag', 'instrument_guitar', 'table', 'home_office', 'light', 'board_game']
Task:Listen to music
response:
{
"thoughts": I walk into my room and turn the radio on so that I can listen to music.,
"actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'toilet', 'chair', 'cat', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'food_bacon', 'stovefan', 'ceilinglamp', 'iron', 'dustpan', 'pillow', 'wall', 'toy', 'box', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cd', 'dresser', 'cupboard', 'light', 'table']
Task:Vacuum
response:
| {
"thoughts": "Plug in the vacuum. Turn it on. Push it back and forth across the floor until all the debris is gone.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[WALK] <dresser>",
"[PUTIN] <vacuum_cleaner> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'toilet', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'shampoo', 'stovefan', 'mat', 'shower', 'window', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'newspaper', 'food_food', 'drinking_glass', 'water', 'curtain', 'doorjamb', 'dresser', 'food_steak', 'door', 'home_office', 'light']
Task:Drink
response:
{
"thoughts": im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <drinking_glass>', '[DRINK] <drinking_glass>']
}
|
Scene_Objects:['pot', 'food_bread', 'food_pizza', 'dog', 'freezer', 'bathroom', 'trashcan', 'milk', 'knife', 'orchid', 'floor', 'ceiling', 'bedroom', 'purse', 'toaster', 'ceilinglamp', 'faucet', 'balanceball', 'garbage_can', 'food_dessert', 'wall', 'nightstand', 'oven', 'tape', 'food_cheese', 'food_vegetable', 'novel', 'toothbrush_holder', 'ice', 'colander']
Task:Rotate stock in refrigerator
response:
| {
"thoughts": "Throw out expired items, put older items in front.",
"actions": [
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_bread>",
"[GRAB] <food_bread>",
"[TURNTO] <food_bread>",
"[LOOKAT] <food_bread>",
"[PUTOBJBACK] <food_bread>",
"[FIND] <food_cheese>",
"[GRAB] <food_cheese>",
"[TURNTO] <food_cheese>",
"[LOOKAT] <food_cheese>",
"[FIND] <garbage_can>",
"[PUTBACK] <food_cheese> <garbage_can>",
"[FIND] <food_cheese>",
"[GRAB] <food_cheese>",
"[TURNTO] <food_cheese>",
"[LOOKAT] <food_cheese>",
"[PUTOBJBACK] <food_cheese>",
"[FIND] <food_dessert>",
"[TURNTO] <food_dessert>",
"[LOOKAT] <food_dessert>",
"[PUSH] <food_dessert>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[TURNTO] <food_vegetable>",
"[LOOKAT] <food_vegetable>",
"[PUTBACK] <food_vegetable> <garbage_can>",
"[FIND] <milk>",
"[GRAB] <milk>",
"[TURNTO] <milk>",
"[LOOKAT] <milk>",
"[PUTOBJBACK] <milk>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'freezer', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'shampoo', 'bedroom', 'bookshelf', 'thread', 'mop_bucket', 'tvstand', 'faucet', 'mousepad', 'towel', 'powersocket', 'bed', 'coffe_maker', 'television', 'oven_mitts', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathtub', 'maindoor', 'home_office', 'bathroom_cabinet', 'table']
Task:Pick up phone
response:
{
"thoughts": Enter living room. Walk to telephone. Pick up from hook.,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'beer', 'measuring_cup', 'chair', 'ground_coffee', 'knifeblock', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mail', 'toaster', 'picture', 'dustpan', 'wall', 'bench', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'after_shave', 'dresser', 'maindoor', 'dishwasher']
Task:Make coffee
response:
| {
"thoughts": "Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[OPEN] <coffe_maker>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[GRAB] <ground_coffee>",
"[PUTOBJBACK] <ground_coffee>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <coffe_maker>",
"[CLOSE] <coffe_maker>",
"[SWITCHON] <coffe_maker>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'toilet', 'chair', 'walllamp', 'bathroom', 'ground_coffee', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'bookshelf', 'toaster', 'tvstand', 'faucet', 'shower', 'foundation', 'mousepad', 'wall', 'cup', 'newspaper', 'bed', 'coffe_maker', 'doorjamb', 'dresser', 'conditioner', 'door', 'light', 'dishwasher', 'tooth_paste']
Task:Change TV channel
response:
{
"thoughts": take remote control, push "change channel" button,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[PUSH] <remote_control>']
}
|
Scene_Objects:['pot', 'juice', 'food_ice_cream', 'beer', 'food_oatmeal', 'microwave', 'freezer', 'walllamp', 'ground_coffee', 'milk', 'knifeblock', 'drawing', 'food_egg', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'toaster', 'food_peanut_butter', 'candle', 'pillow', 'bowl', 'wall', 'bench', 'cup', 'newspaper', 'food_food', 'coffe_maker', 'check', 'food_onion', 'cards', 'kitchen_counter', 'cupboard', 'sink', 'table', 'dishwasher', 'laser_pointer']
Task:Cook some food
response:
| {
"thoughts": "Put oatmeal into a bowl. Add milk. Heat in a microwave. Put pod of coffee into a coffee maker. Activate. Pour juice into a glass.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[FIND] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <bowl>",
"[GRAB] <bowl>",
"[FIND] <food_oatmeal>",
"[GRAB] <food_oatmeal>",
"[PUTBACK] <food_oatmeal> <bowl>",
"[GRAB] <food_oatmeal>",
"[PUTOBJBACK] <food_oatmeal>",
"[CLOSE] <cupboard>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <milk>",
"[GRAB] <milk>",
"[POUR] <milk> <bowl>",
"[PUTOBJBACK] <milk>",
"[CLOSE] <freezer>",
"[FIND] <microwave>",
"[OPEN] <microwave>",
"[PUTIN] <bowl> <microwave>",
"[CLOSE] <microwave>",
"[SWITCHON] <microwave>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[FIND] <coffe_maker>",
"[OPEN] <coffe_maker>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[CLOSE] <coffe_maker>",
"[SWITCHON] <coffe_maker>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <juice>",
"[GRAB] <juice>",
"[POUR] <juice> <cup>",
"[PUTOBJBACK] <juice>",
"[CLOSE] <freezer>",
"[FIND] <table>",
"[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:['scissors', 'toilet', 'freezer', 'bathroom', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'thread', 'stovefan', 'mat', 'faucet', 'towel', 'dining_room', 'wall', 'wall_clock', 'oven', 'bench', 'nightstand', 'check', 'coffee_filter', 'tray', 'shaving_cream', 'towel_rack', 'pencil', 'mouse', 'sink', 'bathroom_cabinet', 'soap']
Task:Wash hands
response:
{
"thoughts": I walk into the bathroom. Walk to the sink. Turn on tap. Get soap. Wash and rinse hands. Turn off tap. Dry hands.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[TURNTO] <sink>', '[LOOKAT] <sink>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[RINSE] <soap>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>']
}
|
Scene_Objects:['glue', 'pot', 'tablelamp', 'detergent', 'cat', 'knife', 'drawing', 'hanger', 'bathroom_counter', 'desk', 'food_cake', 'purse', 'envelope', 'piano_bench', 'stovefan', 'toaster', 'stereo', 'balanceball', 'floor_lamp', 'powersocket', 'love_seat', 'newspaper', 'bed', 'photoframe', 'video_game_controller', 'diary', 'maindoor', 'light', 'soap', 'board_game']
Task:Read
response:
| {
"thoughts": "Sit on an easy chair. Turn on music. Take a book and read. Turn on lamp at night.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[SWITCHON] <stereo>",
"[FIND] <newspaper>",
"[GRAB] <newspaper>",
"[FIND] <love_seat>",
"[SIT] <love_seat>",
"[FIND] <floor_lamp>",
"[SWITCHON] <floor_lamp>",
"[READ] <newspaper>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'food_bacon', 'stovefan', 'mat', 'tvstand', 'window', 'mousepad', 'form', 'dining_room', 'wall', 'cutting_board', 'bed', 'clothes_gloves', 'check', 'television', 'oven_mitts', 'curtain', 'mouse', 'hair', 'napkin', 'vase', 'instrument_violin', 'laser_pointer']
Task:Gaze out window
response:
{
"thoughts": Look at the yard from the window,
"actions": ['[WALK] <home_office>', '[WALK] <window>', '[FIND] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']
}
|
Scene_Objects:['mop', 'bathroom', 'detergent', 'trashcan', 'food_carrot', 'knifeblock', 'floor', 'bedroom', 'thread', 'computer', 'brush', 'plate', 'picture', 'window', 'mousepad', 'clothes_hat', 'pillow', 'wall', 'box', 'bed', 'television', 'curtain', 'food_onion', 'kitchen_counter', 'maindoor', 'table', 'light', 'clothes_shirt', 'dirt', 'teeth']
Task:Read book
response:
| {
"thoughts": "Climb into bed, then read the novel",
"actions": [
"[WALK] <bedroom>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[WALK] <bed>",
"[LIE] <bed>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'trashcan', 'drawing', 'orchid', 'ceiling', 'bedroom', 'mail', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'wall_clock', 'basket_for_clothes', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'door', 'clothes_dress', 'bathroom_cabinet', 'table', 'light', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on.,
"actions": ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'mousepad', 'couch', 'wall', 'bed', 'food_food', 'tray', 'after_shave', 'rag', 'doorjamb', 'maindoor', 'bathroom_cabinet', 'dishwasher', 'vase']
Task:Put away groceries
response:
| {
"thoughts": "Place groceries in refrigerator from shopping at the grocery store.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'fork', 'tablelamp', 'tea', 'band-aids', 'bathroom', 'drawing', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'remote_control', 'computer', 'food_bacon', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_pants', 'pillow', 'wall', 'standingmirror', 'television', 'curtain', 'doorjamb', 'table', 'soap']
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:['tablelamp', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'phone', 'desk', 'stamp', 'keyboard', 'bookshelf', 'computer', 'table_cloth', 'ceilinglamp', 'balanceball', 'faucet', 'mousepad', 'wall', 'nightstand', 'bench', 'check', 'doorjamb', 'mouse', 'controller', 'maindoor', 'light', 'dishwasher']
Task:Research
response:
| {
"thoughts": "I read different articles online to gain a better understanding of a particular business, industry, method, terminology, etc.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <check>",
"[GRAB] <check>",
"[READ] <check>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['freezer', 'walllamp', 'bathroom', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'shampoo', 'tvstand', 'faucet', 'stereo', 'clothes_socks', 'couch', 'clothes_pants', 'cutting_board', 'basket_for_clothes', 'photoframe', 'food_food', 'video_game_controller', 'coffe_maker', 'coffee_filter', 'television', 'tray', 'curtain', 'shaving_cream', 'laundry_detergent', 'maindoor', 'spoon', 'home_office', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": I go to the bathroom and open the washing machine there. I take my laundry basket and put each item of laundry into the machine. Then I take the laundry detergent and pour some into the machine. Finally I close the machine and switch it on.,
"actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['measuring_cup', 'microwave', 'toilet', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'phone', 'food_cake', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'stereo', 'electric_shaver', 'homework', 'balanceball', 'picture', 'window', 'dining_room', 'powersocket', 'cup', 'photoframe', 'mirror', 'tray', 'pencil', 'shoes', 'conditioner', 'sink', 'creditcard']
Task:Shave
response:
| {
"thoughts": "Pick up razor. Push the button to turn it on. Move it in a linear motion against the beard growth. Make sure to get the bottom of your chin, your cheeks, and mustache area.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <electric_shaver>",
"[FIND] <electric_shaver>",
"[GRAB] <electric_shaver>",
"[FIND] <mirror>",
"[TURNTO] <mirror>",
"[SWITCHON] <electric_shaver>",
"[SWITCHOFF] <electric_shaver>",
"[PUTOBJBACK] <electric_shaver>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'juice', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'picture', 'homework', 'mousepad', 'wall', 'oven', 'toy', 'newspaper', 'check', 'television', 'mouse', 'laundry_detergent', 'conditioner', 'laser_pointer']
Task:Push in desk chair
response:
{
"thoughts": Push the desk chair until it is under the desk.,
"actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[TOUCH] <chair>', '[PUSH] <chair>']
}
|
Scene_Objects:['fork', 'pot', 'food_bread', 'scissors', 'microwave', 'freezer', 'milk', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mail', 'food_bacon', 'ceilinglamp', 'shower', 'faucet', 'bowl', 'food_kiwi', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'diary', 'dishrack', 'controller', 'conditioner', 'home_office']
Task:Get glass of milk
response:
| {
"thoughts": "Get an empty glass. Take milk from refrigerator and open it. Pour milk into glass.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cup>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <milk>",
"[GRAB] <milk>",
"[POUR] <milk> <cup>",
"[PUTOBJBACK] <milk>",
"[CLOSE] <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'chair', 'freezer', 'detergent', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'shower', 'faucet', 'window', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'check', 'television', 'food_food', 'ice', 'rag', 'towel_rack', 'kitchen_counter', 'cupboard']
Task:Turn on light
response:
{
"thoughts": I go home and it's dark so I can not see anything,
"actions": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}
|
Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'chair', 'walllamp', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'bills', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'fax_machine', 'doorjamb', 'mouse', 'light', 'dishwasher', '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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'walllamp', 'drawing', 'wallshelf', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'dresser', 'sink', 'instrument_violin']
Task:Watch TV
response:
{
"thoughts": I go to the the living room, sit down on the sofa, and then I switch on the TV with the TV remote,
"actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']
}
|
Scene_Objects:['pot', 'tablelamp', 'toilet', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'shoe-shine_kit', 'couch', 'wall', 'video_game_controller', 'television', 'coin', 'curtain', 'kitchen_counter', 'headset', 'dresser', 'controller', 'table', 'dishwasher', 'soap']
Task:Watch TV
response:
| {
"thoughts": "I sit down on sofa, get the remote, turn on tv, change channel to show I want to watch",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'food_salt', 'toilet', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'tvstand', 'foundation', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'television', 'food_rice', 'doorjamb', 'shoes', 'dresser', 'door', 'light', '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>']
}
|
Scene_Objects:['ironing_board', 'dry_pasta', 'food_salt', 'toilet', 'freezer', 'band-aids', 'nail_polish', 'detergent', 'food_carrot', 'knifeblock', 'longboard', 'clothes_jacket', 'mat', 'iron', 'mousepad', 'form', 'towel', 'dining_room', 'cup', 'bed', 'coffe_maker', 'video_game_controller', 'television', 'ice', 'doorjamb', 'towel_rack', 'home_office', 'light', 'vase', 'clothes_shirt']
Task:Iron shirt
response:
| {
"thoughts": "Set up an ironing board and an iron. Lay a shirt on board. Run iron over shirt until it is free of wrinkles.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <ironing_board>",
"[FIND] <ironing_board>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUTBACK] <clothes_shirt> <ironing_board>",
"[FIND] <iron>",
"[GRAB] <iron>",
"[PLUGIN] <iron>",
"[PLUGOUT] <iron>",
"[PUTOBJBACK] <iron>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'mop', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'toaster', 'stereo', 'window', 'wall', 'bed', 'novel', 'coffe_maker', 'coffee_filter', 'water', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'spoon', 'light', 'dishwasher', 'table', 'coffee']
Task:Make coffee
response:
{
"thoughts": Go to the kitchen and make coffee.,
"actions": ['[RUN] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[PUTOBJBACK] <coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['pot', 'microwave', 'toilet', 'chair', 'freezer', 'detergent', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'wall', 'bench', 'love_seat', 'food_food', 'check', 'television', 'coffe_maker', 'curtain', 'table', 'dishwasher']
Task:Watch TV
response:
| {
"thoughts": "Sit and watch the television",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <love_seat>",
"[SIT] <love_seat>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'walllamp', 'ground_coffee', 'detergent', 'trashcan', 'orchid', 'drawing', 'bedroom', 'tea_bag', 'bookshelf', 'envelope', 'alcohol', 'computer', 'ceilinglamp', 'mat', 'shower', 'deck_of_cards', 'food_noodles', 'microphone', 'bowl', 'wall', 'bench', 'powersocket', 'photoframe', 'television', 'dresser', 'napkin', 'table', 'clothes_shirt']
Task:Pet cat
response:
{
"thoughts": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'food_salt', 'toilet', 'freezer', 'detergent', 'bills', 'orchid', 'hanger', 'ceiling', 'envelope', 'table_cloth', 'brush', 'mat', 'ceilinglamp', 'shower', 'stovefan', 'nightstand', 'powersocket', 'bench', 'photoframe', 'check', 'food_food', 'wooden_spoon', 'sink', 'napkin', 'instrument_guitar', 'table', 'coffee']
Task:Pull up carpet
response:
| {
"thoughts": "Pry up a corner of your old dirty carpet. Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt.",
"actions": [
"[WALK] <home_office>",
"[WALK] <mat>",
"[FIND] <mat>",
"[TOUCH] <mat>",
"[PULL] <mat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'measuring_cup', 'walllamp', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'broom', 'wall', 'newspaper', 'light_bulb', 'novel', 'television', 'curtain', 'doorjamb', 'lighter', 'cupboard', 'table', '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>']
}
|
Scene_Objects:['ceilingfan', 'toothbrush', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'longboard', 'mop_bucket', 'mat', 'tvstand', 'faucet', 'couch', 'clothes_pants', 'towel', 'wall', 'basket_for_clothes', 'photoframe', 'light_bulb', 'wooden_spoon', 'after_shave', 'coffee', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'laser_pointer', 'hands_both', 'shoe_rack']
Task:Wash hands
response:
| {
"thoughts": "Turn faucet clockwise to turn on water. Place hands under stream of water, pick up soap, rub hands with soap. Put soap back down. Rub hands together with soap on them. Rinse hands under water from faucet. Turn faucet counterclockwise to turn water off. Dry hands by rubbing them on a towel.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[FIND] <hands_both>",
"[SCRUB] <hands_both>",
"[PUTOBJBACK] <soap>",
"[WASH] <hands_both>",
"[SWITCHOFF] <faucet>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[WIPE] <hands_both>",
"[PUTOBJBACK] <towel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'blender', 'food_salt', 'chair', 'walllamp', 'nail_polish', 'bathroom', 'milk', 'drawing', 'wallshelf', 'clothes_underwear', 'bathroom_counter', 'floor', 'character', 'stamp', 'envelope', 'button', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'closetdrawer', 'form', 'coffe_maker', 'water', 'mouse', 'dresser', 'hairbrush', 'cupboard', 'table']
Task:Drink
response:
{
"thoughts": walk to kitchen, hold drinking glass, lift glass, pour water in drinking glass,
"actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[FIND] <water>', '[GRAB] <water>', '[WALK] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}
|
Scene_Objects:['food_bread', 'scissors', 'crayon', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'window', 'homework', 'couch', 'wall', 'child', 'bench', 'photoframe', 'newspaper', 'coffe_maker', 'razor', 'television', 'kitchen_counter', 'cupboard', 'table', 'coffee']
Task:Let baby learn how to walk
response:
| {
"thoughts": "The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.",
"actions": [
"[WALK] <home_office>",
"[WALK] <child>",
"[FIND] <child>",
"[TOUCH] <child>",
"[GREET] <child>",
"[FIND] <couch>",
"[TURNTO] <couch>",
"[POINTAT] <couch>",
"[TURNTO] <child>",
"[LOOKAT] <child>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'dog', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'couch', 'form', 'wall', 'powersocket', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'mouse', 'cupboard', 'bathtub', 'sink', 'table']
Task:Work
response:
{
"thoughts": go to home office. turn the computer on. begin working,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']
}
|
Scene_Objects:['measuring_cup', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'ceilinglamp', 'faucet', 'teeth', 'towel', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'light_bulb', 'toilet_paper', 'television', 'food_donut', 'tray', 'cards', 'towel_rack', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']
Task:Hand washing
response:
| {
"thoughts": "Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[FIND] <hands_both>",
"[SCRUB] <hands_both>",
"[PUTOBJBACK] <soap>",
"[WASH] <hands_both>",
"[SWITCHOFF] <faucet>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[WIPE] <hands_both>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'remote_control', 'thread', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'toaster', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'doorjamb', 'pencil', 'dresser', 'door', 'home_office', 'table', 'light']
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:['filing_cabinet', 'microwave', 'blow_dryer', 'cat', 'trashcan', 'toothbrush', 'drawing', 'floor', 'character', 'desk', 'wine_glass', 'ceilinglamp', 'plate', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'food_cheese', 'bed', 'food_food', 'check', 'television', 'coffee_filter', 'curtain', 'door', 'spoon', 'table']
Task:Entertain
response:
| {
"thoughts": "Give guests wine, cheese, crackers and sit and talk",
"actions": [
"[WALK] <home_office>",
"[WALK] <food_cheese>",
"[FIND] <food_cheese>",
"[FIND] <food_food>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <wine_glass>",
"[GRAB] <wine_glass>",
"[DRINK] <wine_glass>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'food_bread', 'toilet', 'bathroom', 'milk', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'towel', 'wall', 'bench', 'cup', 'photoframe', 'toothbrush_holder', 'water', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'clothes_skirt', 'soap']
Task:Take shower
response:
{
"thoughts": Walk into bathroom. Turn on shower. Take off clothing. Climb into shower. Rinse with water. Soap up body. Rinse off with water. Turn off shower. Climb out of shower. Dry off with towel.,
"actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>', '[TURNTO] <shower>', '[FIND] <water>', '[RINSE] <water>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <water>', '[FIND] <towel>', '[GRAB] <towel>', '[SCRUB] <towel>']
}
|
Scene_Objects:['sponge', 'pot', 'sheets', 'food_ice_cream', 'food_salt', 'measuring_cup', 'microwave', 'toilet', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'floor', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'plate', 'window', 'floor_lamp', 'mousepad', 'couch', 'pillow', 'wall', 'clothes_gloves', 'novel', 'check', 'television', 'food_rice', 'doorjamb', 'table']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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:['fork', 'crayon', 'chair', 'food_butter', 'food_carrot', 'ceilingfan', 'drawing', 'knife', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'thread', 'brush', 'plate', 'wall', 'bench', 'powersocket', 'oven', 'check', 'food_food', 'doorjamb', 'console', 'dresser', 'cupboard', 'door', 'maindoor', 'table', 'light']
Task:Eat
response:
| {
"thoughts": "I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[FIND] <table>",
"[PUTBACK] <food_food> <table>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[FIND] <knife>",
"[GRAB] <knife>",
"[FIND] <plate>",
"[EAT] <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:['sheets', 'water_glass', 'pot', 'spectacles', 'chair', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'ceiling', 'character', 'stovefan', 'mat', 'faucet', 'food_orange', 'wall', 'oven', 'cutting_board', 'food_food', 'water', 'tray', 'food_onion', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'instrument_guitar', 'home_office']
Task:Drink
response:
{
"thoughts": I go to the kitchen, take a glass from the cupboard, fill with water and drink,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>', '[RINSE] <water_glass>', '[PUTBACK] <water_glass> <cupboard>']
}
|
Scene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'ground_coffee', 'trashcan', 'knifeblock', 'orchid', 'floor', 'ceiling', 'folder', 'plate', 'faucet', 'tvstand', 'mousepad', 'candle', 'wall', 'pasta', 'oven', 'colander', 'wine', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'hair', 'sink', 'vase', 'soap']
Task:Wipe down counter
response:
| {
"thoughts": "Clean counter",
"actions": [
"[WALK] <dining_room>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <rag>",
"[SQUEEZE] <rag>",
"[SWITCHOFF] <faucet>",
"[WALK] <kitchen_counter>",
"[WIPE] <kitchen_counter>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light']
Task:Greet guests
response:
{
"thoughts": Answer the door. Smile and give a warm hello, or other appropriate greeting. With newcomers to your home, offer your hand to be shook. With old friends it is appropriate to hug, or kiss one another on the cheek.,
"actions": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']
}
|
Scene_Objects:['glue', 'food_bread', 'chair', 'freezer', 'band-aids', 'walllamp', 'food_butter', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'button', 'clothes_jacket', 'toaster', 'ceilinglamp', 'microphone', 'wall', 'oven', 'powersocket', 'bed', 'food_food', 'coffe_maker', 'oven_mitts', 'ice', 'tray', 'curtain', 'pencil', 'clothes_dress', 'dishwasher']
Task:Make toast
response:
| {
"thoughts": "Place slices of bread in a toaster ,wait for the bread to pop up .Set aside.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_bread>",
"[GRAB] <food_bread>",
"[CLOSE] <freezer>",
"[FIND] <toaster>",
"[PLUGIN] <toaster>",
"[PUTBACK] <food_bread> <toaster>",
"[SWITCHON] <toaster>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'comb', 'door', 'light']
Task:Read book
response:
{
"thoughts": Find book, grab book, fin bookmark, sit down somewhere comfortable, open book, read book, close book after reading.,
"actions": ['[WALK] <desk>', '[FIND] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[FIND] <couch>', '[SIT] <couch>', '[GRAB] <novel>', '[READ] <novel>', '[PUTBACK] <bookmark> <novel>']
}
|
Scene_Objects:['filing_cabinet', 'food_salt', 'crayon', 'measuring_cup', 'tea', 'mop', 'chair', 'nail_polish', 'bathroom', 'hanger', 'shampoo', 'phone', 'character', 'thread', 'tvstand', 'food_peanut_butter', 'bench', 'tape', 'food_food', 'mouthwash', 'razor', 'wooden_spoon', 'curtain', 'lighter', 'controller', 'laundry_detergent', 'door', 'bag', 'dishwasher', 'teeth']
Task:Watch fly
response:
| {
"thoughts": "Look around for a fly, often on a wall or ceiling. Follow it's movements.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <fly>",
"[FIND] <fly>",
"[TURNTO] <fly>",
"[LOOKAT] <fly>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'food_bread', 'crayon', 'tea', 'freezer', 'walllamp', 'bathroom', 'detergent', 'blow_dryer', 'drawing', 'floor', 'desk', 'thread', 'mop_bucket', 'tvstand', 'towel', 'wall', 'toy', 'cup', 'check', 'razor', 'food_donut', 'wine', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'laundry_detergent', 'light', 'soap']
Task:Vacuum
response:
{
"thoughts": Robot has a vacuum underneath its feat/body that will allow it to clean the surface of the floor.,
"actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <vacuum_cleaner>', '[GRAB] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PLUGIN] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[WALK] <dining_room>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[PULL] <vacuum_cleaner>', '[PUSH] <vacuum_cleaner>', '[WALK] <home_office>', '[SWITCHOFF] <vacuum_cleaner>', '[PLUGOUT] <vacuum_cleaner>', '[WALK] <filing_cabinet>', '[PUTBACK] <vacuum_cleaner> <filing_cabinet>', '[CLOSE] <filing_cabinet>']
}
|
Scene_Objects:['trashcan', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'toaster', 'mat', 'stereo', 'window', 'food_jam', 'pillow', 'dining_room', 'wall', 'powersocket', 'bed', 'check', 'mouthwash', 'television', 'tray', 'curtain', 'dishrack', 'dresser', 'laundry_detergent', 'hairdryer', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'shoe_rack']
Task:Read book
response:
| {
"thoughts": "I lie on my bed and read a book.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[WALK] <bed>",
"[LIE] <bed>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'filing_cabinet', 'crayon', 'toilet', 'bathroom', 'nail_polish', 'trashcan', 'food_carrot', 'hanger', 'floor', 'computer', 'toaster', 'window', 'food_jam', 'nightstand', 'oven', 'bench', 'tape', 'photoframe', 'food_food', 'coffe_maker', 'television', 'toilet_paper', 'doorjamb', 'dresser', 'pajamas', 'cupboard', 'door', 'sink', 'home_office']
Task:Listen to music
response:
{
"thoughts": I walk into the living room. I find the stereo and turn it on, and I listen to the music.,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['chair', 'bathroom', 'drawing', 'clothes_underwear', 'bathroom_counter', 'floor', 'character', 'computer', 'mop_bucket', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'window', 'couch', 'towel', 'dining_room', 'wall', 'newspaper', 'bed', 'television', 'wine', 'rag', 'mouse', 'napkin', 'bathroom_cabinet', 'table', 'dishwasher', 'light', 'soap']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'blow_dryer', 'knifeblock', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'folder', 'desk', 'food_cake', 'stovefan', 'toaster', 'deck_of_cards', 'faucet', 'candle', 'pillow', 'dining_room', 'oven', 'photoframe', 'check', 'food_food', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'soap', 'board_game', 'clothes_shirt']
Task:Pet cat
response:
{
"thoughts": Walk to living room. Find cat. Walk to cat. Pull cat.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[PULL] <cat>']
}
|
Scene_Objects:['fork', 'dry_pasta', 'food_salt', 'chair', 'drawing', 'bills', 'hanger', 'floor', 'phone', 'ceiling', 'toaster', 'plate', 'wall', 'bench', 'powersocket', 'tape', 'cup', 'bed', 'check', 'food_food', 'tray', 'doorjamb', 'pencil', 'dishrack', 'dresser', 'cupboard', 'door', 'table', 'light', 'laser_pointer']
Task:Eat
response:
| {
"thoughts": "Serve food on dinning table in appropriate utensils, sit on the chair, eat",
"actions": [
"[WALK] <dining_room>",
"[WALK] <table>",
"[FIND] <table>",
"[TURNTO] <table>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[FIND] <plate>",
"[PUTBACK] <food_food> <plate>",
"[GRAB] <food_food>",
"[PUTOBJBACK] <food_food>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[EAT] <plate>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'food_pizza', 'toilet', 'detergent', 'toothbrush', 'orchid', 'wallshelf', 'hanger', 'bedroom', 'bookshelf', 'computer', 'shower', 'window', 'cutting_board', 'food_cheese', 'novel', 'check', 'mouthwash', 'toothbrush_holder', 'wine', 'doorjamb', 'pajamas', 'hairdryer', 'maindoor', 'bathtub', 'home_office', 'door', 'clothes_skirt', 'tooth_paste', 'teeth']
Task:Wash teeth
response:
{
"thoughts": walk to bathroom, look at the toothbrush holder, grab the toothbrush from the toothbrush holder, find the toothpaste, squeeze the toothpaste into toothbrush, now wash the teeth,
"actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>']
}
|
Scene_Objects:['microwave', 'bathroom', 'cat', 'ceilingfan', 'woman', 'drawing', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'wall', 'child', 'oven', 'toy', 'bed', 'clothes_gloves', 'television', 'curtain', 'centerpiece', 'kitchen_counter', 'spoon', 'table', 'vase']
Task:Watch movie
response:
| {
"thoughts": "Sitting and watching a movie with family",
"actions": [
"[WALK] <home_office>",
"[WALK] <child>",
"[FIND] <child>",
"[TURNTO] <child>",
"[LOOKAT] <child>",
"[GREET] <child>",
"[FIND] <woman>",
"[TURNTO] <woman>",
"[LOOKAT] <woman>",
"[GREET] <woman>",
"[WALK] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[TOUCH] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[TOUCH] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[TOUCH] <television>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[WATCH] <television>",
"[WATCH] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'scissors', 'tea', 'freezer', 'walllamp', 'knifeblock', 'knife', 'bills', 'floor', 'toaster', 'mat', 'plate', 'stereo', 'picture', 'tvstand', 'dish_soap', 'microphone', 'wall', 'oven', 'cup', 'light_bulb', 'coffe_maker', 'drinking_glass', 'tray', 'mouse', 'cupboard', 'controller', 'maindoor', 'spoon', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into the dishwasher. Turn on the dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[TURNTO] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[OPEN] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['microwave', 'freezer', 'trashcan', 'knifeblock', 'drawing', 'food_egg', 'clothes_underwear', 'orchid', 'bathroom_counter', 'ceiling', 'folder', 'cleaning_solution', 'mat', 'faucet', 'broom', 'wall', 'toy', 'box', 'photoframe', 'bed', 'food_food', 'mirror', 'paper_towel', 'dresser', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'vase']
Task:Clean mirror
response:
| {
"thoughts": "First spray the mirrors with Windex or window type spray. Take paper towels and wipe until sparkly clean. If they have streaks, repeat the process.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <bathroom_cabinet>",
"[OPEN] <bathroom_cabinet>",
"[FIND] <paper_towel>",
"[GRAB] <paper_towel>",
"[CLOSE] <bathroom_cabinet>",
"[WALK] <mirror>",
"[FIND] <cleaning_solution>",
"[RINSE] <cleaning_solution>",
"[WIPE] <mirror>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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:['pot', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'video_game_console', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'cup', 'video_game_controller', 'television', 'curtain', 'dishrack', 'napkin', 'table', 'vase', 'scrabble', 'shoe_rack']
Task:Play games
response:
| {
"thoughts": "Turn on game. Use controller",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[PLUGIN] <television>",
"[SWITCHON] <television>",
"[FIND] <video_game_console>",
"[PLUGIN] <video_game_console>",
"[SWITCHON] <video_game_console>",
"[FIND] <video_game_console>",
"[FIND] <video_game_controller>",
"[GRAB] <video_game_controller>",
"[WALK] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'mousepad', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'curtain', 'mouse', 'door', 'hairdryer', 'sink', 'food_steak', 'light', 'dishwasher', 'spoon', 'table', 'board_game']
Task:Write school paper
response:
{
"thoughts": Writing and drafting a paper for class work,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']
}
|
Scene_Objects:['pot', 'scissors', 'food_salt', 'toilet', 'band-aids', 'drawing', 'orchid', 'clothes_underwear', 'hanger', 'longboard', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'ceilinglamp', 'mat', 'stereo', 'tvstand', 'towel', 'pillow', 'bowl', 'wall', 'nightstand', 'mouthwash', 'dresser', 'clothes_dress', 'maindoor', 'bathroom_cabinet', 'clothes_skirt', 'creditcard']
Task:Hang up jacket
response:
| {
"thoughts": "I put clothes on hangers and hang them in the closet",
"actions": [
"[WALK] <bedroom>",
"[WALK] <clothes_dress>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[WALK] <dresser>",
"[FIND] <hanger>",
"[OPEN] <dresser>",
"[PUTIN] <clothes_dress> <dresser>",
"[FIND] <clothes_dress>",
"[GRAB] <clothes_dress>",
"[WALK] <dresser>",
"[PUTIN] <clothes_dress> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'spectacles', 'microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'character', 'desk', 'alcohol', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'photoframe', 'light_bulb', 'television', 'curtain', 'kettle', 'napkin', 'bathroom_cabinet', 'table', 'creditcard']
Task:Relax on sofa
response:
{
"thoughts": walk to living room, walk to sofa, sit on sofa.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['sponge', 'toilet', 'bathroom', 'trashcan', 'milk', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'clothes_jacket', 'toaster', 'stovefan', 'tvstand', 'picture', 'window', 'dustpan', 'pillow', 'dining_room', 'wall', 'box', 'bed', 'wine', 'curtain', 'kettle', 'home_office', 'light', 'dishwasher']
Task:Look out window
response:
| {
"thoughts": "I head into my child's room and look out the window to view the neighborhood from a different area in the house.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <window>",
"[TURNTO] <window>",
"[LOOKAT] <window>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'measuring_cup', 'toilet', 'chair', 'drawing', 'food_egg', 'clothes_underwear', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'button', 'shoe-shine_kit', 'shower', 'window', 'broom', 'wall', 'wall_clock', 'powersocket', 'bench', 'standingmirror', 'novel', 'coin', 'doorjamb', 'door', 'light', 'table', 'creditcard']
Task:Read
response:
{
"thoughts": We pick out a book from the bookshelf and read it.,
"actions": ['[WALK] <novel>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']
}
|
Scene_Objects:['fork', 'crayon', 'dog', 'toothbrush', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'faucet', 'shower', 'balanceball', 'mousepad', 'wall', 'pasta', 'powersocket', 'oven', 'nightstand', 'photoframe', 'video_game_controller', 'coffee_filter', 'wooden_spoon', 'console', 'shoes', 'sink', 'bathroom_cabinet', 'tooth_paste', 'teeth']
Task:Brush teeth
response:
| {
"thoughts": "Put toothpaste on toothbrush, brush teeth, rinse mouth",
"actions": [
"[WALK] <bathroom>",
"[WALK] <toothbrush>",
"[FIND] <toothbrush>",
"[GRAB] <toothbrush>",
"[FIND] <tooth_paste>",
"[GRAB] <tooth_paste>",
"[POUR] <tooth_paste> <toothbrush>",
"[PUTOBJBACK] <tooth_paste>",
"[WALK] <sink>",
"[FIND] <teeth>",
"[SCRUB] <teeth>",
"[SCRUB] <teeth>",
"[SCRUB] <teeth>",
"[PUTBACK] <toothbrush> <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <toothbrush>",
"[RINSE] <teeth>",
"[SWITCHOFF] <faucet>",
"[GRAB] <toothbrush>",
"[PUTOBJBACK] <toothbrush>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'food_bread', 'walllamp', 'bathroom', 'cpuscreen', 'kitchen_cabinet', 'floor', 'tea_bag', 'toaster', 'mat', 'stereo', 'balanceball', 'dish_soap', 'towel', 'wall', 'oven', 'bed', 'light_bulb', 'novel', 'coffe_maker', 'check', 'coin', 'food_donut', 'tray', 'doorjamb', 'towel_rack', 'sink', 'dishwasher', 'vase', 'clothes_shirt']
Task:Wash dishes with dishwasher
response:
{
"thoughts": I walk to the kitchen. I open the dishwasher. I open the kitchen cabinet. I reach inside the cabinet and grab the box of dish soap. I add some soap to the open dishwasher. I put the box of dish soap back in the kitchen cabinet. I close the kitchen cabinet and then I close the dishwasher. I turn the dishwasher on and wait.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[GRAB] <dish_soap>', '[PUTIN] <dish_soap> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'candle', 'wall', 'nightstand', 'powersocket', 'television', 'doorjamb', 'mouse', 'cupboard', 'sink', 'light', 'colander']
Task:Work
response:
| {
"thoughts": "Sit at my computer desk, Turn on Computer. Get online. Work.",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>"
]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.