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:['microwave', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'phone', 'bookshelf', 'table_cloth', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'cup', 'photoframe', 'check', 'television', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'door', 'sink', 'light', 'tooth_paste']
Task:Pet dog
response:
{
"thoughts": Pet my dog in hall,
"actions": ['[WALK] <home_office>', '[WALK] <dog>', '[TURNTO] <dog>', '[LOOKAT] <dog>', '[TOUCH] <dog>']
}
|
Scene_Objects:['glue', 'filing_cabinet', 'scissors', 'microwave', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'floor', 'ceiling', 'desk', 'bookshelf', 'purse', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'nightstand', 'child', 'cup', 'television', 'curtain', 'centerpiece', 'food_steak', 'hairdryer', 'table', 'vase']
Task:Watch TV
response:
| {
"thoughts": "Turn on tv. Sit with kids.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[SWITCHON] <television>",
"[WALK] <couch>",
"[FIND] <child>",
"[GREET] <child>",
"[FIND] <child>",
"[GREET] <child>",
"[SIT] <couch>",
"[TURNTO] <television>",
"[WATCH] <television>",
"[TURNTO] <television>",
"[WATCH] <television>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'tablelamp', 'juice', 'microwave', 'toilet', 'chair', 'freezer', 'ground_coffee', 'bathroom', 'knife', 'ceiling', 'bedroom', 'clothes_jacket', 'bookmark', 'toaster', 'faucet', 'iron', 'couch', 'food_peanut_butter', 'dining_room', 'oven', 'cup', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'home_office']
Task:Pet cat
response:
{
"thoughts": find a cat, touch it gently,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['sheets', 'pot', 'tablelamp', 'crayon', 'tea', 'mop', 'ground_coffee', 'detergent', 'drawing', 'floor', 'phone', 'ceilinglamp', 'laptop', 'shower', 'iron', 'window', 'oil', 'couch', 'pillow', 'wall', 'oven', 'cup', 'coffe_maker', 'toilet_paper', 'television', 'door', 'sink', 'table', 'scrabble', 'dirt']
Task:Read book
response:
| {
"thoughts": "Bring book, lie on the sofa, read book",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[GRAB] <novel>",
"[WALK] <couch>",
"[LIE] <couch>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'filing_cabinet', 'microwave', 'freezer', 'detergent', 'drawing', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'ceilinglamp', 'iron', 'faucet', 'window', 'homework', 'bowl', 'wall', 'wall_clock', 'bench', 'shelf', 'newspaper', 'mouthwash', 'food_donut', 'doorjamb', 'coffee_pot', 'door', 'sink', 'bathroom_cabinet', 'light', 'board_game']
Task:Turn light off
response:
{
"thoughts": Put the light switch into the down, or off, position.,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHOFF] <light>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'photoframe', 'mouthwash', 'television', 'doorjamb', 'mouse', 'chessboard', 'dresser', 'cupboard', 'door', 'light', 'table']
Task:Re arrange office
response:
| {
"thoughts": "Walk in.Turn on light.Move furniture. Change the room",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <desk>",
"[PUSH] <desk>",
"[WALK] <chair>",
"[PUSH] <chair>",
"[WALK] <couch>",
"[PUSH] <couch>",
"[WALK] <filing_cabinet>",
"[PUSH] <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', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'trashcan', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'homework', 'pillow', 'wall', 'pasta', 'powersocket', 'photoframe', 'oven_mitts', 'doorjamb', 'kitchen_counter', 'comb', 'door', 'bathtub', 'light', 'dishwasher']
Task:Go to toilet
response:
{
"thoughts": I walk to bathroom, I open the door of the bathroom, and sit on the toilet.,
"actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[SIT] <toilet>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'toilet', 'walllamp', 'ceilingfan', 'knifeblock', 'drawing', 'floor', 'folder', 'bedroom', 'bookshelf', 'table_cloth', 'toaster', 'window', 'wall', 'pasta', 'oven', 'nightstand', 'cup', 'novel', 'coffe_maker', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'hair', 'door', 'bathroom_cabinet', 'dishwasher']
Task:Take dishes out of dishwasher
response:
| {
"thoughts": "Take clean dishes out of the dishwasher and put away",
"actions": [
"[WALK] <dining_room>",
"[WALK] <dishwasher>",
"[OPEN] <dishwasher>",
"[CLOSE] <dishwasher>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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:['filing_cabinet', 'scissors', 'blender', 'food_salt', 'crayon', 'chair', 'band-aids', 'ceilingfan', 'needle', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'brush', 'ceilinglamp', 'shower', 'dining_room', 'wall', 'oven', 'powersocket', 'coffe_maker', 'curtain', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'maindoor', 'light']
Task:Dust
response:
| {
"thoughts": "Using soft brush, carefully dust both Indonesian wedding doll statues.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <brush>",
"[GRAB] <brush>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'desk', 'bedroom', 'stovefan', 'ceilinglamp', 'plate', 'mat', 'couch', 'wall', 'oven', 'food_food', 'tray', 'food_onion', 'curtain', 'diary', 'kitchen_counter', 'dishrack', 'sauce_pan', 'cupboard', 'spoon', 'home_office']
Task:Cook some food
response:
{
"thoughts": I pull a sauce pan from the cupboard. I turn the stove on. I take my ingredients from the pantry and fridge. I put the ingredients in the pan and I mix them with a spoon. I cook until the food is finished and transfer my food to a plate.,
"actions": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <spoon>', '[GRAB] <spoon>', '[FIND] <sauce_pan>', '[PUTBACK] <spoon> <sauce_pan>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <plate>', '[PUTBACK] <pot> <plate>']
}
|
Scene_Objects:['glue', 'microwave', 'dog', 'band-aids', 'jelly', 'walllamp', 'bathroom', 'ceilingfan', 'food_butter', 'bathroom_counter', 'video_game_console', 'tea_bag', 'keyboard', 'stovefan', 'mat', 'faucet', 'balanceball', 'couch', 'clothes_hat', 'form', 'nightstand', 'bench', 'oven', 'video_game_controller', 'tray', 'pencil', 'napkin', 'home_office', 'soap', 'dirt']
Task:Playing video game
response:
| {
"thoughts": "Playing video games on various video game systems such as wii u and xbox",
"actions": [
"[WALK] <home_office>",
"[WALK] <video_game_console>",
"[FIND] <video_game_console>",
"[SWITCHON] <video_game_console>",
"[FIND] <video_game_controller>",
"[GRAB] <video_game_controller>",
"[PUTOBJBACK] <video_game_controller>",
"[SWITCHOFF] <video_game_console>",
"[FIND] <video_game_console>",
"[SWITCHON] <video_game_console>",
"[FIND] <video_game_controller>",
"[GRAB] <video_game_controller>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'freezer', 'walllamp', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'toaster', 'shower', 'faucet', 'window', 'couch', 'wall', 'powersocket', 'bed', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub', 'light', 'laser_pointer']
Task:Take shower
response:
{
"thoughts": walk to bathroom , find shower , take a shower,
"actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>']
}
|
Scene_Objects:['tablelamp', 'cloth_napkin', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'toilet_paper', 'coffee_filter', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'light', 'dishwasher', 'table']
Task:Clean
response:
| {
"thoughts": "Use a cloth to wipe away any marks on the computer screen.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <cloth_napkin>",
"[GRAB] <cloth_napkin>",
"[WIPE] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'knife', 'drawing', 'wallshelf', 'orchid', 'hanger', 'cpuscreen', 'floor', 'character', 'keyboard', 'purse', 'homework', 'mousepad', 'wall', 'pasta', 'bench', 'keys', 'television', 'wooden_spoon', 'towel_rack', 'kettle', 'kitchen_counter', 'hair', 'conditioner', 'home_office', 'table']
Task:Hang up car keys
response:
{
"thoughts": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,
"actions": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'tablelamp', 'blender', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'mat', 'balanceball', 'clothes_socks', 'dustpan', 'wall', 'powersocket', 'food_cheese', 'after_shave', 'doorjamb', 'towel_rack', 'dresser', 'door', 'bathroom_cabinet', 'light', 'home_office']
Task:Turn on light
response:
| {
"thoughts": "Hit light switch",
"actions": [
"[WALK] <bedroom>",
"[WALK] <light>",
"[SWITCHON] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['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>']
}
|
Scene_Objects:['glue', 'filing_cabinet', 'chair', 'bathroom', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'cup', 'bed', 'novel', 'television', 'curtain', 'after_shave', 'doorjamb', 'door', 'light']
Task:Turn off light
response:
| {
"thoughts": "Hit the switch.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <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:['filing_cabinet', 'toothbrush', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'folder', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'mat', 'tvstand', 'towel', 'wall', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'coffee_filter', 'food_rice', 'after_shave', 'doorjamb', 'cards', 'door', 'napkin', 'light', 'vase']
Task:Turn on light
response:
{
"thoughts": Walk to the bedroom and use the button on the wall, next to the door to turn on the lights.,
"actions": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>']
}
|
Scene_Objects:['sponge', 'filing_cabinet', 'scissors', 'food_ice_cream', 'microwave', 'freezer', 'ceilingfan', 'character', 'bookshelf', 'toaster', 'ceilinglamp', 'deck_of_cards', 'mat', 'tvstand', 'window', 'faucet', 'mousepad', 'oil', 'food_jam', 'wall', 'nightstand', 'newspaper', 'television', 'ice', 'centerpiece', 'cupboard', 'sink', 'napkin', 'home_office', 'dishwasher']
Task:Get dressed
response:
| {
"thoughts": "I get dressed in my bedroom in the mornings.",
"actions": [
"[WALK] <bedroom>",
"[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:['food_bread', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'needle', 'floor', 'phone', 'mail', 'mat', 'plate', 'faucet', 'stereo', 'couch', 'dustpan', 'dining_room', 'wall', 'bench', 'oven', 'toy', 'cup', 'newspaper', 'standingmirror', 'food_food', 'razor', 'console', 'towel_rack', 'bathtub', 'table']
Task:Set up table
response:
{
"thoughts": Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.,
"actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <plate> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>', '[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <food_food> <table>']
}
|
Scene_Objects:['pot', 'juice', 'dog', 'freezer', 'walllamp', 'ground_coffee', 'knifeblock', 'floor', 'ceiling', 'tea_bag', 'envelope', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'couch', 'food_kiwi', 'wall', 'bed', 'newspaper', 'check', 'coffe_maker', 'food_food', 'curtain', 'kitchen_counter', 'cupboard', 'pajamas', 'food_snack', 'sink', 'coffee']
Task:Have snack
response:
| {
"thoughts": "Pour soda into a glass. Get pretzels out of bag. Eat and drink",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cup>",
"[FIND] <cup>",
"[GRAB] <cup>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <juice>",
"[GRAB] <juice>",
"[POUR] <juice> <cup>",
"[PUTIN] <juice> <freezer>",
"[CLOSE] <freezer>",
"[WALK] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <food_snack>",
"[GRAB] <food_snack>",
"[CLOSE] <cupboard>",
"[DRINK] <cup>",
"[EAT] <food_snack>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'toilet', 'walllamp', 'nail_polish', 'dough', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'cards', 'dishrack', 'door', 'light']
Task:Change TV channel
response:
{
"thoughts": first i will go to living room and then take the remote and swtitch on television after that il change the channel,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['food_pizza', 'blender', 'chair', 'food_carrot', 'drawing', 'hanger', 'floor', 'phone', 'keyboard', 'purse', 'button', 'clothes_jacket', 'toaster', 'faucet', 'candle', 'form', 'broom', 'wall', 'bench', 'powersocket', 'doorjamb', 'kettle', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'door', 'hairdryer', 'table', 'light']
Task:Clean
response:
| {
"thoughts": "Walk in.Wipe off table.Pull out chairs.Wipe out chairs.Sweep floor.Put back chairs.Clean windows.Polish silverware.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <table>",
"[FIND] <chair>",
"[PULL] <chair>",
"[WIPE] <chair>",
"[PUSH] <chair>",
"[FIND] <chair>",
"[PULL] <chair>",
"[WIPE] <chair>",
"[PUSH] <chair>",
"[WIPE] <table>",
"[PUTOBJBACK] <rag>",
"[FIND] <broom>",
"[GRAB] <broom>",
"[PUTOBJBACK] <broom>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'toilet', 'dog', 'freezer', 'walllamp', 'bathroom', 'food_carrot', 'drawing', 'hanger', 'phone', 'ceiling', 'desk', 'computer', 'toaster', 'mat', 'mousepad', 'closetdrawer', 'food_peanut_butter', 'towel', 'cup', 'food_cheese', 'keys', 'tray', 'after_shave', 'towel_rack', 'mouse', 'cupboard', 'sink', 'coffee']
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:['juice', 'bathroom', 'detergent', 'nail_polish', 'trashcan', 'food_butter', 'orchid', 'hanger', 'longboard', 'floor', 'bathroom_counter', 'remote_control', 'envelope', 'computer', 'window', 'electric_shaver', 'wall', 'cutting_board', 'bed', 'television', 'tray', 'curtain', 'after_shave', 'lighter', 'mouse', 'cupboard', 'clothes_dress', 'light', 'clothes_skirt', 'board_game']
Task:Watch TV
response:
| {
"thoughts": "Watching tv with a remote is always fun; lay back, relax and enjoy;",
"actions": [
"[WALK] <bedroom>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[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:['bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'computer', 'tvstand', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'cup', 'television', 'doorjamb', 'mouse', 'shoes', 'door', 'sink', 'napkin', 'clothes_scarf', 'table', 'light', 'dishwasher', 'colander']
Task:Relax on sofa
response:
{
"thoughts": walk to living room ,find sofa ,sit on sofa,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['dog', 'freezer', 'bathroom', 'detergent', 'shampoo', 'desk', 'stamp', 'food_bacon', 'brush', 'ceilinglamp', 'oil', 'soap', 'food_orange', 'towel', 'nightstand', 'video_game_controller', 'razor', 'television', 'wine', 'food_onion', 'mouse', 'shoes', 'hair', 'door', 'sink', 'home_office', 'light', 'vase', 'colander', 'teeth']
Task:Open door
response:
| {
"thoughts": "I walk up to the door. I use my hand to turn the door knob to the left. I pull the door open with the same hand I used to turn the door knob",
"actions": [
"[RUN] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'microwave', 'toilet', 'walllamp', 'ceilingfan', 'knifeblock', 'drawing', 'floor', 'folder', 'bedroom', 'bookshelf', 'table_cloth', 'toaster', 'window', 'wall', 'pasta', 'oven', 'nightstand', 'cup', 'novel', 'coffe_maker', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'hair', 'door', 'bathroom_cabinet', 'dishwasher']
Task:Take dishes out of dishwasher
response:
{
"thoughts": Take clean dishes out of the dishwasher and put away,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>']
}
|
Scene_Objects:['glue', 'trashcan', 'orchid', 'knifeblock', 'floor', 'tea_bag', 'keyboard', 'computer', 'stovefan', 'tvstand', 'stereo', 'window', 'dustpan', 'candle', 'food_jam', 'wall', 'pasta', 'bed', 'photoframe', 'coffe_maker', 'television', 'tray', 'curtain', 'wooden_spoon', 'towel_rack', 'pencil', 'chessboard', 'cupboard', 'maindoor', 'light']
Task:Listen to music
response:
| {
"thoughts": "Put iPhone into speaker holder, open up the Pandora app, listen to music.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <phone>",
"[FIND] <phone>",
"[GRAB] <phone>",
"[WALK] <stereo>",
"[PLUGIN] <phone>",
"[SWITCHON] <stereo>",
"[FIND] <bed>",
"[SIT] <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:['spectacles', 'sheets', 'drawing', 'cpuscreen', 'ceiling', 'desk', 'bookmark', 'mat', 'plate', 'stereo', 'deck_of_cards', 'mousepad', 'couch', 'clothes_hat', 'clothes_pants', 'bench', 'clothes_gloves', 'video_game_controller', 'curtain', 'towel_rack', 'cd', 'dishrack', 'chessboard', 'pajamas', 'laundry_detergent', 'maindoor', 'door', 'sink', 'bathroom_cabinet', 'clothes_shirt']
Task:Listen to music
response:
{
"thoughts": Find the radio; switch on the radio and listen to music.,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'wine', 'doorjamb', 'mouse', 'dresser', 'napkin', 'bathroom_cabinet', 'light']
Task:Clean
response:
| {
"thoughts": "Wipe down computer desk and monitor",
"actions": [
"[WALK] <home_office>",
"[WALK] <rag>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <desk>",
"[FIND] <computer>",
"[WIPE] <computer>",
"[WIPE] <desk>",
"[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', 'dry_pasta', 'ceilingfan', 'trashcan', 'drawing', 'longboard', 'floor', 'ceiling', 'bedroom', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'shower', 'deck_of_cards', 'couch', 'food_kiwi', 'wall', 'tape', 'basket_for_clothes', 'keys', 'coffe_maker', 'toilet_paper', 'television', 'curtain', 'cd', 'controller', 'table']
Task:Watch TV
response:
{
"thoughts": Sit on the couch. Get comfortable. Switch on the television. Stare at the television.,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['pot', 'scissors', 'chair', 'drawing', 'needle', 'hanger', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'laptop', 'iron', 'mat', 'deck_of_cards', 'mousepad', 'oil', 'wall', 'basket_for_clothes', 'food_donut', 'food_rice', 'tray', 'curtain', 'doorjamb', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'clothes_scarf', 'light']
Task:Put on coat
response:
| {
"thoughts": "I remove my scarf from a coat peg in the entrance hall. I wrap the scarf around my neck",
"actions": [
"[WALK] <home_office>",
"[WALK] <hanger>",
"[TURNTO] <hanger>",
"[LOOKAT] <hanger>",
"[FIND] <clothes_scarf>",
"[GRAB] <clothes_scarf>",
"[PUTON] <clothes_scarf>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'tablelamp', 'mop', 'chair', 'detergent', 'cat', 'phone', 'stamp', 'keyboard', 'stovefan', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'deck_of_cards', 'toaster', 'mousepad', 'closetdrawer', 'dining_room', 'food_kiwi', 'wall', 'check', 'coffe_maker', 'curtain', 'rag', 'mouse', 'comb', 'bathroom_cabinet', 'dishwasher', 'soap']
Task:Pet cat
response:
{
"thoughts": I go looking for the cat in the living room where he usually sleeps. Once I find the cat I just pet him for a few minutes.,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['sheets', 'pot', 'filing_cabinet', 'tea', 'chair', 'freezer', 'ground_coffee', 'drawing', 'orchid', 'floor', 'purse', 'faucet', 'balanceball', 'food_noodles', 'food_peanut_butter', 'wall', 'powersocket', 'toy', 'bed', 'food_food', 'check', 'food_donut', 'doorjamb', 'pencil', 'laundry_detergent', 'door', 'bag', 'napkin', 'light', 'table']
Task:Pick up toys
response:
| {
"thoughts": "Grab toys off floor. Put it in a container.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <toy>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'toothbrush', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'food_noodles', 'form', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'keys', 'toothbrush_holder', 'rag', 'doorjamb', 'sink', 'bathroom_cabinet', 'instrument_guitar', 'dishwasher', 'tooth_paste', 'teeth']
Task:Wash teeth
response:
{
"thoughts": I walk in to the bathroom. I turn on the faucet. I find the toothbrush and toothpaste. I grab the toothbrush and toothpaste. I rinse off the toothbrush. I add toothpaste to the toothbrush. I put back the toothpaste. I wash my teeth with the toothbrush. I rinse off the toothbrush. I put the toothbrush back. I rinse my mouth out. I turn the faucet off.,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[RINSE] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>', '[PUTOBJBACK] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>', '[RINSE] <toothbrush>', '[PUTOBJBACK] <toothbrush>', '[RINSE] <teeth>', '[SWITCHOFF] <faucet>']
}
|
Scene_Objects:['glue', 'sponge', 'scissors', 'chair', 'dog', 'drawing', 'bills', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'ceilinglamp', 'shoe-shine_kit', 'window', 'foundation', 'couch', 'wall', 'bench', 'basket_for_clothes', 'bed', 'novel', 'television', 'kitchen_counter', 'dresser', 'cupboard', 'bathroom_cabinet', 'light', 'table']
Task:Read book
response:
| {
"thoughts": "Grab book. Read it.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[CLOSE] <dresser>",
"[FIND] <couch>",
"[SIT] <couch>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'beer', 'cat', 'trashcan', 'milk', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'character', 'desk', 'bookshelf', 'food_cake', 'computer', 'brush', 'ceilinglamp', 'plate', 'deck_of_cards', 'wall', 'powersocket', 'toy', 'newspaper', 'bed', 'coffe_maker', 'curtain', 'pencil', 'hair', 'door', 'light']
Task:Give milk to cat
response:
{
"thoughts": Grab milk and pour it into the plate so that the cat can drink,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[POINTAT] <cat>', '[PULL] <cat>', '[FIND] <milk>', '[GRAB] <milk>', '[FIND] <plate>', '[POUR] <milk> <plate>', '[TOUCH] <cat>', '[SCRUB] <cat>']
}
|
Scene_Objects:['glue', 'pot', 'food_ice_cream', 'crayon', 'cat', 'woman', 'knife', 'longboard', 'ceiling', 'tea_bag', 'keyboard', 'bookshelf', 'envelope', 'clothes_jacket', 'bookmark', 'ceilinglamp', 'homework', 'foundation', 'food_jam', 'coffe_maker', 'check', 'mouse', 'controller', 'laundry_detergent', 'maindoor', 'clothes_scarf', 'bathroom_cabinet', 'vase', 'clothes_shirt', 'scrabble']
Task:Greet guests
response:
| {
"thoughts": "Greet people into my home",
"actions": [
"[WALK] <home_office>",
"[WALK] <woman>",
"[FIND] <woman>",
"[GREET] <woman>",
"[FIND] <woman>",
"[GREET] <woman>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'glue', 'measuring_cup', 'dog', 'walllamp', 'bathroom', 'floor', 'phone', 'bedroom', 'mat', 'stereo', 'faucet', 'window', 'closetdrawer', 'dining_room', 'food_cheese', 'standingmirror', 'bed', 'check', 'television', 'coffee_filter', 'food_rice', 'ice', 'curtain', 'doorjamb', 'pencil', 'conditioner', 'bathtub', 'napkin', 'vase']
Task:Listen to music
response:
{
"thoughts": Listen to music,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['pot', 'detergent', 'ceilingfan', 'trashcan', 'drawing', 'knife', 'floor', 'ceiling', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'picture', 'couch', 'wall', 'pasta', 'novel', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'dresser', 'maindoor', 'table', 'light', 'vase', 'tooth_paste']
Task:Watch TV
response:
| {
"thoughts": "I sit on my couch and watch TV in my living room",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[TOUCH] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[TOUCH] <television>",
"[TURNTO] <television>",
"[LOOKAT] <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:['food_salt', 'toilet', 'detergent', 'food_butter', 'dough', 'food_carrot', 'drawing', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'keyboard', 'computer', 'clothes_jacket', 'tvstand', 'faucet', 'shower', 'electric_shaver', 'mousepad', 'towel', 'wall', 'oven', 'cup', 'photoframe', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'hands_both']
Task:Wash hands
response:
{
"thoughts": Wash hands with soap and hot water,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'detergent', 'drawing', 'floor', 'ceiling', 'stamp', 'bedroom', 'thread', 'computer', 'toaster', 'faucet', 'mousepad', 'food_peanut_butter', 'wall', 'powersocket', 'toy', 'cup', 'newspaper', 'doorjamb', 'chessboard', 'comb', 'door', 'sink', 'bag', 'light', 'board_game']
Task:Clean
response:
| {
"thoughts": "Enter inside kid's room, begin picking up toys from the floor and putting them in a toy box, leave once once.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <toy>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[FIND] <toy>",
"[GRAB] <toy>",
"[WALK] <filing_cabinet>",
"[PUTBACK] <toy> <filing_cabinet>",
"[CLOSE] <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'microwave', 'freezer', 'bathroom', 'cpuscreen', 'desk', 'tea_bag', 'alcohol', 'tvstand', 'oven', 'tape', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'toilet_paper', 'television', 'coffee_filter', 'wooden_spoon', 'mouse', 'cd', 'controller', 'maindoor', 'sink', 'home_office', 'light', 'dishwasher', 'soap', 'dirt', 'shoe_rack']
Task:Listen to music
response:
{
"thoughts": Walk into living room. Turn on radio.,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['filing_cabinet', 'food_bread', 'tablelamp', 'food_salt', 'dog', 'walllamp', 'trashcan', 'dough', 'bills', 'knifeblock', 'floor', 'computer', 'bookmark', 'window', 'couch', 'food_jam', 'pillow', 'wall', 'nightstand', 'oven', 'cutting_board', 'bed', 'photoframe', 'novel', 'food_food', 'television', 'curtain', 'diary', 'mouse', 'table']
Task:Breakfast
response:
| {
"thoughts": "I have breakfast in bed, watching tv.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[GRAB] <food_food>",
"[WALK] <bedroom>",
"[WALK] <television>",
"[SWITCHON] <television>",
"[WALK] <bed>",
"[LIE] <bed>",
"[TURNTO] <television>",
"[WATCH] <television>",
"[EAT] <food_food>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'filing_cabinet', 'food_salt', 'walllamp', 'bathroom', 'trashcan', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'tvstand', 'shower', 'faucet', 'towel', 'wall', 'cup', 'keys', 'food_food', 'television', 'water', 'curtain', 'lighter', 'kitchen_counter', 'shoes', 'door', 'table', 'light', 'soap', 'teeth']
Task:Take shower
response:
{
"thoughts": go to a bathroom, open the shower, let water wash your body,
"actions": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']
}
|
Scene_Objects:['measuring_cup', 'microwave', 'toilet', 'jelly', 'walllamp', 'trashcan', 'knifeblock', 'knife', 'desk', 'keyboard', 'computer', 'button', 'brush', 'window', 'mousepad', 'couch', 'bench', 'cutting_board', 'novel', 'check', 'coffe_maker', 'television', 'toothbrush_holder', 'food_rice', 'curtain', 'headset', 'dresser', 'home_office', 'table', 'dishwasher']
Task:Lock door
response:
| {
"thoughts": "Turn the lock.",
"actions": [
"[WALK] <bedroom>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'juice', 'cd_player', 'chair', 'freezer', 'detergent', 'trashcan', 'knife', 'knifeblock', 'drawing', 'floor', 'ceiling', 'bedroom', 'keyboard', 'remote_control', 'computer', 'button', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'nightstand', 'after_shave', 'door', 'bathtub', 'home_office', 'table', 'clothes_skirt', 'instrument_guitar', 'light']
Task:Listen to music
response:
{
"thoughts": Walk to CD player and turn it on then go and sit in a chair and turn the remote control on and then listen to some music.,
"actions": ['[WALK] <cd_player>', '[SWITCHON] <cd_player>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']
}
|
Scene_Objects:['glue', 'tablelamp', 'mop', 'toilet', 'chair', 'trashcan', 'knifeblock', 'hanger', 'longboard', 'floor', 'phone', 'keyboard', 'balanceball', 'foundation', 'pillow', 'wall', 'powersocket', 'box', 'photoframe', 'bed', 'check', 'rag', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'maindoor', 'light', 'colander']
Task:Sit
response:
| {
"thoughts": "We sit at the dining room table",
"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', 'walllamp', 'trashcan', 'drawing', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'food_food', 'coffe_maker', 'television', 'tray', 'curtain', 'mouse', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'sink', 'table']
Task:Relax on sofa
response:
{
"thoughts": I walk to the living room. I sit in the sofa and I relax.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'remote_control', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'couch', 'wall', 'powersocket', 'oven', 'coffe_maker', 'television', 'coffee_filter', 'food_rice', 'tray', 'curtain', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'dirt']
Task:Watch TV
response:
| {
"thoughts": "I like to set on my sofa.Turn on the tv. And watch Perry Mason. Monday's through Friday's.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'television', 'coin', 'doorjamb', 'mouse', 'chessboard', 'bathtub', 'table']
Task:Write school paper
response:
{
"thoughts": Writing and drafting a paper for class work,
"actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']
}
|
Scene_Objects:['tablelamp', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'bathroom_counter', 'bookshelf', 'keyboard', 'computer', 'button', 'ceilinglamp', 'tvstand', 'faucet', 'picture', 'mousepad', 'pillow', 'wall', 'basket_for_clothes', 'photoframe', 'curtain', 'shoes', 'cd', 'vacuum_cleaner', 'dresser', 'cupboard', 'clothes_dress', 'home_office', 'table', 'shoe_rack']
Task:Take off shoes
response:
| {
"thoughts": "Bend down to reach your feet. Shift balance to one leg. Grab the shoe of the foot of the other leg, it is best to use one hand to grip near the front, and one towards the heel. Pull the shoe down toward the ground while also pushing on the heel away from the body. Repeat with other shoe. Place shoes in a designated area.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <shoes>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PULL] <shoes>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[PUTIN] <shoes> <dresser>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[PULL] <shoes>",
"[WALK] <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:['measuring_cup', 'chair', 'walllamp', 'bathroom', 'milk', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'envelope', 'computer', 'mat', 'ceilinglamp', 'stereo', 'mousepad', 'wall', 'toothbrush_holder', 'food_rice', 'ice', 'after_shave', 'mouse', 'headset', 'dresser', 'door', 'home_office', 'table', 'board_game']
Task:Work
response:
{
"thoughts": Walk to home office, walk to desk, sit in chair, turn on computer, look at computer, click mouse and type on keyboard.,
"actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[TOUCH] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}
|
Scene_Objects:['sheets', 'dry_pasta', 'ceilingfan', 'trashcan', 'drawing', 'longboard', 'floor', 'ceiling', 'bedroom', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'laptop', 'window', 'shower', 'deck_of_cards', 'couch', 'food_kiwi', 'wall', 'tape', 'basket_for_clothes', 'keys', 'coffe_maker', 'toilet_paper', 'television', 'curtain', 'cd', 'controller', 'table']
Task:Watch TV
response:
| {
"thoughts": "Sit on the couch. Get comfortable. Switch on the television. Stare at the television.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <couch>",
"[SIT] <couch>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'chair', 'cat', 'hanger', 'bathroom_counter', 'floor', 'bookshelf', 'keyboard', 'ceilinglamp', 'shower', 'foundation', 'couch', 'food_orange', 'powersocket', 'bench', 'clothes_gloves', 'toilet_paper', 'razor', 'food_donut', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'dresser', 'pajamas', 'laundry_detergent', 'clothes_scarf', 'home_office', 'laser_pointer', 'creditcard']
Task:Drink
response:
{
"thoughts": Pour water into a glass and drink from the glass.,
"actions": ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}
|
Scene_Objects:['tablelamp', 'beer', 'freezer', 'ground_coffee', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'bedroom', 'stamp', 'computer', 'ceilinglamp', 'balanceball', 'oil', 'couch', 'broom', 'wall', 'oven', 'box', 'food_cheese', 'television', 'doorjamb', 'towel_rack', 'kitchen_counter', 'sink', 'vase', 'shoe_rack']
Task:Eat cheese
response:
| {
"thoughts": "Open fridge. Get cheese. Eat it.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_cheese>",
"[GRAB] <food_cheese>",
"[EAT] <food_cheese>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'food_salt', 'microwave', 'toilet', 'walllamp', 'drawing', 'needle', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'desk', 'computer', 'bookmark', 'stovefan', 'plate', 'tvstand', 'dish_soap', 'closetdrawer', 'dining_room', 'wall', 'wall_clock', 'oven', 'powersocket', 'curtain', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
"thoughts": Walk to the kitchen. Open the dishwasher. Grab plate and put it in the dishwasher. Grab dish soap and put it in the dishwasher. Switch on the dishwasher.,
"actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}
|
Scene_Objects:['filing_cabinet', 'blender', 'chair', 'jelly', 'food_carrot', 'cpuscreen', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'laptop', 'plate', 'mousepad', 'dining_room', 'wall', 'wine', 'after_shave', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'light']
Task:Work
response:
| {
"thoughts": "I walk in. Turn on the light. Set in my chair. Turn on lap top. And start to work.",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <laptop>",
"[GRAB] <laptop>",
"[SWITCHON] <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:['food_salt', 'trashcan', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'stovefan', 'tvstand', 'food_peanut_butter', 'nightstand', 'wall', 'oven', 'powersocket', 'coffe_maker', 'toothbrush_holder', 'after_shave', 'curtain', 'coffee_pot', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'bathtub', 'sink', 'home_office', 'dishwasher', 'tooth_paste']
Task:Brush teeth
response:
{
"thoughts": today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well,
"actions": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <toothbrush>']
}
|
Scene_Objects:['fork', 'tablelamp', 'food_ice_cream', 'walllamp', 'bathroom', 'ceilingfan', 'trashcan', 'woman', 'drawing', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'bedroom', 'man', 'ceilinglamp', 'window', 'couch', 'wall', 'bench', 'cup', 'newspaper', 'novel', 'check', 'television', 'towel_rack', 'clothes_dress', 'table', 'clothes_skirt', 'creditcard']
Task:Hang with friends
response:
| {
"thoughts": "Sit with friends. Talk",
"actions": [
"[WALK] <home_office>",
"[WALK] <man>",
"[FIND] <man>",
"[TURNTO] <man>",
"[LOOKAT] <man>",
"[GREET] <man>",
"[FIND] <woman>",
"[TURNTO] <woman>",
"[LOOKAT] <woman>",
"[GREET] <woman>",
"[WALK] <couch>",
"[SIT] <couch>",
"[TURNTO] <man>",
"[LOOKAT] <man>",
"[GREET] <man>",
"[TURNTO] <woman>",
"[LOOKAT] <woman>",
"[GREET] <woman>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'blender', 'food_salt', 'toilet', 'walllamp', 'bathroom', 'food_butter', 'drawing', 'hanger', 'shampoo', 'bedroom', 'purse', 'computer', 'stovefan', 'laptop', 'ceilinglamp', 'electric_shaver', 'window', 'homework', 'clothes_socks', 'wall_clock', 'shelf', 'basket_for_clothes', 'bed', 'coffe_maker', 'check', 'wooden_spoon', 'centerpiece', 'lighter', 'kettle']
Task:Browse internet
response:
{
"thoughts": The task is browse and surf on the internet regarding a particular topic,
"actions": ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>']
}
|
Scene_Objects:['filing_cabinet', 'beer', 'freezer', 'ground_coffee', 'nail_polish', 'bills', 'drawing', 'knifeblock', 'floor', 'folder', 'bedroom', 'tea_bag', 'mail', 'computer', 'towel', 'wall', 'powersocket', 'cutting_board', 'cup', 'keys', 'clothes_gloves', 'check', 'razor', 'tray', 'doorjamb', 'pencil', 'dresser', 'door', 'light', 'table']
Task:Put clothes away
response:
| {
"thoughts": "I take clean clothes and either place them in dresser drawers or hang them in a closet.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <filing_cabinet>",
"[OPEN] <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:['dry_pasta', 'filing_cabinet', 'freezer', 'walllamp', 'cpuscreen', 'wallshelf', 'ceiling', 'computer', 'shower', 'window', 'mousepad', 'couch', 'dining_room', 'wall_clock', 'oven', 'powersocket', 'bench', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'razor', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'home_office', 'light', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": "I walk to entrance hall" "I walk to bedroom" "I find basket of clothes" "I lift basket of clothes" "I walk to kitchen" "I find washing machine" "I open washing machine " "I put laundry in washing machine" "I add laundry detergent" " "I close washing machine lid" "I switch washing machine on",
"actions": ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>']
}
|
Scene_Objects:['filing_cabinet', 'food_bread', 'microwave', 'chair', 'band-aids', 'woman', 'needle', 'longboard', 'man', 'keyboard', 'envelope', 'toaster', 'mat', 'ceilinglamp', 'shower', 'faucet', 'stereo', 'nightstand', 'box', 'light_bulb', 'coffe_maker', 'curtain', 'towel_rack', 'shoes', 'dresser', 'hairbrush', 'door', 'vase', 'instrument_violin', 'creditcard']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'ground_coffee', 'walllamp', 'food_butter', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'thread', 'stovefan', 'toaster', 'tvstand', 'faucet', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'coffe_maker', 'food_food', 'oven_mitts', 'coffee_filter', 'water', 'wine', 'wooden_spoon', 'controller', 'bathroom_cabinet', 'home_office', 'dishwasher']
Task:Make coffee
response:
{
"thoughts": Walk to kitchen, open coffee maker, find coffee filter, grab coffee filter, put coffee filter in coffee maker, find ground coffee, put ground coffee in coffee maker, pour water in coffee maker, close coffee maker and switch on coffee maker.,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']
}
|
Scene_Objects:['fork', 'toilet', 'trashcan', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'thread', 'computer', 'piano_bench', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'foundation', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'oven', 'bed', 'novel', 'check', 'television', 'curtain', 'towel_rack', 'dresser', 'vase']
Task:Read book
response:
| {
"thoughts": "Put child in bed, sit down,read book.",
"actions": [
"[WALK] <bedroom>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[FIND] <bed>",
"[SIT] <bed>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'food_pizza', 'filing_cabinet', 'scissors', 'chair', 'ceilingfan', 'dough', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'coffee_table', 'television', 'coin', 'wooden_spoon', 'curtain', 'maindoor', 'table']
Task:Watch TV
response:
{
"thoughts": I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>']
}
|
Scene_Objects:['sheets', 'fork', 'filing_cabinet', 'toilet', 'detergent', 'food_butter', 'orchid', 'needle', 'bills', 'stereo', 'window', 'dining_room', 'bench', 'oven', 'bed', 'novel', 'check', 'coffee_filter', 'tray', 'wooden_spoon', 'centerpiece', 'headset', 'conditioner', 'food_steak', 'napkin', 'home_office', 'soap', 'scrabble', 'dirt', 'coffee']
Task:File documents
response:
| {
"thoughts": "I file all of my paperwork (including bills, receipts, documents, device instructions, etc.) in my black paperwork case that has many different files in order to organize. I place each piece of paper in its' corresponding subject (as indicated by printed words on each tab).",
"actions": [
"[WALK] <home_office>",
"[WALK] <bills>",
"[FIND] <bills>",
"[GRAB] <bills>",
"[WALK] <filing_cabinet>",
"[OPEN] <filing_cabinet>",
"[PUTIN] <bills> <filing_cabinet>",
"[FIND] <check>",
"[GRAB] <check>",
"[WALK] <filing_cabinet>",
"[PUTIN] <check> <filing_cabinet>",
"[FIND] <check>",
"[GRAB] <check>",
"[WALK] <filing_cabinet>",
"[PUTIN] <check> <filing_cabinet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'toilet', 'walllamp', 'drawing', 'wallshelf', 'floor', 'phone', 'character', 'bedroom', 'alcohol', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'foundation', 'food_noodles', 'wall', 'nightstand', 'bench', 'oven', 'food_food', 'television', 'curtain', 'rag', 'pencil', 'door', 'clothes_scarf', 'home_office', 'table']
Task:Play games
response:
{
"thoughts": I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours.,
"actions": ['[WALK] <home_office>', '[WALK] <board_game>', '[FIND] <board_game>', '[GRAB] <board_game>', '[WALK] <dining_room>', '[WALK] <table>', '[PUTBACK] <board_game> <table>']
}
|
Scene_Objects:['pot', 'juice', 'tea', 'chair', 'trashcan', 'drawing', 'bills', 'longboard', 'floor', 'man', 'tea_bag', 'food_bacon', 'ceilinglamp', 'laptop', 'shower', 'window', 'foundation', 'couch', 'pillow', 'wall', 'pasta', 'cutting_board', 'basket_for_clothes', 'bed', 'light_bulb', 'television', 'clothes_dress', 'bag', 'home_office', 'table']
Task:Have conversation with boyfriend
response:
| {
"thoughts": "Sit on sofa, talk",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[WALK] <couch>",
"[SIT] <couch>",
"[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:['filing_cabinet', 'chair', 'bathroom', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'purse', 'computer', 'shower', 'window', 'electric_shaver', 'mousepad', 'oil', 'couch', 'form', 'wall', 'food_food', 'television', 'rag', 'lighter', 'mouse', 'controller', 'sink']
Task:Pick up phone
response:
{
"thoughts": first when i hear the ringing sound i will run to my living room and picks up and i will say hello,
"actions": ['[RUN] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['tablelamp', 'chair', 'cat', 'ceilingfan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'oil', 'couch', 'wall', 'wall_clock', 'powersocket', 'oven', 'bench', 'newspaper', 'mouthwash', 'television', 'diary', 'towel_rack', 'mouse', 'dresser', 'hairbrush', 'hairdryer', 'soap']
Task:Check email
response:
| {
"thoughts": "Sit in teak deck chair, have wooden drawing board on lap, laptop on wooden drawing board, log in to my two email accounts, go through new emails and respond.",
"actions": [
"[WALK] <home_office>",
"[WALK] <laptop>",
"[FIND] <laptop>",
"[GRAB] <laptop>",
"[WALK] <chair>",
"[SIT] <chair>",
"[SWITCHON] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[TOUCH] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[TOUCH] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[TOUCH] <laptop>",
"[TURNTO] <laptop>",
"[LOOKAT] <laptop>",
"[TOUCH] <laptop>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'microwave', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'folder', 'desk', 'alcohol', 'stovefan', 'plate', 'mousepad', 'wall', 'oven', 'food_food', 'check', 'tray', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'sink', 'clothes_scarf', 'light', 'clothes_shirt', 'teeth']
Task:Pick up phone
response:
{
"thoughts": walk over and pick up the phone,
"actions": ['[WALK] <phone>', '[GRAB] <phone>']
}
|
Scene_Objects:['spectacles', 'tablelamp', 'juice', 'microwave', 'toilet', 'chair', 'walllamp', 'dough', 'drawing', 'cpuscreen', 'floor', 'folder', 'desk', 'bookshelf', 'keyboard', 'computer', 'mail', 'shower', 'picture', 'mousepad', 'wall', 'nightstand', 'bench', 'oven', 'photoframe', 'novel', 'check', 'food_food', 'centerpiece', 'mouse']
Task:Arrange folders
response:
| {
"thoughts": "Go through all my folders and re-arrange in alfabetaical order and put on computer desk",
"actions": [
"[WALK] <home_office>",
"[WALK] <desk>",
"[FIND] <folder>",
"[GRAB] <folder>",
"[OPEN] <desk>",
"[PUTBACK] <folder> <desk>",
"[FIND] <folder>",
"[GRAB] <folder>",
"[PUTBACK] <folder> <desk>",
"[FIND] <folder>",
"[GRAB] <folder>",
"[PUTBACK] <folder> <desk>",
"[FIND] <folder>",
"[GRAB] <folder>",
"[PUTBACK] <folder> <desk>",
"[FIND] <folder>",
"[GRAB] <folder>",
"[PUTBACK] <folder> <desk>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dog', 'walllamp', 'detergent', 'food_carrot', 'orchid', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'table_cloth', 'mat', 'faucet', 'shower', 'oil', 'clothes_socks', 'dustpan', 'wall', 'toy', 'bed', 'razor', 'water', 'coffee_pot', 'cupboard', 'hairdryer', 'sink', 'napkin', 'bathroom_cabinet', 'teeth']
Task:Wash teeth
response:
{
"thoughts": Wash the teeth,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[TURNTO] <water>', '[POINTAT] <water>', '[FIND] <teeth>', '[WASH] <teeth>', '[SWITCHOFF] <faucet>']
}
|
Scene_Objects:['tablelamp', 'blender', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'shampoo', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'coin', 'doorjamb', 'mouse', 'sink', 'light', 'soap']
Task:Write school paper
response:
| {
"thoughts": "Writing and drafting a paper for class work",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[SWITCHON] <computer>",
"[SWITCHOFF] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'walllamp', 'detergent', 'cat', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'remote_control', 'mail', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'couch', 'wall', 'bench', 'clothes_gloves', 'coffe_maker', 'television', 'curtain', 'coffee_pot', 'home_office', 'table', 'coffee']
Task:Change TV channel
response:
{
"thoughts": walk to living room, look at the television, switch on the television, grab the remote control, press the channel button in remote control, now the tv channel is changed,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[GRAB] <button>']
}
|
Scene_Objects:['sheets', 'toilet', 'chair', 'dog', 'trashcan', 'woman', 'milk', 'man', 'envelope', 'ceilinglamp', 'shower', 'window', 'pillow', 'dining_room', 'newspaper', 'clothes_gloves', 'coffe_maker', 'toilet_paper', 'toothbrush_holder', 'oven_mitts', 'tray', 'curtain', 'console', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'napkin', 'home_office', 'tooth_paste']
Task:Greet people
response:
| {
"thoughts": "Say HI to those that come in.",
"actions": [
"[WALK] <home_office>",
"[WALK] <woman>",
"[FIND] <woman>",
"[GREET] <woman>",
"[FIND] <woman>",
"[GREET] <woman>",
"[FIND] <man>",
"[GREET] <man>",
"[FIND] <man>",
"[GREET] <man>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'ceilingfan', 'drawing', 'cpuscreen', 'phone', 'desk', 'keyboard', 'mail', 'mat', 'window', 'towel', 'dining_room', 'wall', 'pasta', 'oven', 'cup', 'check', 'curtain', 'rag', 'doorjamb', 'cards', 'cupboard', 'conditioner', 'clothes_scarf', 'napkin', 'home_office', 'vase', 'soap', 'laser_pointer']
Task:Listen to music
response:
{
"thoughts": I go to my bedroom, and then I switch on the radio,
"actions": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['food_bread', 'filing_cabinet', 'chair', 'band-aids', 'orchid', 'hanger', 'floor', 'ceiling', 'phone', 'folder', 'character', 'ceilinglamp', 'shower', 'oil', 'clothes_hat', 'wall', 'cup', 'novel', 'check', 'ice', 'rag', 'doorjamb', 'kettle', 'console', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'dresser', 'cupboard', 'light']
Task:vacuum carpet
response:
| {
"thoughts": "I bring my vacuum cleaner into the living room. I plug it into the wall. I press the on switch on the vacuum cleaner. I push the vacuum cleaner back and forth over the length and width of the carpet until I have vacuumed the entire carpet. I turn the vacuum cleaner off. I take the vacuum cleaner back to the hall closet.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dresser>",
"[OPEN] <dresser>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PLUGIN] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[PULL] <vacuum_cleaner>",
"[PUSH] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>",
"[PLUGOUT] <vacuum_cleaner>",
"[WALK] <dresser>",
"[PUTIN] <vacuum_cleaner> <dresser>",
"[CLOSE] <dresser>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'filing_cabinet', 'toilet', 'food_butter', 'orchid', 'bathroom_counter', 'bedroom', 'tea_bag', 'bookshelf', 'stovefan', 'ceilinglamp', 'faucet', 'shower', 'window', 'food_noodles', 'couch', 'clothes_hat', 'pillow', 'bench', 'powersocket', 'basket_for_clothes', 'television', 'oven_mitts', 'kitchen_counter', 'shoes', 'pajamas', 'door', 'light', 'soap', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": Get dirty clothes out of basket for clothes in bedroom, carry dirty clothes to laundry room, place dirty clothes in washing machine, add laundry detergent to washing machine, turn washing machine on, set type of wash, start washing machine,
"actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[OPEN] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['fork', 'filing_cabinet', 'blender', 'walllamp', 'ceilingfan', 'dough', 'drawing', 'floor', 'ceiling', 'desk', 'stamp', 'remote_control', 'food_cake', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'couch', 'wall', 'oven', 'photoframe', 'novel', 'television', 'curtain', 'home_office', 'table', 'instrument_guitar']
Task:Watch TV
response:
| {
"thoughts": "Sit on the couch nd watch t.V",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[TURNTO] <television>",
"[LOOKAT] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'glue', 'tablelamp', 'mop', 'microwave', 'freezer', 'walllamp', 'needle', 'food_egg', 'floor', 'ceiling', 'tea_bag', 'keyboard', 'stovefan', 'stereo', 'form', 'dining_room', 'wall', 'oven', 'powersocket', 'cutting_board', 'toy', 'keys', 'food_food', 'coffe_maker', 'wine', 'tray', 'kitchen_counter', 'clothes_scarf', 'creditcard']
Task:Put groceries in Fridge
response:
{
"thoughts": Open the fridge, and put groceries in the fridge. Close the fridge.,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']
}
|
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'freezer', 'walllamp', 'food_butter', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'bedroom', 'alcohol', 'window', 'food_jam', 'dining_room', 'wall', 'bench', 'powersocket', 'newspaper', 'food_food', 'doorjamb', 'kettle', 'towel_rack', 'dresser', 'cupboard', 'door', 'table', 'light']
Task:Eat dinner
response:
| {
"thoughts": "In our dining room, my family eats dinner. Once the food has been prepared, we gather at the dining room table and prepare to eat.",
"actions": [
"[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>",
"[WALK] <chair>",
"[PULL] <chair>",
"[SIT] <chair>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>",
"[TURNTO] <food_food>",
"[LOOKAT] <food_food>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_bread', 'toilet', 'walllamp', 'bills', 'drawing', 'cpuscreen', 'bathroom_counter', 'ceiling', 'cleaning_solution', 'mop_bucket', 'table_cloth', 'faucet', 'shower', 'iron', 'clothes_socks', 'pillow', 'wall', 'food_food', 'mirror', 'wine', 'doorjamb', 'coffee_pot', 'paper_towel', 'cupboard', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'dishwasher', 'scrabble']
Task:Clean mirror
response:
{
"thoughts": First spray the mirrors with Windex or window type spray. Take paper towels and wipe until sparkly clean. If they have streaks, repeat the process.,
"actions": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[FIND] <cleaning_solution>', '[RINSE] <cleaning_solution>', '[WIPE] <mirror>']
}
|
Scene_Objects:['pot', 'detergent', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'laptop', 'shower', 'window', 'oil', 'clothes_socks', 'couch', 'food_orange', 'pillow', 'wall', 'novel', 'coffe_maker', 'television', 'food_rice', 'rag', 'doorjamb', 'cupboard', 'door', 'sink', 'napkin', 'table', 'light']
Task:Relax
response:
| {
"thoughts": "Lie down on the couch.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[LIE] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'toilet', 'chair', 'freezer', 'detergent', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'bedroom', 'piano_bench', 'ceilinglamp', 'mat', 'shower', 'faucet', 'oil', 'food_orange', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'check', 'doorjamb', 'vacuum_cleaner', 'door', 'table', 'light']
Task:Put groceries in Fridge
response:
{
"thoughts": Put the groceries on the table into the fridge,
"actions": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTBACK] <food_chicken> <freezer>', '[CLOSE] <freezer>', '[FIND] <food_carrot>', '[GRAB] <food_carrot>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_carrot> <freezer>', '[CLOSE] <freezer>']
}
|
Scene_Objects:['tablelamp', 'crayon', 'chair', 'freezer', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'ceilinglamp', 'balanceball', 'mousepad', 'pillow', 'wall', 'nightstand', 'bench', 'razor', 'coin', 'doorjamb', 'mouse', 'conditioner', 'light', 'dishwasher']
Task:Turn on computer
response:
| {
"thoughts": "Push power button.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[SWITCHON] <computer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'tablelamp', 'detergent', 'ceilingfan', 'hanger', 'bathroom_counter', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'food_cake', 'clothes_jacket', 'button', 'laptop', 'tvstand', 'mat', 'dustpan', 'food_food', 'after_shave', 'towel_rack', 'pencil', 'kitchen_counter', 'laundry_detergent', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'table', 'vase', 'washing_machine', 'coffee']
Task:Wash clothes
response:
{
"thoughts": "I walk to entrance hall" "I walk to bedroom" "I find basket of clothes" "I lift basket of clothes" "I walk to kitchen" "I find washing machine" "I open washing machine " "I put laundry in washing machine" "I add laundry detergent" " "I close washing machine lid" "I switch washing machine on",
"actions": ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[TURNTO] <washing_machine>']
}
|
Scene_Objects:['pot', 'chair', 'ceilingfan', 'trashcan', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bookshelf', 'table_cloth', 'mop_bucket', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'food_noodles', 'couch', 'wall', 'nightstand', 'food_food', 'television', 'curtain', 'cupboard', 'table', 'light', 'vase', 'dishwasher', 'dirt']
Task:Watch TV
response:
| {
"thoughts": "Sit on the couch or the chair or the floor and watch cable, movies, or netflix.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[FIND] <couch>",
"[SIT] <couch>",
"[TURNTO] <television>",
"[WATCH] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'bathroom', 'cat', 'milk', 'orchid', 'floor', 'dvd_player', 'desk', 'keyboard', 'purse', 'table_cloth', 'mat', 'shower', 'window', 'clothes_socks', 'couch', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'mouthwash', 'television', 'curtain', 'food_onion', 'doorjamb', 'kitchen_counter', 'bathtub', 'napkin', 'table']
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', 'chair', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'hanger', 'floor', 'ceiling', 'phone', 'ceilinglamp', 'tvstand', 'stereo', 'electric_shaver', 'food_noodles', 'form', 'bowl', 'wall', 'nightstand', 'cup', 'check', 'toothbrush_holder', 'after_shave', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'light', 'board_game', 'clothes_shirt']
Task:Put on coat
response:
| {
"thoughts": "Open closet and grab coat. Put on coat and fasten the front closed. Close closet.",
"actions": [
"[WALK] <home_office>",
"[WALK] <dresser>",
"[FIND] <dresser>",
"[OPEN] <dresser>",
"[FIND] <clothes_shirt>",
"[GRAB] <clothes_shirt>",
"[PUTON] <clothes_shirt>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'creditcard']
Task:Browse internet
response:
{
"thoughts": Walk to the Home office. Sit on the chair. Switch on the computer. Type with keyboard for internet.,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']
}
|
Scene_Objects:['tablelamp', 'food_salt', 'beer', 'toilet', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'shoe-shine_kit', 'faucet', 'couch', 'candle', 'wall', 'nightstand', 'bench', 'powersocket', 'photoframe', 'video_game_controller', 'curtain', 'rag', 'console', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'table', 'colander']
Task:Wash sink
response:
| {
"thoughts": "I spray some cleaner and wait a minte or so then wipe it out.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <cleaning_solution>",
"[FIND] <cleaning_solution>",
"[GRAB] <cleaning_solution>",
"[WALK] <sink>",
"[POUR] <cleaning_solution> <sink>",
"[PUTOBJBACK] <cleaning_solution>",
"[FIND] <rag>",
"[GRAB] <rag>",
"[WALK] <sink>",
"[WIPE] <sink>",
"[WIPE] <sink>",
"[WIPE] <sink>",
"[PUTOBJBACK] <rag>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'mat', 'faucet', 'couch', 'dining_room', 'wall', 'newspaper', 'toilet_paper', 'television', 'oven_mitts', 'water', 'tray', 'vacuum_cleaner', 'controller', 'door', 'sink', 'napkin', 'bathroom_cabinet', 'instrument_guitar', 'light', 'soap', 'teeth']
Task:Wash teeth
response:
{
"thoughts": Wash the teeth,
"actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[TURNTO] <water>', '[POINTAT] <water>', '[FIND] <teeth>', '[WASH] <teeth>', '[SWITCHOFF] <faucet>']
}
|
Scene_Objects:['pot', 'tablelamp', 'scissors', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'knifeblock', 'cpuscreen', 'ceiling', 'character', 'stamp', 'bookshelf', 'stovefan', 'plate', 'faucet', 'balanceball', 'mousepad', 'wall', 'cup', 'bed', 'food_food', 'coffe_maker', 'wine', 'kitchen_counter', 'cupboard', 'hair', 'laundry_detergent', 'sink', 'table']
Task:Get out dish
response:
| {
"thoughts": "Open cupboard. Get out the dish.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[CLOSE] <cupboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_ice_cream', 'toilet', 'walllamp', 'nail_polish', 'dough', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'cards', 'dishrack', 'door', 'light']
Task:Change TV channel
response:
{
"thoughts": first i will go to living room and then take the remote and swtitch on television after that il change the channel,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TOUCH] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['pot', 'blender', 'microwave', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'longboard', 'floor', 'keyboard', 'toaster', 'laptop', 'stereo', 'window', 'food_peanut_butter', 'dining_room', 'broom', 'nightstand', 'oven', 'cup', 'photoframe', 'bed', 'television', 'after_shave', 'curtain', 'pencil', 'bathroom_cabinet', 'light', 'dishwasher', 'vase']
Task:Clean
response:
| {
"thoughts": "Clean the welcome mat",
"actions": [
"[WALK] <home_office>",
"[WALK] <vacuum_cleaner>",
"[FIND] <vacuum_cleaner>",
"[GRAB] <vacuum_cleaner>",
"[SWITCHON] <vacuum_cleaner>",
"[SWITCHOFF] <vacuum_cleaner>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'glue', 'measuring_cup', 'microwave', 'chair', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'floor', 'phone', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'wall', 'nightstand', 'photoframe', 'food_food', 'coffee_pot', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'instrument_violin', 'table', 'soap', 'tooth_paste']
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>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'beer', 'measuring_cup', 'toilet', 'freezer', 'food_carrot', 'drawing', 'food_egg', 'hanger', 'floor', 'ceiling', 'bedroom', 'mat', 'laptop', 'shower', 'tvstand', 'closetdrawer', 'food_orange', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'drinking_glass', 'wine', 'doorjamb', 'door', 'light']
Task:Drink
response:
{
"thoughts": Robot Drinks the water,
"actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>', '[PUTOBJBACK] <drinking_glass>', '[CLOSE] <freezer>']
}
|
Scene_Objects:['glue', 'sheets', 'food_bread', 'food_pizza', 'tablelamp', 'scissors', 'toilet', 'walllamp', 'woman', 'knifeblock', 'hanger', 'bathroom_counter', 'man', 'tea_bag', 'keyboard', 'mail', 'stereo', 'window', 'couch', 'child', 'powersocket', 'photoframe', 'novel', 'coffe_maker', 'video_game_controller', 'ice', 'rag', 'headset', 'chessboard', 'maindoor']
Task:Greet guests
response:
| {
"thoughts": "Greet guests when they knock on the door and invite them to enter my home",
"actions": [
"[WALK] <home_office>",
"[WALK] <child>",
"[FIND] <child>",
"[GREET] <child>",
"[FIND] <man>",
"[GREET] <man>",
"[FIND] <woman>",
"[GREET] <woman>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'microwave', 'chair', 'bathroom', 'orchid', 'food_egg', 'cpuscreen', 'floor', 'phone', 'bedroom', 'desk', 'stovefan', 'toaster', 'ceilinglamp', 'shower', 'mat', 'food_peanut_butter', 'wall', 'pasta', 'powersocket', 'oven', 'cup', 'bed', 'after_shave', 'food_onion', 'chessboard', 'dresser', 'cupboard', 'clothes_scarf', 'home_office']
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:['filing_cabinet', 'microwave', 'band-aids', 'drawing', 'longboard', 'floor', 'ceiling', 'folder', 'computer', 'clothes_jacket', 'alcohol', 'ceilinglamp', 'balanceball', 'window', 'foundation', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'television', 'wine', 'towel_rack', 'pencil', 'shoes', 'dresser', 'cupboard', 'table', 'light', 'dishwasher']
Task:Arrange furniture
response:
| {
"thoughts": "Move furniture where you want it.",
"actions": [
"[WALK] <home_office>",
"[WALK] <coffee_table>",
"[PUSH] <coffee_table>",
"[WALK] <couch>",
"[PUSH] <couch>",
"[WALK] <couch>",
"[PUSH] <couch>",
"[WALK] <filing_cabinet>",
"[PUSH] <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', 'water_glass', 'microwave', 'toilet', 'chair', 'freezer', 'bathroom', 'wallshelf', 'bookshelf', 'clothes_jacket', 'toaster', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'dining_room', 'nightstand', 'wall', 'wall_clock', 'powersocket', 'basket_for_clothes', 'novel', 'coffe_maker', 'tray', 'doorjamb', 'console', 'dishrack', 'hairdryer', 'door', 'bathtub']
Task:Drink
response:
{
"thoughts": Drink water,
"actions": ['[WALK] <dining_room>', '[WALK] <water_glass>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']
}
|
Scene_Objects:['food_pizza', 'nail_polish', 'food_carrot', 'drawing', 'knife', 'floor', 'ceiling', 'desk', 'mat', 'stereo', 'shower', 'clothes_socks', 'candle', 'pillow', 'dining_room', 'nightstand', 'bench', 'newspaper', 'check', 'video_game_controller', 'doorjamb', 'cards', 'chessboard', 'pajamas', 'clothes_dress', 'table', 'light', 'board_game', 'laser_pointer', 'coffee']
Task:Play games
response:
| {
"thoughts": "I either bring out monopoly, uno, chess, checkers or playing cards and lay them out on the dining room table. We then play the games for a couple of hours.",
"actions": [
"[WALK] <home_office>",
"[WALK] <board_game>",
"[FIND] <board_game>",
"[GRAB] <board_game>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[PUTBACK] <board_game> <table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'chair', 'food_butter', 'food_carrot', 'drawing', 'orchid', 'knifeblock', 'knife', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'toaster', 'mat', 'food_noodles', 'couch', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'light', 'dirt']
Task:Relax on sofa
response:
{
"thoughts": Relax on the sofa in the living room.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['glue', 'pot', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'ceilinglamp', 'toaster', 'form', 'wall', 'oven', 'food_vegetable', 'photoframe', 'tray', 'kitchen_counter', 'cupboard', 'maindoor', 'home_office', 'dishwasher', 'clothes_skirt', 'soap', 'creditcard']
Task:Cook some food
response:
| {
"thoughts": "I prepare meals and cook them on the stove.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_vegetable>",
"[GRAB] <food_vegetable>",
"[CLOSE] <freezer>",
"[FIND] <oven>",
"[SWITCHON] <oven>",
"[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:['sponge', 'toilet', 'chair', 'freezer', 'band-aids', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'bedroom', 'ceilinglamp', 'tvstand', 'clothes_socks', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'clothes_gloves', 'novel', 'tray', 'doorjamb', 'kitchen_counter', 'door', 'table', 'light', 'dishwasher']
Task:Pet cat
response:
{
"thoughts": walk to entrance hall, look at the sofa, sit on the sofa, look at the cat, allow cat to near with you, touch the cat smoothly on it head, now pet the cat smoothly,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['toilet', 'nail_polish', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'toaster', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'cup', 'check', 'television', 'curtain', 'shoes', 'vacuum_cleaner', 'hairdryer', 'spoon', 'table']
Task:Change TV channel
response:
| {
"thoughts": "I go to the living room, I settle on the sofa, I turn on the television, change the channel",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <shoes>",
"[FIND] <shoes>",
"[GRAB] <shoes>",
"[DROP] <shoes>",
"[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:['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>']
}
|
Scene_Objects:['crayon', 'cd_player', 'chair', 'toilet', 'walllamp', 'cat', 'hanger', 'floor', 'phone', 'remote_control', 'purse', 'alcohol', 'tvstand', 'iron', 'picture', 'window', 'wall', 'nightstand', 'powersocket', 'bench', 'cutting_board', 'basket_for_clothes', 'after_shave', 'doorjamb', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'door', 'light']
Task:Listen to music
response:
| {
"thoughts": "Walk to CD player and turn it on then go and sit in a chair and turn the remote control on and then listen to some music.",
"actions": [
"[WALK] <cd_player>",
"[SWITCHON] <cd_player>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <remote_control>",
"[TOUCH] <remote_control>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'filing_cabinet', 'tablelamp', 'bathroom', 'trashcan', 'food_butter', 'cpuscreen', 'desk', 'bookshelf', 'computer', 'mop_bucket', 'mat', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'bench', 'oven', 'powersocket', 'toy', 'photoframe', 'coffe_maker', 'television', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'bathtub', 'sink', 'home_office']
Task:Pick up toys
response:
{
"thoughts": Grab toys off floor. Put it in a container.,
"actions": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']
}
|
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'piano_bench', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'powersocket', 'doorjamb', 'mouse', 'dresser', 'maindoor', 'light', 'instrument_violin', 'shoe_rack']
Task:Write an email
response:
| {
"thoughts": "Compose an email in the home office.",
"actions": [
"[WALK] <home_office>",
"[WALK] <computer>",
"[FIND] <computer>",
"[SWITCHON] <computer>",
"[FIND] <keyboard>",
"[TYPE] <keyboard>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'tablelamp', 'blender', 'crayon', 'microwave', 'toilet', 'walllamp', 'milk', 'drawing', 'bathroom_counter', 'phone', 'desk', 'envelope', 'table_cloth', 'ceilinglamp', 'plate', 'faucet', 'picture', 'couch', 'clothes_pants', 'powersocket', 'bench', 'newspaper', 'tray', 'rag', 'kitchen_counter', 'laundry_detergent', 'soap', 'scrabble', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": Walk to bathroom. Open washing maschine. Grab pants and put it into washing maschine. Pour laundry detergent into washing machine and close the washing maschine. Plug in washing machine.,
"actions": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[PLUGIN] <washing_machine>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'crayon', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'knifeblock', 'floor', 'desk', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_orange', 'pillow', 'form', 'dining_room', 'wall', 'bench', 'coffe_maker', 'television', 'rag', 'pencil', 'comb', 'table', 'tooth_paste', 'clothes_shirt', 'scrabble', 'creditcard']
Task:Relax on sofa
response:
| {
"thoughts": "I walk to the living room and stand in front of the sofa. Then I turn and sit on the sofa and lean my back against the pillow and my feet on the floor.",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[TURNTO] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'water_glass', 'pot', 'glue', 'walllamp', 'trashcan', 'knifeblock', 'ceiling', 'clothes_jacket', 'stovefan', 'toaster', 'mat', 'faucet', 'microphone', 'wall', 'cup', 'bed', 'food_food', 'check', 'water', 'food_donut', 'curtain', 'kitchen_counter', 'chessboard', 'cupboard', 'laundry_detergent', 'sink', 'spoon', 'bathroom_cabinet', 'dirt']
Task:Drink
response:
{
"thoughts": I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}
|
Scene_Objects:['fork', 'tablelamp', 'crayon', 'microwave', 'drawing', 'bills', 'cpuscreen', 'longboard', 'floor', 'bookshelf', 'computer', 'button', 'table_cloth', 'toaster', 'ceilinglamp', 'faucet', 'window', 'oil', 'couch', 'food_jam', 'food_orange', 'wall', 'bench', 'mouthwash', 'television', 'cupboard', 'table', 'clothes_skirt', 'light', 'tooth_paste']
Task:Relax on sofa
response:
| {
"thoughts": "walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[TURNTO] <couch>",
"[LOOKAT] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['juice', 'food_ice_cream', 'blow_dryer', 'detergent', 'ceilingfan', 'drawing', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bedroom', 'keyboard', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'shoe-shine_kit', 'couch', 'food_orange', 'wall', 'tape', 'television', 'curtain', 'kitchen_counter', 'conditioner', 'bathroom_cabinet', 'table']
Task:Relax on sofa
response:
{
"thoughts": For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <conditioner>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[LIE] <couch>']
}
|
Scene_Objects:['pot', 'scissors', 'tea', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'hanger', 'kitchen_cabinet', 'floor', 'ceiling', 'phone', 'food_chicken', 'button', 'stovefan', 'toaster', 'ceilinglamp', 'wall', 'oven', 'bed', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'light', 'dishwasher']
Task:Cook some food
response:
| {
"thoughts": "I walk into the kitchen and walk over the cabinent. I pull out a pan and walk to the stove. I put the pan on the stove and walk over to the fridge. I pull out out meat from the fridge and walk back over the stove. Then I put the meat in the pan.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <kitchen_cabinet>",
"[FIND] <pot>",
"[GRAB] <pot>",
"[WALK] <oven>",
"[PUTBACK] <pot> <oven>",
"[WALK] <freezer>",
"[OPEN] <freezer>",
"[FIND] <food_chicken>",
"[GRAB] <food_chicken>",
"[WALK] <oven>",
"[PUTBACK] <food_chicken> <oven>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'table']
Task:Watch youtube
response:
{
"thoughts": Go to youtube.Com watch videos,
"actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']
}
|
Scene_Objects:['tablelamp', 'beer', 'toilet', 'dough', 'toothbrush', 'drawing', 'floor', 'ceiling', 'computer', 'ceilinglamp', 'tvstand', 'stereo', 'shower', 'window', 'oil', 'couch', 'bowl', 'wall', 'oven', 'toy', 'cup', 'bed', 'food_food', 'television', 'wooden_spoon', 'towel_rack', 'comb', 'cupboard', 'table', 'dishwasher']
Task:Relax on sofa
response:
| {
"thoughts": "Walk to living room. Find couch. Sit on couch",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'ceilinglamp', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'tape', 'basket_for_clothes', 'bed', 'coffe_maker', 'chessboard', 'clothes_dress', 'door', 'home_office', 'light', 'soap', 'washing_machine']
Task:Wash clothes
response:
{
"thoughts": Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,
"actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['dry_pasta', 'toilet', 'ceilingfan', 'milk', 'knife', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'food_cake', 'computer', 'stovefan', 'deck_of_cards', 'mousepad', 'wall', 'wall_clock', 'photoframe', 'bed', 'video_game_controller', 'coffee_pot', 'mouse', 'door', 'bathroom_cabinet', 'light', 'soap', 'scrabble', 'coffee']
Task:Go to toilet
response:
| {
"thoughts": "I go to the bathroom. I locate the toilet. I walk to the toilet.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <toilet>",
"[FIND] <toilet>",
"[WALK] <toilet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['chair', 'detergent', 'food_butter', 'clothes_underwear', 'hanger', 'floor', 'stamp', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'shoe-shine_kit', 'clothes_socks', 'closetdrawer', 'couch', 'clothes_pants', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'vacuum_cleaner', 'laundry_detergent', 'clothes_dress', 'bathroom_cabinet', 'light', 'dishwasher', 'clothes_shirt', 'washing_machine', 'creditcard']
Task:Wash clothes
response:
{
"thoughts": I grab the basket for clothes from the bedroom. I carry it and walk to the washing machine. I open the washing machine. I grab the dirty clothes. I put the clothes in the washing machine. I grab the laundry detergent and put it in the washing machine. I close the washing machine. I switch on the washing machine.,
"actions": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[DROP] <basket_for_clothes>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTBACK] <clothes_socks> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[GRAB] <laundry_detergent>', '[PUTOBJBACK] <laundry_detergent>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'microwave', 'toilet', 'nail_polish', 'knifeblock', 'hanger', 'bedroom', 'keyboard', 'mail', 'button', 'mat', 'stereo', 'iron', 'shower', 'mousepad', 'dustpan', 'photoframe', 'newspaper', 'food_food', 'video_game_controller', 'coffe_maker', 'coin', 'curtain', 'kettle', 'napkin', 'home_office', 'light', 'teeth']
Task:Listen to music
response:
| {
"thoughts": "I go into the living room and turn on the radio. Then, I select the station I want, which is usually a preset.",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[FIND] <button>",
"[PUSH] <button>",
"[FIND] <button>",
"[PUSH] <button>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'food_pizza', 'chair', 'cat', 'drawing', 'floor', 'tea_bag', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'stovefan', 'window', 'couch', 'food_orange', 'wall', 'food_food', 'television', 'oven_mitts', 'food_onion', 'curtain', 'after_shave', 'comb', 'napkin', 'home_office', 'table', 'dishwasher', 'bathroom_cabinet', 'laser_pointer', 'scrabble']
Task:Relax on sofa
response:
{
"thoughts": go to the living room,find the sofa,sat down in the sofa,take some relaxation.,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['blender', 'food_ice_cream', 'bathroom', 'cat', 'drawing', 'bills', 'bathroom_counter', 'floor', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'window', 'mousepad', 'couch', 'towel', 'wall', 'powersocket', 'tape', 'food_cheese', 'novel', 'television', 'wooden_spoon', 'curtain', 'shaving_cream', 'chessboard', 'shoes', 'food_steak', 'table', 'light']
Task:Relax on sofa
response:
| {
"thoughts": "move to living room, locate sofa, move to sofa, sit on sofa, lie on sofa",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[WALK] <couch>",
"[SIT] <couch>",
"[LIE] <couch>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'blender', 'crayon', 'microwave', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'bedroom', 'envelope', 'stovefan', 'window', 'oil', 'wall', 'powersocket', 'bench', 'toy', 'keys', 'food_donut', 'wooden_spoon', 'curtain', 'doorjamb', 'maindoor', 'bathtub', 'bathroom_cabinet', 'light', 'dirt', 'teeth']
Task:Turn on light
response:
{
"thoughts": walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.,
"actions": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>']
}
|
Scene_Objects:['pot', 'crayon', 'microwave', 'chair', 'freezer', 'detergent', 'food_egg', 'hanger', 'floor', 'ceiling', 'toaster', 'plate', 'shower', 'mousepad', 'broom', 'wall', 'pasta', 'keys', 'novel', 'coffe_maker', 'toothbrush_holder', 'coffee_filter', 'wooden_spoon', 'towel_rack', 'controller', 'maindoor', 'sink', 'dishwasher', 'coffee', 'creditcard']
Task:Make coffee
response:
| {
"thoughts": "Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <coffe_maker>",
"[FIND] <coffe_maker>",
"[OPEN] <coffe_maker>",
"[FIND] <coffee_filter>",
"[GRAB] <coffee_filter>",
"[PUTBACK] <coffee_filter> <coffe_maker>",
"[FIND] <coffee>",
"[GRAB] <coffee>",
"[PUTBACK] <coffee> <coffe_maker>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'tea', 'knifeblock', 'cpuscreen', 'folder', 'bedroom', 'table_cloth', 'toaster', 'plate', 'homework', 'oil', 'closetdrawer', 'powersocket', 'tape', 'bed', 'novel', 'coffe_maker', 'television', 'razor', 'wine', 'doorjamb', 'shoes', 'dishrack', 'headset', 'cupboard', 'hairdryer', 'light', 'shoe_rack']
Task:Listen to music
response:
{
"thoughts": walk into living room, walk to stereo, turn on stereo, listen to music,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'walllamp', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'dvd_player', 'character', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'electric_shaver', 'mousepad', 'couch', 'form', 'wall', 'nightstand', 'clothes_gloves', 'television', 'curtain', 'headset', 'maindoor', 'table', 'clothes_shirt']
Task:Watch TV
response:
| {
"thoughts": "Walk to Living room. Find Television. Walk to sofa. Sit on sofa. Find Remote. Grab remote. Turn to television. Look at television. Switch on Television.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[WALK] <couch>",
"[SIT] <couch>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[TURNTO] <television>",
"[LOOKAT] <television>",
"[SWITCHON] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'food_pizza', 'filing_cabinet', 'microwave', 'chair', 'walllamp', 'orchid', 'knifeblock', 'bathroom_counter', 'ceiling', 'phone', 'stamp', 'keyboard', 'thread', 'computer', 'stovefan', 'toaster', 'plate', 'shower', 'mousepad', 'form', 'wall', 'food_cheese', 'bed', 'console', 'headset', 'dresser', 'spoon', 'bathroom_cabinet', 'bag']
Task:Walk to room
response:
{
"thoughts": Leave the living room and enter the hall,
"actions": ['[WALK] <home_office>', '[WALK] <home_office>']
}
|
Scene_Objects:['dry_pasta', 'filing_cabinet', 'toilet', 'detergent', 'ceilingfan', 'drawing', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'remote_control', 'thread', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'shower', 'couch', 'pillow', 'wall', 'food_cheese', 'television', 'curtain', 'centerpiece', 'home_office', 'table']
Task:Watch TV
response:
| {
"thoughts": "I go in my living room, find the remote, sit on my couch, turn on the TV and watch TV.",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[FIND] <couch>",
"[SIT] <couch>",
"[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:['food_pizza', 'tablelamp', 'chair', 'freezer', 'detergent', 'bathroom_counter', 'desk', 'bedroom', 'keyboard', 'button', 'stovefan', 'ceilinglamp', 'stereo', 'shower', 'window', 'clothes_socks', 'dining_room', 'nightstand', 'wall', 'bench', 'oven', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'dresser', 'napkin', 'bathroom_cabinet', 'soap']
Task:Listen to music
response:
{
"thoughts": Walk into living room, look for radio, grab on button,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>']
}
|
Scene_Objects:['sheets', 'glue', 'chair', 'walllamp', 'ceilingfan', 'knife', 'orchid', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'balanceball', 'mousepad', 'clothes_socks', 'bowl', 'wall', 'check', 'television', 'mouse', 'kitchen_counter', 'cd', 'door', 'light', 'soap']
Task:Pick up phone
response:
| {
"thoughts": "When the phone rings, I pick up the call and give response to the call.",
"actions": [
"[WALK] <home_office>",
"[WALK] <chair>",
"[FIND] <chair>",
"[SIT] <chair>",
"[FIND] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['scissors', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'newspaper', 'television', 'doorjamb', 'dresser', 'soap', 'instrument_violin']
Task:Watch TV
response:
{
"thoughts": I sit on my couch and watch TV in my living room,
"actions": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']
}
|
Scene_Objects:['glue', 'shoe_rack', 'food_salt', 'beer', 'measuring_cup', 'microwave', 'trashcan', 'food_carrot', 'orchid', 'drawing', 'bookshelf', 'envelope', 'alcohol', 'ceilinglamp', 'plate', 'food_jam', 'pillow', 'oven', 'newspaper', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'lighter', 'doorjamb', 'coffee_pot', 'towel_rack', 'cupboard', 'hairdryer', 'creditcard']
Task:Pet cat
response:
| {
"thoughts": "find a cat, touch it gently",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['glue', 'sheets', 'food_bread', 'food_pizza', 'tablelamp', 'scissors', 'toilet', 'walllamp', 'woman', 'knifeblock', 'hanger', 'bathroom_counter', 'man', 'tea_bag', 'keyboard', 'mail', 'stereo', 'window', 'couch', 'child', 'powersocket', 'photoframe', 'novel', 'coffe_maker', 'video_game_controller', 'ice', 'rag', 'headset', 'chessboard', 'maindoor']
Task:Greet guests
response:
{
"thoughts": Greet guests when they knock on the door and invite them to enter my home,
"actions": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[GREET] <child>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']
}
|
Scene_Objects:['bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'folder', 'character', 'remote_control', 'food_cake', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'window', 'couch', 'wall', 'oven', 'bench', 'photoframe', 'coffee_table', 'food_food', 'television', 'curtain', 'lighter', 'towel_rack', 'controller', 'maindoor', 'table', 'light']
Task:Change TV channel
response:
| {
"thoughts": "Walk to the living room and look at the coffee table. Grab the remote control and turn to the television and point the remote control. Put back the remote control.",
"actions": [
"[WALK] <home_office>",
"[WALK] <coffee_table>",
"[FIND] <coffee_table>",
"[TURNTO] <coffee_table>",
"[LOOKAT] <coffee_table>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <television>",
"[TURNTO] <television>",
"[POINTAT] <television>",
"[PUTOBJBACK] <remote_control>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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:['beer', 'toilet', 'walllamp', 'detergent', 'dough', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'desk', 'table_cloth', 'faucet', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'pasta', 'photoframe', 'food_food', 'check', 'food_donut', 'dishrack', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'soap']
Task:Wash hands
response:
| {
"thoughts": "walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse hands,",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <sink>",
"[FIND] <soap>",
"[WASH] <soap>",
"[RINSE] <soap>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'crayon', 'microwave', 'toilet', 'chair', 'dough', 'drawing', 'knifeblock', 'clothes_underwear', 'floor', 'folder', 'bedroom', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'candle', 'clothes_hat', 'wall', 'food_food', 'food_onion', 'cards', 'mouse', 'kitchen_counter', 'cupboard', 'conditioner', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'dirt']
Task:Wash dishes by hand
response:
{
"thoughts": I walk into the kitchen to the sink. I put dishes in sink and wash them with my hands,
"actions": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>', '[WASH] <plate>']
}
|
Scene_Objects:['glue', 'food_pizza', 'tea', 'freezer', 'walllamp', 'knifeblock', 'food_egg', 'cpuscreen', 'bathroom_counter', 'phone', 'computer', 'toaster', 'brush', 'ceilinglamp', 'mat', 'window', 'mousepad', 'pillow', 'wall', 'clothes_gloves', 'novel', 'check', 'food_onion', 'console', 'kitchen_counter', 'vacuum_cleaner', 'hair', 'controller', 'bathroom_cabinet', 'instrument_violin']
Task:Read book
response:
| {
"thoughts": "go to bedroom, sit down, pick up book, read",
"actions": [
"[WALK] <home_office>",
"[WALK] <novel>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'tablelamp', 'microwave', 'toilet', 'freezer', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'toaster', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'water', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink']
Task:Drink
response:
{
"thoughts": I need to go to Kitchen. Get a cup. Fill cup. Drink,
"actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}
|
Scene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'shower', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'cards', 'mouse', 'bathroom_cabinet', 'light', 'soap']
Task:Work
response:
| {
"thoughts": "Walk to the home office and turn to the desk. Switch on the computer. Grab the mouse and keyboard to start working.",
"actions": [
"[WALK] <home_office>",
"[WALK] <desk>",
"[FIND] <desk>",
"[TURNTO] <desk>",
"[FIND] <computer>",
"[TURNTO] <computer>",
"[LOOKAT] <computer>",
"[SWITCHON] <computer>",
"[FIND] <keyboard>",
"[GRAB] <keyboard>",
"[FIND] <mouse>",
"[GRAB] <mouse>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'juice', 'dog', 'orchid', 'floor', 'desk', 'button', 'clothes_jacket', 'mat', 'stereo', 'shower', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toilet_paper', 'mouthwash', 'television', 'curtain', 'after_shave', 'doorjamb', 'hair', 'food_steak', 'napkin', 'home_office', 'table', 'vase']
Task:Listen to music
response:
{
"thoughts": sitting down to listen to music on the radio,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['pot', 'filing_cabinet', 'beer', 'crayon', 'detergent', 'drawing', 'food_egg', 'floor', 'ceiling', 'bedroom', 'brush', 'mat', 'ceilinglamp', 'shower', 'balanceball', 'window', 'couch', 'towel', 'wall', 'bench', 'light_bulb', 'television', 'water', 'curtain', 'mouse', 'kitchen_counter', 'door', 'home_office', 'soap', 'laser_pointer']
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'cat', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'phone', 'desk', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'toaster', 'window', 'oil', 'closetdrawer', 'couch', 'form', 'pillow', 'wall', 'wall_clock', 'coffe_maker', 'television', 'curtain', 'mouse', 'home_office', 'table', 'coffee']
Task:Pet cat
response:
{
"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:['sheets', 'scissors', 'toilet', 'jelly', 'ground_coffee', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'clothes_jacket', 'faucet', 'mousepad', 'wall', 'oven', 'cup', 'photoframe', 'video_game_controller', 'television', 'tray', 'doorjamb', 'mouse', 'conditioner', 'sink', 'bathroom_cabinet', 'home_office', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:
| {
"thoughts": "Go to the bathroom and wash hands.",
"actions": [
"[RUN] <bathroom>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <soap>",
"[GRAB] <soap>",
"[PUTBACK] <soap> <sink>",
"[FIND] <hands_both>",
"[WASH] <hands_both>",
"[GRAB] <soap>",
"[PUTOBJBACK] <soap>",
"[RINSE] <hands_both>",
"[SWITCHOFF] <faucet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'toilet', 'walllamp', 'bathroom', 'detergent', 'drawing', 'bills', 'floor', 'character', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'stereo', 'closetdrawer', 'form', 'dining_room', 'nightstand', 'powersocket', 'cup', 'bed', 'tray', 'mouse', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'home_office', 'dirt', 'electrical_outlet']
Task:Turn on radio
response:
{
"thoughts": Go to the radio. Switch on the power button. Tune the station. Set the volume. Listen to the music.,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[FIND] <electrical_outlet>', '[TURNTO] <electrical_outlet>', '[PLUGIN] <stereo>', '[SWITCHON] <electrical_outlet>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'television', 'toothbrush_holder', 'curtain', 'kettle', 'mouse', 'bag', 'table', 'vase']
Task:Watch TV
response:
| {
"thoughts": "Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program.",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[FIND] <television>",
"[SWITCHON] <television>",
"[WALK] <chair>",
"[SIT] <chair>",
"[TURNTO] <television>",
"[WATCH] <television>",
"[SWITCHOFF] <television>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'water_glass', 'microwave', 'toilet', 'drawing', 'wallshelf', 'ceiling', 'desk', 'bookmark', 'toaster', 'stovefan', 'mat', 'shower', 'couch', 'wall', 'oven', 'coffe_maker', 'coin', 'water', 'tray', 'towel_rack', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'cupboard', 'controller', 'hairdryer', 'spoon', 'dishwasher', 'creditcard']
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:['glue', 'pot', 'food_ice_cream', 'walllamp', 'nail_polish', 'detergent', 'knife', 'needle', 'cpuscreen', 'bathroom_counter', 'character', 'bedroom', 'remote_control', 'envelope', 'alcohol', 'button', 'deck_of_cards', 'iron', 'nightstand', 'pasta', 'television', 'wine', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher', 'vase']
Task:Change TV channel
response:
| {
"thoughts": "Take the Tv Remote Control in the Living Room table And Press the Channel Change Button to change the channel",
"actions": [
"[WALK] <home_office>",
"[WALK] <remote_control>",
"[FIND] <remote_control>",
"[GRAB] <remote_control>",
"[FIND] <button>",
"[PUSH] <button>",
"[PUTOBJBACK] <remote_control>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', '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>']
}
|
Scene_Objects:['juice', 'bathroom', 'ceilingfan', 'drawing', 'bills', 'knife', 'orchid', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'bookmark', 'ceilinglamp', 'tvstand', 'balanceball', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'keys', 'television', 'coffee_filter', 'curtain', 'centerpiece', 'cupboard', 'bathroom_cabinet', 'table']
Task:Change TV channel
response:
| {
"thoughts": "change the tv channel",
"actions": [
"[WALK] <home_office>",
"[WALK] <television>",
"[SWITCHON] <television>",
"[FIND] <remote_control>",
"[FIND] <button>",
"[PUSH] <button>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'microwave', 'toilet', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'folder', 'tea_bag', 'mat', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'pasta', 'nightstand', 'photoframe', 'novel', 'food_food', 'tray', 'curtain', 'doorjamb', 'door', 'table', 'light', 'board_game']
Task:Read book
response:
{
"thoughts": Bring book, lie on the sofa, read book,
"actions": ['[WALK] <home_office>', '[WALK] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[LIE] <couch>', '[READ] <novel>']
}
|
Scene_Objects:['sponge', 'fork', 'sheets', 'tablelamp', 'mop', 'detergent', 'ceilingfan', 'milk', 'hanger', 'ceiling', 'desk', 'window', 'mousepad', 'clothes_socks', 'clothes_pants', 'pillow', 'dining_room', 'bench', 'cutting_board', 'bed', 'novel', 'check', 'television', 'curtain', 'cards', 'towel_rack', 'cd', 'shoes', 'napkin', 'table']
Task:Pick up phone
response:
| {
"thoughts": "walk into room, grab phone",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'filing_cabinet', 'tea', 'microwave', 'dog', 'freezer', 'walllamp', 'drawing', 'orchid', 'hanger', 'keyboard', 'button', 'ceilinglamp', 'stereo', 'homework', 'mousepad', 'closetdrawer', 'food_peanut_butter', 'food_jam', 'wall', 'oven', 'food_cheese', 'keys', 'tray', 'lighter', 'mouse', 'kitchen_counter', 'cd', 'clothes_dress', 'bathroom_cabinet']
Task:Pet cat
response:
{
"thoughts": Petting the cat,
"actions": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']
}
|
Scene_Objects:['sponge', 'juice', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'desk', 'mop_bucket', 'stovefan', 'toaster', 'faucet', 'food_jam', 'wall', 'photoframe', 'novel', 'coffe_maker', 'video_game_controller', 'shaving_cream', 'towel_rack', 'hairbrush', 'sink', 'bathroom_cabinet', 'home_office', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:
| {
"thoughts": "Wash Hands",
"actions": [
"[WALK] <bathroom>",
"[WALK] <faucet>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <faucet>",
"[FIND] <soap>",
"[SCRUB] <soap>",
"[FIND] <hands_both>",
"[SCRUB] <hands_both>",
"[RINSE] <hands_both>",
"[SWITCHOFF] <faucet>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'dog', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'piano_bench', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'towel', 'wall', 'oven', 'coffe_maker', 'television', 'coffee_filter', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathtub', 'coffee']
Task:Make coffee
response:
{
"thoughts": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,
"actions": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <coffee>', '[GRAB] <coffee>', '[PUTBACK] <coffee> <coffe_maker>']
}
|
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'freezer', 'cat', 'orchid', 'drawing', 'hanger', 'ceiling', 'dvd_player', 'desk', 'mail', 'piano_bench', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'mousepad', 'food_orange', 'pillow', 'bench', 'bed', 'check', 'doorjamb', 'cd', 'controller', 'laundry_detergent', 'sink', 'home_office', 'dishwasher']
Task:Pet cat
response:
| {
"thoughts": "I go to the living room then go to the cat and touch it.",
"actions": [
"[WALK] <home_office>",
"[WALK] <cat>",
"[FIND] <cat>",
"[TOUCH] <cat>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'walllamp', 'drawing', 'needle', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'character', 'computer', 'toaster', 'mat', 'tvstand', 'deck_of_cards', 'stovefan', 'ceilinglamp', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'television', 'tray', 'doorjamb', 'pencil', 'conditioner', 'door', 'table', 'dishwasher']
Task:Relax on sofa
response:
{
"thoughts": Walk to living room. Find couch. Sit on couch,
"actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']
}
|
Scene_Objects:['fork', 'food_bread', 'filing_cabinet', 'tablelamp', 'freezer', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'bills', 'floor', 'ceiling', 'character', 'food_cake', 'piano_bench', 'brush', 'ceilinglamp', 'mousepad', 'towel', 'wall', 'bed', 'food_food', 'food_donut', 'ice', 'curtain', 'kettle', 'dresser', 'light', 'soap', 'coffee']
Task:Put groceries in Fridge
response:
| {
"thoughts": "Open the fridge, put the groceries in the fridge and close it.",
"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:['dry_pasta', 'food_pizza', 'mop', 'cat', 'knife', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'dvd_player', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'faucet', 'stereo', 'window', 'couch', 'towel', 'wall', 'novel', 'tray', 'doorjamb', 'hairbrush', 'sink', 'bathroom_cabinet', 'soap', 'hands_both', 'shoe_rack']
Task:Wash hands
response:
{
"thoughts": I go to the sink, turn on the water, put soap on my hands, rub them together, then rinse them off and turn off the water. I then towel off my hands.,
"actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[FIND] <hands_both>', '[WIPE] <hands_both>']
}
|
Scene_Objects:['dry_pasta', 'pot', 'ceilingfan', 'toothbrush', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'piano_bench', 'toaster', 'faucet', 'window', 'mousepad', 'clothes_pants', 'wall', 'nightstand', 'pasta', 'photoframe', 'toothbrush_holder', 'shoes', 'dresser', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'tooth_paste', 'laser_pointer']
Task:Brush teeth
response:
| {
"thoughts": "go to bathroom. grab toothbrush. put toothpaste on toothbrush. brush teeth. turn on faucet. rinse toothbrush and mouth. put toothbrush away.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <toothbrush_holder>",
"[TURNTO] <toothbrush_holder>",
"[LOOKAT] <toothbrush_holder>",
"[FIND] <tooth_paste>",
"[GRAB] <tooth_paste>",
"[FIND] <toothbrush>",
"[GRAB] <toothbrush>",
"[PUTBACK] <tooth_paste> <toothbrush_holder>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[RINSE] <toothbrush>",
"[PUTBACK] <toothbrush> <toothbrush_holder>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['dry_pasta', 'glue', 'measuring_cup', 'microwave', 'chair', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'floor', 'phone', 'bookshelf', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'wall', 'nightstand', 'photoframe', 'food_food', 'coffee_pot', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'instrument_violin', 'table', 'soap', 'tooth_paste']
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>']
}
|
Scene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'freezer', 'drawing', 'hanger', 'kitchen_cabinet', 'floor', 'phone', 'bathroom_counter', 'folder', 'stamp', 'keyboard', 'computer', 'food_bacon', 'table_cloth', 'brush', 'mat', 'plate', 'clothes_socks', 'couch', 'bowl', 'bench', 'toy', 'bed', 'check', 'cupboard', 'door', 'table', 'light']
Task:Set up table
response:
| {
"thoughts": "Walk to the kitchen. Open the kitchen cabinet. Grab the plate and put it on the table.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[FIND] <table>",
"[PUTBACK] <plate> <table>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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', 'measuring_cup', 'dog', 'walllamp', 'bathroom', 'floor', 'phone', 'bedroom', 'mat', 'stereo', 'faucet', 'window', 'closetdrawer', 'dining_room', 'food_cheese', 'standingmirror', 'bed', 'check', 'television', 'coffee_filter', 'food_rice', 'ice', 'curtain', 'doorjamb', 'pencil', 'conditioner', 'bathtub', 'napkin', 'vase']
Task:Listen to music
response:
{
"thoughts": Listen to music,
"actions": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']
}
|
Scene_Objects:['scissors', 'tea', 'chair', 'trashcan', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'desk', 'tea_bag', 'bookshelf', 'keyboard', 'computer', 'picture', 'mousepad', 'food_jam', 'wall', 'cutting_board', 'cup', 'novel', 'tray', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light', 'dishwasher']
Task:Read book
response:
| {
"thoughts": "Walk to home office, turn on light, grab a book, sit in chair, start to read the book",
"actions": [
"[WALK] <home_office>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[FIND] <novel>",
"[GRAB] <novel>",
"[FIND] <chair>",
"[SIT] <chair>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'crayon', 'chair', 'walllamp', 'hanger', 'floor', 'ceiling', 'phone', 'tea_bag', 'clothes_jacket', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'dish_soap', 'mousepad', 'dustpan', 'clothes_hat', 'wall', 'cup', 'coffe_maker', 'coffee_filter', 'curtain', 'coffee_pot', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'napkin']
Task:Wash dishes
response:
{
"thoughts": Place all of the dirty dishes in a sink full of clean, soapy water. Wash them. Rinse them in fresh, running water. Place them in the strainer to dry.,
"actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[SCRUB] <cup>', '[PUTOBJBACK] <cup>', '[PUTBACK] <sponge> <sink>', '[SWITCHON] <faucet>', '[RINSE] <cup>', '[GRAB] <cup>', '[FIND] <dishrack>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishrack>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[GRAB] <sponge>', '[PUTOBJBACK] <sponge>']
}
|
Scene_Objects:['sheets', 'crayon', 'chair', 'band-aids', 'bathroom', 'food_butter', 'ceilingfan', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'longboard', 'folder', 'bookshelf', 'brush', 'shoe-shine_kit', 'stereo', 'food_jam', 'wall', 'powersocket', 'coffe_maker', 'food_food', 'television', 'wooden_spoon', 'doorjamb', 'dresser', 'cupboard', 'door', 'light']
Task:Turn on light
response:
| {
"thoughts": "walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <home_office>",
"[WALK] <home_office>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'chair', 'milk', 'drawing', 'cpuscreen', 'shampoo', 'folder', 'bookshelf', 'computer', 'table_cloth', 'ceilinglamp', 'mat', 'oil', 'mousepad', 'couch', 'towel', 'nightstand', 'wall', 'cutting_board', 'cup', 'photoframe', 'bed', 'food_donut', 'mouse', 'kitchen_counter', 'pajamas', 'sink', 'napkin', 'home_office', 'tooth_paste']
Task:Open front door
response:
{
"thoughts": Walk over to the front door, turn the knob, and open the door.,
"actions": ['[WALK] <home_office>']
}
|
Scene_Objects:['food_pizza', 'mop', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'envelope', 'faucet', 'picture', 'homework', 'window', 'mousepad', 'clothes_hat', 'towel', 'wall', 'photoframe', 'hands_both', 'food_food', 'doorjamb', 'kettle', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'light', 'vase', 'teeth']
Task:Wash teeth
response:
| {
"thoughts": "I need to rinse my dentures off and put them back in my mouth.",
"actions": [
"[WALK] <bathroom>",
"[WALK] <light>",
"[FIND] <light>",
"[SWITCHON] <light>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <teeth>",
"[GRAB] <teeth>",
"[WASH] <teeth>",
"[PUTOBJBACK] <teeth>",
"[SWITCHOFF] <faucet>",
"[FIND] <towel>",
"[GRAB] <towel>",
"[FIND] <hands_both>",
"[SCRUB] <hands_both>",
"[PUTOBJBACK] <towel>",
"[SWITCHOFF] <light>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'microwave', 'chair', 'jelly', 'knifeblock', 'floor', 'ceiling', 'character', 'alcohol', 'toaster', 'plate', 'faucet', 'drying_rack', 'window', 'tvstand', 'dish_soap', 'closetdrawer', 'couch', 'towel', 'pillow', 'food_kiwi', 'wall', 'toy', 'novel', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'instrument_guitar', 'shoe_rack']
Task:Do dishes
response:
{
"thoughts": Wash dirty dishes, dry them and then put them away,
"actions": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <drying_rack>', '[PUTBACK] <plate> <drying_rack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <drying_rack>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']
}
|
Scene_Objects:['sponge', 'tea', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'ceiling', 'bookshelf', 'computer', 'button', 'mail', 'stovefan', 'ceilinglamp', 'window', 'couch', 'wall', 'bench', 'tape', 'cup', 'coffe_maker', 'tray', 'headset', 'comb', 'cupboard', 'sink', 'home_office', 'table', 'bathroom_cabinet', 'vase']
Task:Read book
response:
| {
"thoughts": "pick up your book and read it",
"actions": [
"[WALK] <bedroom>",
"[WALK] <novel>",
"[GRAB] <novel>",
"[READ] <novel>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_salt', 'toilet', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'bedroom', 'keyboard', 'tvstand', 'stereo', 'balanceball', 'picture', 'mousepad', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'photoframe', 'bed', 'toilet_paper', 'coffe_maker', 'cards', 'mouse', 'kitchen_counter', 'cd', 'vase']
Task:Go to toilet
response:
{
"thoughts": Walk to the bathroom. Find the toilet. Lift the top of the toilet. Sit on the toilet.,
"actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']
}
|
Scene_Objects:['food_bread', 'freezer', 'cat', 'food_carrot', 'dough', 'orchid', 'needle', 'hanger', 'longboard', 'floor', 'ceiling', 'bathroom_counter', 'ceilinglamp', 'mat', 'stereo', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'light_bulb', 'food_food', 'coffe_maker', 'video_game_controller', 'oven_mitts', 'food_rice', 'vacuum_cleaner', 'dresser', 'door', 'hairdryer']
Task:Put groceries in Fridge
response:
| {
"thoughts": "I leave the bags with groceries near the fridge, open the door and put the groceries in the shelves.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[PUTIN] <food_food> <freezer>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'towel_rack', 'kitchen_counter', 'chessboard', 'sink', 'home_office', 'bathroom_cabinet', 'table', 'instrument_violin']
Task:Go to toilet
response:
{
"thoughts": Walk to the bathroom. Find the toilet. Lift the top of the toilet. Sit on the toilet.,
"actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']
}
|
Scene_Objects:['food_pizza', 'food_ice_cream', 'mop', 'chair', 'freezer', 'walllamp', 'cat', 'trashcan', 'toothbrush', 'hanger', 'bathroom_counter', 'floor', 'keyboard', 'dining_room', 'bench', 'powersocket', 'cup', 'photoframe', 'novel', 'toothbrush_holder', 'curtain', 'mouse', 'headset', 'pajamas', 'door', 'dishwasher', 'vase', 'tooth_paste', 'clothes_shirt', '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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'microwave', 'toilet', 'detergent', 'cat', 'food_butter', 'knife', 'phone', 'character', 'table_cloth', 'mat', 'deck_of_cards', 'stereo', 'form', 'pillow', 'dining_room', 'nightstand', 'wall', 'basket_for_clothes', 'photoframe', 'tray', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'clothes_dress', 'table', 'soap', 'washing_machine', 'creditcard']
Task:Wash clothes
response:
{
"thoughts": Walk to Bathroom. Find basket for clothes. Lift clothes dress from basket. Find washing machine. Walk to washing machine. Put clothes in washing machine. Put soap in washing machine. Switch on washing machine.,
"actions": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_dress> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}
|
Scene_Objects:['sheets', 'pot', 'mop', 'dog', 'jelly', 'drawing', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'character', 'computer', 'stovefan', 'faucet', 'oil', 'dining_room', 'wall', 'nightstand', 'oven', 'cutting_board', 'photoframe', 'check', 'tray', 'sink', 'napkin', 'bathroom_cabinet', 'soap', 'dirt', 'hands_both']
Task:Wash hands
response:
| {
"thoughts": "go to the bathroom and wash your hands",
"actions": [
"[WALK] <bathroom>",
"[WALK] <sink>",
"[FIND] <faucet>",
"[SWITCHON] <faucet>",
"[FIND] <soap>",
"[SQUEEZE] <soap>",
"[FIND] <hands_both>",
"[WASH] <hands_both>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', '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:['food_bread', 'microwave', 'freezer', 'walllamp', 'bathroom', 'toothbrush', 'orchid', 'hanger', 'longboard', 'phone', 'desk', 'computer', 'food_bacon', 'table_cloth', 'clothes_jacket', 'brush', 'ceilinglamp', 'faucet', 'foundation', 'mousepad', 'clothes_pants', 'pasta', 'light_bulb', 'toothbrush_holder', 'coin', 'coffee_filter', 'towel_rack', 'hair', 'vase', '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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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:['water_glass', 'scissors', 'tablelamp', 'bathroom', 'drawing', 'floor', 'desk', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'shower', 'window', 'couch', 'clothes_hat', 'towel', 'wall', 'oven', 'photoframe', 'check', 'food_food', 'television', 'coffe_maker', 'tray', 'centerpiece', 'pencil', 'chessboard', 'hair', 'table', 'vase']
Task:Relax on sofa
response:
| {
"thoughts": "Drink a glass of water in the sofa",
"actions": [
"[WALK] <home_office>",
"[WALK] <couch>",
"[FIND] <couch>",
"[SIT] <couch>",
"[FIND] <water_glass>",
"[GRAB] <water_glass>",
"[DRINK] <water_glass>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'tea', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'bathroom', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'ceilinglamp', 'plate', 'mousepad', 'food_noodles', 'couch', 'closetdrawer', 'food_jam', 'form', 'pillow', 'wall', 'nightstand', 'razor', 'television', 'shaving_cream', 'kitchen_counter', 'bathroom_cabinet', 'dishwasher', 'soap', 'teeth']
Task:Text friends while sitting on couch
response:
{
"thoughts": Text while sitting,
"actions": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[TOUCH] <phone>']
}
|
Scene_Objects:['fork', 'blow_dryer', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'kitchen_cabinet', 'floor', 'phone', 'desk', 'computer', 'laptop', 'plate', 'stereo', 'oil', 'clothes_hat', 'wall', 'bench', 'oven', 'powersocket', 'newspaper', 'coffe_maker', 'curtain', 'rag', 'kitchen_counter', 'maindoor', 'home_office', 'table', 'light', 'soap']
Task:Set up table
response:
| {
"thoughts": "Walk into kitchen. Grab plates and forks. Walk into dining room. Put plates and forks on table.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <kitchen_cabinet>",
"[FIND] <kitchen_cabinet>",
"[OPEN] <kitchen_cabinet>",
"[FIND] <fork>",
"[GRAB] <fork>",
"[FIND] <plate>",
"[GRAB] <plate>",
"[WALK] <dining_room>",
"[WALK] <table>",
"[FIND] <table>",
"[PUTBACK] <fork> <table>",
"[PUTBACK] <plate> <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:['fork', 'filing_cabinet', 'chair', 'drawing', 'bills', 'knife', 'floor', 'ceilinglamp', 'stereo', 'window', 'couch', 'food_jam', 'form', 'towel', 'dining_room', 'wall', 'basket_for_clothes', 'photoframe', 'novel', 'food_food', 'check', 'television', 'oven_mitts', 'razor', 'tray', 'pencil', 'dresser', 'pajamas', 'table', 'soap']
Task:Read book
response:
{
"thoughts": Sit and read,
"actions": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[WALK] <couch>', '[SIT] <couch>', '[READ] <novel>']
}
|
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>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
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:['sheets', 'food_pizza', 'tablelamp', 'blender', 'scissors', 'freezer', 'walllamp', 'ground_coffee', 'orchid', 'character', 'bedroom', 'bookshelf', 'alcohol', 'button', 'toaster', 'stereo', 'homework', 'electric_shaver', 'mousepad', 'couch', 'bowl', 'toy', 'clothes_gloves', 'coffe_maker', 'kitchen_counter', 'conditioner', 'napkin', 'table', 'light', 'dishwasher']
Task:Listen to music
response:
| {
"thoughts": "Walk into living room, look for radio, grab on button",
"actions": [
"[WALK] <home_office>",
"[WALK] <stereo>",
"[FIND] <stereo>",
"[TURNTO] <stereo>",
"[LOOKAT] <stereo>",
"[FIND] <button>",
"[GRAB] <button>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'ground_coffee', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'keyboard', 'mail', 'mat', 'faucet', 'wall', 'nightstand', 'powersocket', 'oven', 'cup', 'photoframe', 'bed', 'novel', 'curtain', 'doorjamb', 'diary', 'cupboard', 'door', 'sink', 'instrument_guitar']
Task:Read book
response:
{
"thoughts": Walk over to the bookshelf. Pick storybook off the shelf. Sit on bed. Open storybook and read out loud.,
"actions": ['[WALK] <bedroom>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[WALK] <bed>', '[SIT] <bed>', '[READ] <novel>']
}
|
Scene_Objects:['pot', 'ground_coffee', 'walllamp', 'detergent', 'knifeblock', 'longboard', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'faucet', 'candle', 'wall', 'box', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'towel_rack', 'kitchen_counter', 'chessboard', 'cupboard', 'hair', 'maindoor', 'sink', 'napkin', 'dishwasher', 'tooth_paste']
Task:Make coffee
response:
| {
"thoughts": "I walk to the kitchen and find the coffee machine. I open the coffee machine and pour a filter in it. I open the cupboard and grab ground coffee. I put ground coffee in the filter and water in the coffee machine. I close the coffee machine. I switch on the coffee machine and wait",
"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] <cupboard>",
"[OPEN] <cupboard>",
"[FIND] <ground_coffee>",
"[GRAB] <ground_coffee>",
"[PUTBACK] <ground_coffee> <coffe_maker>",
"[WALK] <water>",
"[FIND] <water>",
"[GRAB] <water>",
"[POUR] <water> <coffe_maker>",
"[CLOSE] <coffe_maker>",
"[SWITCHON] <coffe_maker>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_socks', 'closetdrawer', 'mousepad', 'clothes_pants', 'wall', 'powersocket', 'oven', 'cup', 'newspaper', 'food_food', 'check', 'coffe_maker', 'shaving_cream', 'mouse', 'pencil', 'shoes', 'dresser', 'hair', 'conditioner', 'light', 'clothes_shirt', 'shoe_rack']
Task:Get dressed
response:
{
"thoughts": Open drawer. Pull out pants and put them on. Take a shirt out and put it on. Put on socks and shoes.,
"actions": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTON] <clothes_pants>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTON] <clothes_shirt>', '[FIND] <clothes_socks>', '[GRAB] <clothes_socks>', '[PUTON] <clothes_socks>', '[CLOSE] <dresser>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']
}
|
Scene_Objects:['microwave', 'walllamp', 'bathroom', 'food_carrot', 'toothbrush', 'orchid', 'knife', 'longboard', 'character', 'bedroom', 'computer', 'faucet', 'homework', 'clothes_socks', 'food_noodles', 'dining_room', 'photoframe', 'check', 'television', 'after_shave', 'rag', 'lighter', 'towel_rack', 'kitchen_counter', 'dresser', 'clothes_dress', 'home_office', 'light', 'laser_pointer', 'scrabble']
Task:Pick up phone
response:
| {
"thoughts": "I walk to the home office. I find the telephone. I pick up the telephone handset.",
"actions": [
"[WALK] <home_office>",
"[WALK] <phone>",
"[FIND] <phone>",
"[GRAB] <phone>"
]
} |
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.
Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'pot', 'mop', 'band-aids', 'walllamp', 'trashcan', 'ceilingfan', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'bathroom_counter', 'desk', 'computer', 'stovefan', 'toaster', 'deck_of_cards', 'shower', 'wall', 'pasta', 'oven', 'cup', 'water', 'tray', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'sauce_pan', 'cupboard', 'dishwasher']
Task:Cook some food
response:
{
"thoughts": Cook some pasta on the stove,
"actions": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pasta>', '[GRAB] <pasta>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <sauce_pan>', '[POUR] <water> <sauce_pan>', '[FIND] <oven>', '[SWITCHON] <oven>', '[PUTBACK] <pasta> <sauce_pan>', '[FIND] <sauce_pan>', '[GRAB] <sauce_pan>', '[PUTBACK] <sauce_pan> <oven>']
}
|
Scene_Objects:['tablelamp', 'food_ice_cream', 'freezer', 'cat', 'knifeblock', 'longboard', 'floor', 'ceiling', 'keyboard', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'mat', 'stereo', 'tvstand', 'electric_shaver', 'mousepad', 'couch', 'wall', 'oven', 'bench', 'cup', 'food_food', 'doorjamb', 'conditioner', 'clothes_scarf', 'home_office', 'table', 'light', 'vase']
Task:Put groceries in Fridge
response:
| {
"thoughts": "I get my groceries and go to the fridge. I open the fridge and put the groceries there.",
"actions": [
"[WALK] <dining_room>",
"[WALK] <food_food>",
"[FIND] <food_food>",
"[GRAB] <food_food>",
"[FIND] <freezer>",
"[OPEN] <freezer>",
"[PUTIN] <food_food> <freezer>",
"[CLOSE] <freezer>"
]
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.