{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'wine', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'light', 'table', 'clothes_skirt']\nTask:Write an email\nresponse:\n{\n    \"thoughts\": enter office, find computer, turn it on,,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TOUCH] <keyboard>', '[TYPE] <keyboard>']\n}\n", "input": "\nScene_Objects:['sheets', 'toilet', 'freezer', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'button', 'bookmark', 'ceilinglamp', 'window', 'couch', 'microphone', 'pillow', 'wall', 'pasta', 'tape', 'box', 'novel', 'curtain', 'doorjamb', 'hairbrush', 'door', 'home_office', 'table', 'bathroom_cabinet', 'soap', 'tooth_paste', 'clothes_shirt']\nTask:Text friends while sitting on couch\nresponse:\n", "output": {"thoughts": "Text while sitting", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[GRAB] <phone>", "[WALK] <couch>", "[SIT] <couch>", "[TURNTO] <phone>", "[LOOKAT] <phone>", "[TOUCH] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'couch', 'candle', 'clothes_hat', 'pillow', 'wall', 'oven', 'coffe_maker', 'television', 'curtain', 'diary', 'towel_rack', 'mouse', 'dishrack', 'home_office', 'table']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": I walk to the living room. I see the couch.  I sit down on the couch, then lie down and put my feet up.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[LIE] <couch>']\n}\n", "input": "\nScene_Objects:['sponge', 'food_pizza', 'juice', 'crayon', 'blow_dryer', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'mat', 'tvstand', 'faucet', 'wall', 'powersocket', 'bench', 'tape', 'photoframe', 'clothes_gloves', 'food_donut', 'after_shave', 'doorjamb', 'dishrack', 'door', 'sink', 'bathroom_cabinet', 'soap']\nTask:Clean sink\nresponse:\n", "output": {"thoughts": "Take a premoistened cleaning wipe and wipe down top of sink and faucet.  Next clean the sink bowl.  Let air dry.", "actions": ["[WALK] <bathroom>", "[WALK] <rag>", "[FIND] <rag>", "[GRAB] <rag>", "[WALK] <sink>", "[FIND] <faucet>", "[WIPE] <faucet>", "[WIPE] <sink>", "[PUTOBJBACK] <rag>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'scissors', 'crayon', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'bookmark', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'window', 'homework', 'couch', 'wall', 'child', 'bench', 'photoframe', 'newspaper', 'coffe_maker', 'razor', 'television', 'kitchen_counter', 'cupboard', 'table', 'coffee']\nTask:Let baby learn how to walk\nresponse:\n{\n    \"thoughts\": The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[GREET] <child>', '[FIND] <couch>', '[TURNTO] <couch>', '[POINTAT] <couch>', '[TURNTO] <child>', '[LOOKAT] <child>']\n}\n", "input": "\nScene_Objects:['food_salt', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'ceiling', 'character', 'toaster', 'ceilinglamp', 'tvstand', 'stereo', 'deck_of_cards', 'oil', 'wall', 'bench', 'powersocket', 'novel', 'coffe_maker', 'food_food', 'television', 'tray', 'rag', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'scrabble']\nTask:Make popcorn\nresponse:\n", "output": {"thoughts": "Lay popcorn bag flat inside microwave and press popcorn button to start.", "actions": ["[WALK] <dining_room>", "[WALK] <food_food>", "[FIND] <food_food>", "[GRAB] <food_food>", "[WALK] <microwave>", "[TURNTO] <microwave>", "[OPEN] <microwave>", "[PUTIN] <food_food> <microwave>", "[CLOSE] <microwave>", "[SWITCHON] <microwave>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'chair', 'walllamp', 'detergent', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'bathroom_counter', 'phone', 'folder', 'man', 'keyboard', 'mop_bucket', 'tvstand', 'faucet', 'picture', 'plate', 'mousepad', 'bench', 'oven', 'powersocket', 'photoframe', 'food_food', 'check', 'food_onion', 'clothes_scarf', 'spoon', 'light', 'dishwasher']\nTask:Greet guests\nresponse:\n{\n    \"thoughts\": When someone knocks I n the door walk through the hallway and greet them.,\n    \"actions\": ['[RUN] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'chair', 'freezer', 'walllamp', 'food_butter', 'toothbrush', 'knifeblock', 'floor', 'character', 'bookshelf', 'food_cake', 'mat', 'shoe-shine_kit', 'shower', 'mousepad', 'couch', 'microphone', 'cup', 'newspaper', 'mouthwash', 'television', 'coffee_filter', 'food_donut', 'console', 'kitchen_counter', 'headset', 'dresser', 'cupboard', 'clothes_dress', 'home_office']\nTask:Answer door\nresponse:\n", "output": {"thoughts": "Wait until doorbell rings, look to see who it is outside and open the door if you feel so inclined.", "actions": ["[WALK] <home_office>", "[WALK] <man>", "[FIND] <man>", "[GREET] <man>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Grab book.  Read it.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <dresser>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['fork', 'tablelamp', 'microwave', 'jelly', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'character', 'table_cloth', 'toaster', 'stovefan', 'mat', 'iron', 'pillow', 'dining_room', 'wall', 'powersocket', 'cup', 'photoframe', 'coffe_maker', 'television', 'pencil', 'kitchen_counter', 'hairbrush', 'cupboard', 'door', 'dishwasher', 'clothes_skirt']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Making coffee", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'scissors', 'beer', 'microwave', 'bathroom', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'toaster', 'brush', 'plate', 'shower', 'clothes_socks', 'dining_room', 'wall', 'powersocket', 'tape', 'box', 'cup', 'coffe_maker', 'food_food', 'doorjamb', 'centerpiece', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['beer', 'walllamp', 'drawing', 'orchid', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'couch', 'candle', 'pillow', 'wall', 'nightstand', 'powersocket', 'keys', 'television', 'curtain', 'doorjamb', 'door', 'sink', 'table']\nTask:Watch movie\nresponse:\n", "output": {"thoughts": "Sit down on couch in front of TV.  Use remote to turn on the TV", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'food_pizza', 'ground_coffee', 'walllamp', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'character', 'computer', 'piano_bench', 'stovefan', 'toaster', 'tvstand', 'faucet', 'oil', 'pillow', 'wall', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'after_shave', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'dishwasher']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Get my coffee pot going,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <coffee_pot>', '[FIND] <coffee_pot>', '[GRAB] <coffee_pot>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffee_pot>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffee_pot>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <oven>', '[PUTBACK] <coffee_pot> <oven>', '[SWITCHON] <oven>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'jelly', 'freezer', 'walllamp', 'ground_coffee', 'knife', 'knifeblock', 'cpuscreen', 'orchid', 'needle', 'floor', 'ceiling', 'desk', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'clothes_hat', 'wall', 'oven', 'cup', 'food_food', 'toothbrush_holder', 'tray', 'rag', 'kitchen_counter', 'cupboard', 'sink', 'bag']\nTask:Clean\nresponse:\n", "output": {"thoughts": "Take out a rag. Turn on faucet and get water on the rag. Clean counter off.", "actions": ["[WALK] <dining_room>", "[WALK] <rag>", "[FIND] <rag>", "[GRAB] <rag>", "[WALK] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[PUTBACK] <rag> <sink>", "[SWITCHOFF] <faucet>", "[GRAB] <rag>", "[SQUEEZE] <rag>", "[WALK] <kitchen_counter>", "[WIPE] <kitchen_counter>", "[PUTOBJBACK] <rag>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'pot', 'food_pizza', 'food_salt', 'freezer', 'drawing', 'knife', 'cpuscreen', 'knifeblock', 'floor', 'character', 'bookshelf', 'laptop', 'plate', 'mousepad', 'candle', 'dining_room', 'wall', 'light_bulb', 'food_food', 'coffe_maker', 'tray', 'kitchen_counter', 'chessboard', 'dishrack', 'shoes', 'cupboard', 'laundry_detergent', 'dishwasher', 'instrument_violin']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'measuring_cup', 'walllamp', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'face', 'computer', 'bookmark', 'mat', 'faucet', 'mousepad', 'clothes_hat', 'towel', 'dining_room', 'wall', 'wall_clock', 'nightstand', 'face_soap', 'basket_for_clothes', 'newspaper', 'tray', 'rag', 'mouse', 'dishrack', 'sink', 'bathroom_cabinet']\nTask:Wash face\nresponse:\n", "output": {"thoughts": "Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel.", "actions": ["[WALK] <bathroom>", "[WALK] <sink>", "[FIND] <rag>", "[GRAB] <rag>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[WASH] <rag>", "[FIND] <face_soap>", "[GRAB] <face_soap>", "[POUR] <face_soap> <rag>", "[PUTOBJBACK] <face_soap>", "[FIND] <face>", "[SCRUB] <face>", "[PUTBACK] <rag> <sink>", "[RINSE] <face>", "[RINSE] <rag>", "[SWITCHOFF] <faucet>", "[GRAB] <rag>", "[PUTOBJBACK] <rag>", "[FIND] <towel>", "[GRAB] <towel>", "[WIPE] <face>", "[PUTOBJBACK] <towel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'detergent', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'folder', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'tvstand', 'shower', 'homework', 'oil', 'dustpan', 'dining_room', 'wall', 'powersocket', 'bench', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'home_office', 'light']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": Walk into the bedroom and walk to the light switch. Flip the switch.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['fork', 'pot', 'tablelamp', 'microwave', 'dog', 'walllamp', 'trashcan', 'knifeblock', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'faucet', 'ceilinglamp', 'oil', 'wall', 'oven', 'coffe_maker', 'drinking_glass', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'bag', 'dishwasher', 'colander']\nTask:Unload dishwasher\nresponse:\n", "output": {"thoughts": "Open the dishwasher door. Take out all of the dishes and silverware. Put the dishes and silverware in their drawers and cabinets. Close the dishwasher door.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[FIND] <drinking_glass>", "[GRAB] <drinking_glass>", "[FIND] <cupboard>", "[OPEN] <cupboard>", "[PUTBACK] <drinking_glass> <cupboard>", "[FIND] <fork>", "[GRAB] <fork>", "[FIND] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[PUTIN] <fork> <kitchen_cabinet>", "[FIND] <knife>", "[GRAB] <knife>", "[PUTIN] <knife> <kitchen_cabinet>", "[FIND] <spoon>", "[GRAB] <spoon>", "[PUTIN] <spoon> <kitchen_cabinet>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTIN] <plate> <kitchen_cabinet>", "[CLOSE] <kitchen_cabinet>", "[CLOSE] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'towel', 'dining_room', 'wall', 'wall_clock', 'oven', 'coffe_maker', 'food_food', 'curtain', 'kitchen_counter', 'cupboard', 'food_steak', 'sink']\nTask:Wash dishes by hand\nresponse:\n{\n    \"thoughts\": Walk to Kitchen, find sink, find dishes and dish soap. Put soap on plate. open faucet, rinse dishes close faucet.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <plate>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <plate>']\n}\n", "input": "\nScene_Objects:['chair', 'walllamp', 'cat', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'bookmark', 'mat', 'ceilinglamp', 'food_noodles', 'mousepad', 'wall', 'oven', 'check', 'video_game_controller', 'television', 'oven_mitts', 'after_shave', 'food_onion', 'centerpiece', 'mouse', 'door', 'table', 'coffee']\nTask:Use computer\nresponse:\n", "output": {"thoughts": "Sit at my desk and grade papers on my computer", "actions": ["[WALK] <home_office>", "[WALK] <chair>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <computer>", "[SWITCHON] <computer>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'jelly', 'freezer', 'food_carrot', 'drawing', 'floor', 'ceiling', 'desk', 'envelope', 'table_cloth', 'mat', 'faucet', 'mousepad', 'couch', 'pillow', 'towel', 'wall', 'cup', 'food_food', 'mouthwash', 'television', 'water', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'food_steak', 'light', 'dishwasher', 'table']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Walk into kitchen, look for cup, walk to cup, look for refrigerator, walk to refrigerator, open door, grab water, pour water into cup,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[TURNTO] <cup>', '[LOOKAT] <cup>', '[WALK] <cup>', '[FIND] <freezer>', '[TURNTO] <freezer>', '[LOOKAT] <freezer>', '[WALK] <freezer>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>']\n}\n", "input": "\nScene_Objects:['food_carrot', 'milk', 'dough', 'knifeblock', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bedroom', 'mat', 'faucet', 'shower', 'stereo', 'towel', 'pillow', 'wall', 'bench', 'cup', 'bed', 'photoframe', 'coffe_maker', 'wooden_spoon', 'after_shave', 'rag', 'mouse', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n", "output": {"thoughts": "Turn on the water faucet. Wet my hands and turn off the faucet. Put soap on my hands. Rub hands together, making sure the soap covers all areas of the hands. Scrub hands for about 20 seconds. Turn on the water water faucet. Rinse hands under the running water. Turn off the water faucet. Dry hands with a towel.", "actions": ["[WALK] <bathroom>", "[WALK] <sink>", "[FIND] <sink>", "[TURNTO] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <hands_both>", "[WASH] <hands_both>", "[FIND] <soap>", "[GRAB] <soap>", "[SCRUB] <hands_both>", "[PUTOBJBACK] <soap>", "[RINSE] <hands_both>", "[SWITCHOFF] <faucet>", "[FIND] <towel>", "[GRAB] <towel>", "[WIPE] <hands_both>", "[PUTOBJBACK] <towel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_ice_cream', 'microwave', 'toilet', 'chair', 'knifeblock', 'hanger', 'floor', 'toaster', 'stovefan', 'shoe-shine_kit', 'faucet', 'homework', 'food_noodles', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'cup', 'newspaper', 'coffee_filter', 'food_rice', 'console', 'mouse', 'kitchen_counter', 'dishrack', 'comb', 'cupboard', 'door', 'sink']\nTask:Drink\nresponse:\n{\n    \"thoughts\": go to the kitchen, walk to the cabinet, pic up a glass. carry the glass to the sink. turn on the water and fill up the glass. drink the water.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['mop', 'freezer', 'trashcan', 'milk', 'knifeblock', 'orchid', 'clothes_underwear', 'bookshelf', 'purse', 'thread', 'computer', 'ceilinglamp', 'tvstand', 'iron', 'couch', 'microphone', 'wall', 'cutting_board', 'basket_for_clothes', 'keys', 'toothbrush_holder', 'oven_mitts', 'curtain', 'doorjamb', 'diary', 'chessboard', 'home_office', 'bathroom_cabinet', 'clothes_skirt', 'light']\nTask:Hang up car keys\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'chair', 'drawing', 'hanger', 'floor', 'phone', 'ceilinglamp', 'plate', 'iron', 'candle', 'pillow', 'wall', 'bench', 'powersocket', 'oven', 'food_food', 'video_game_controller', 'check', 'wooden_spoon', 'after_shave', 'doorjamb', 'shoes', 'dresser', 'cupboard', 'clothes_dress', 'door', 'conditioner', 'sink', 'table', 'light']\nTask:Eat dinner\nresponse:\n{\n    \"thoughts\": Put food on the table, sit down, and eat the food.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <plate> <table>', '[FIND] <chair>', '[SIT] <chair>', '[EAT] <plate>']\n}\n", "input": "\nScene_Objects:['walllamp', 'food_carrot', 'drawing', 'orchid', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'microphone', 'pillow', 'wall', 'wall_clock', 'photoframe', 'television', 'toothbrush_holder', 'food_donut', 'doorjamb', 'shaving_cream', 'mouse', 'door', 'sink', 'clothes_scarf', 'napkin', 'table']\nTask:Straighten pictures on wall\nresponse:\n", "output": {"thoughts": "Move the pictures/paintings until they are straight.", "actions": ["[WALK] <home_office>", "[WALK] <drawing>", "[FIND] <drawing>", "[TURNTO] <drawing>", "[LOOKAT] <drawing>", "[TOUCH] <drawing>", "[PUSH] <drawing>", "[FIND] <drawing>", "[TURNTO] <drawing>", "[LOOKAT] <drawing>", "[TOUCH] <drawing>", "[PUSH] <drawing>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'pot', 'food_pizza', 'dry_pasta', 'walllamp', 'trashcan', 'food_carrot', 'dough', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'wall', 'wall_clock', 'oven', 'food_cheese', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'cupboard', 'home_office', 'table', 'dishwasher']\nTask:Keep an eye on stove as something is cooking\nresponse:\n{\n    \"thoughts\": Watch whatever is cooking on the stove so it doesn't burn or pour. Turn off heat when done,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <oven>', '[FIND] <pot>', '[TURNTO] <pot>', '[LOOKAT] <pot>', '[FIND] <wall_clock>', '[TURNTO] <wall_clock>', '[LOOKAT] <wall_clock>', '[SWITCHOFF] <oven>']\n}\n", "input": "\nScene_Objects:['food_ice_cream', 'measuring_cup', 'freezer', 'nail_polish', 'food_carrot', 'drawing', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'plate', 'mat', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'powersocket', 'bench', 'food_vegetable', 'food_food', 'doorjamb', 'mouse', 'door', 'light', 'table', 'scrabble']\nTask:Fix snack\nresponse:\n", "output": {"thoughts": "Open fridge. Take out carrots and other vegetables. Put vegetables on a plate. Put away carrots and celery. Close fridge.", "actions": ["[WALK] <dining_room>", "[WALK] <kitchen_cabinet>", "[FIND] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[FIND] <plate>", "[GRAB] <plate>", "[CLOSE] <kitchen_cabinet>", "[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <food_carrot>", "[GRAB] <food_carrot>", "[PUTBACK] <food_carrot> <plate>", "[FIND] <food_vegetable>", "[GRAB] <food_vegetable>", "[PUTBACK] <food_vegetable> <plate>", "[CLOSE] <freezer>", "[WALK] <table>", "[PUTBACK] <plate> <table>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'food_salt', 'measuring_cup', 'toilet', 'jelly', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'alcohol', 'mat', 'shower', 'foundation', 'electric_shaver', 'mousepad', 'wall', 'toy', 'basket_for_clothes', 'photoframe', 'wine', 'dresser', 'laundry_detergent', 'food_steak', 'door', 'napkin', 'bathroom_cabinet', 'dishwasher']\nTask:Pick up toys\nresponse:\n{\n    \"thoughts\": Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <toy>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <dresser>', '[OPEN] <dresser>', '[PUTBACK] <toy> <dresser>', '[CLOSE] <dresser>', '[FIND] <toy>', '[GRAB] <toy>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[PUTBACK] <toy> <filing_cabinet>', '[CLOSE] <filing_cabinet>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'sheets', 'pot', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mail', 'tvstand', 'stereo', 'window', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'powersocket', 'pasta', 'oven', 'light_bulb', 'coffe_maker', 'food_rice', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'door', 'light']\nTask:Turn light off\nresponse:\n", "output": {"thoughts": "Put the light switch into the down, or off, position.", "actions": ["[WALK] <dining_room>", "[WALK] <light>", "[FIND] <light>", "[SWITCHOFF] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Put groceries in Fridge\nresponse:\n{\n    \"thoughts\": Put the groceries on the table into the fridge,\n    \"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>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'walllamp', 'dough', 'drawing', 'orchid', 'needle', 'floor', 'ceiling', 'desk', 'bookshelf', 'computer', 'bookmark', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'couch', 'pillow', 'food_kiwi', 'wall', 'oven', 'photoframe', 'novel', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office', 'table']\nTask:Admire art\nresponse:\n", "output": {"thoughts": "Looking at painting, art", "actions": ["[WALK] <home_office>", "[WALK] <drawing>", "[TURNTO] <drawing>", "[LOOKAT] <drawing>", "[FIND] <drawing>", "[TURNTO] <drawing>", "[LOOKAT] <drawing>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tea', 'microwave', 'toilet', 'jelly', 'bathroom_counter', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'food_noodles', 'clothes_socks', 'mousepad', 'closetdrawer', 'food_kiwi', 'wall', 'cutting_board', 'cup', 'coffe_maker', 'toothbrush_holder', 'television', 'oven_mitts', 'water', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'home_office', 'soap', 'tooth_paste']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Walk to kitchen, walk to cupboard, open cupboard, grab cup, walk to sink, pour water in cup, drink water.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'chair', 'dough', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'homework', 'mousepad', 'towel', 'wall', 'nightstand', 'bed', 'novel', 'coffe_maker', 'toothbrush_holder', 'ice', 'diary', 'kettle', 'mouse', 'door', 'spoon', 'instrument_violin']\nTask:Study\nresponse:\n", "output": {"thoughts": "Do homework or read books while sitting on the chair.", "actions": ["[WALK] <bedroom>", "[WALK] <chair>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <novel>", "[GRAB] <novel>", "[READ] <novel>", "[PUTOBJBACK] <novel>", "[FIND] <novel>", "[GRAB] <novel>", "[READ] <novel>", "[PUTOBJBACK] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['measuring_cup', 'chair', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'longboard', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'window', 'mousepad', 'couch', 'wall', 'powersocket', 'bed', 'curtain', 'doorjamb', 'shaving_cream', 'mouse', 'comb', 'door', 'napkin', 'table', 'light']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": I turn on computer. I use keyboard to type. I open browser. I search.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']\n}\n", "input": "\nScene_Objects:['microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'video_game_console', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'candle', 'broom', 'wall', 'powersocket', 'check', 'video_game_controller', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'hairbrush', 'door', 'table', 'dishwasher', 'dirt']\nTask:Play games\nresponse:\n", "output": {"thoughts": "Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video  game remote controller.", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[SWITCHON] <television>", "[FIND] <video_game_console>", "[SWITCHON] <video_game_console>", "[FIND] <video_game_controller>", "[GRAB] <video_game_controller>", "[FIND] <button>", "[PUSH] <button>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'food_salt', 'chair', 'bathroom', 'drawing', 'food_egg', 'floor', 'desk', 'bookshelf', 'computer', 'mat', 'stereo', 'shower', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'pajamas', 'controller', 'door', 'clothes_scarf', 'light', 'dishwasher', 'board_game']\nTask:Pull up carpet\nresponse:\n{\n    \"thoughts\": Pry up a corner of your old dirty carpet.  Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <mat>', '[FIND] <mat>', '[TOUCH] <mat>', '[PULL] <mat>']\n}\n", "input": "\nScene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'band-aids', 'cat', 'food_carrot', 'knife', 'foundation', 'electric_shaver', 'mousepad', 'clothes_socks', 'pillow', 'dining_room', 'nightstand', 'oven', 'toy', 'check', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'chessboard', 'cupboard', 'conditioner', 'door', 'food_steak', 'clothes_skirt', 'duster']\nTask:Dust\nresponse:\n", "output": {"thoughts": "Get a broom or duster with long handle. Dust blades of ceiling fan.", "actions": ["[WALK] <bedroom>", "[WALK] <duster>", "[FIND] <duster>", "[GRAB] <duster>", "[PUTOBJBACK] <duster>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'toilet', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'character', 'video_game_console', 'bedroom', 'computer', 'button', 'table_cloth', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'box', 'video_game_controller', 'television', 'curtain', 'pencil', 'dresser', 'door', 'table']\nTask:Play games\nresponse:\n{\n    \"thoughts\": Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video  game remote controller.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['sheets', 'blender', 'toilet', 'walllamp', 'cat', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'toy', 'cup', 'bed', 'keys', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'door', 'table', 'shoe_rack']\nTask:Watch  TV\nresponse:\n", "output": {"thoughts": "Sit on my couch  directly opposite  my tv , switch  on my tv with the  remote control  and watch", "actions": ["[WALK] <home_office>", "[WALK] <remote_control>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[WALK] <couch>", "[SIT] <couch>", "[TOUCH] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'glue', 'tablelamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'clothes_jacket', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'bed', 'novel', 'mouse', 'shoes', 'dresser', 'clothes_dress', 'light', 'table']\nTask:Get ready for day\nresponse:\n{\n    \"thoughts\": Grab shoes, purse etc and head out the door!,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <purse>', '[GRAB] <purse>', '[CLOSE] <dresser>', '[WALK] <home_office>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'drawing', 'needle', 'knife', 'clothes_underwear', 'hanger', 'floor', 'envelope', 'computer', 'ceilinglamp', 'oil', 'mousepad', 'pillow', 'bowl', 'wall', 'nightstand', 'child', 'bed', 'novel', 'food_food', 'coffe_maker', 'television', 'doorjamb', 'dishrack', 'comb', 'laundry_detergent', 'conditioner', 'sink', 'instrument_violin']\nTask:Story reading time\nresponse:\n", "output": {"thoughts": "Sit on bed with child, open mother goose, pick story, read book, point at the pretty pictures", "actions": ["[WALK] <bedroom>", "[WALK] <child>", "[FIND] <child>", "[GREET] <child>", "[FIND] <novel>", "[GRAB] <novel>", "[FIND] <bed>", "[SIT] <bed>", "[TURNTO] <child>", "[LOOKAT] <child>", "[TURNTO] <novel>", "[POINTAT] <novel>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'envelope', 'computer', 'mop_bucket', 'stovefan', 'mat', 'tvstand', 'toaster', 'foundation', 'mousepad', 'pillow', 'wall', 'standingmirror', 'photoframe', 'toilet_paper', 'oven_mitts', 'tray', 'mouse', 'sink']\nTask:Read book\nresponse:\n{\n    \"thoughts\": go to living room,find the text book on the self ,sat on the chair ,open and read the book,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['sponge', 'pot', 'filing_cabinet', 'microwave', 'walllamp', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'piano_bench', 'mat', 'tvstand', 'faucet', 'shower', 'homework', 'clothes_socks', 'broom', 'wall', 'bench', 'cup', 'rag', 'kitchen_counter', 'laundry_detergent', 'door', 'sink', 'bathroom_cabinet', 'tooth_paste']\nTask:Wipe down sink\nresponse:\n", "output": {"thoughts": "Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well.", "actions": ["[WALK] <bathroom>", "[WALK] <bathroom_cabinet>", "[OPEN] <bathroom_cabinet>", "[FIND] <rag>", "[GRAB] <rag>", "[WALK] <sink>", "[WIPE] <sink>", "[PUTOBJBACK] <rag>", "[CLOSE] <bathroom_cabinet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'spectacles', 'pot', 'microwave', 'knifeblock', 'floor', 'ceiling', 'folder', 'character', 'toaster', 'plate', 'drying_rack', 'faucet', 'dish_soap', 'couch', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'hairdryer', 'light', 'dirt', 'coffee']\nTask:Wash dishes by hand\nresponse:\n{\n    \"thoughts\": I walk in to the Kitchen. I find a plate, a sponge, and the dish soap. I find the faucet. I turn the faucet on. I pour water on the sponge and plate. I add dish soap to the sponge. I put the dish soap back. I scrub the plate. I rinse the plate. I place the plate on the drying rack. I rinse the sponge. I turn the faucet off.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <sponge>', '[GRAB] <sponge>', '[RINSE] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[FIND] <drying_rack>', '[PUTBACK] <plate> <plate>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']\n}\n", "input": "\nScene_Objects:['glue', 'microwave', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'purse', 'mail', 'ceilinglamp', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'bed', 'light_bulb', 'check', 'food_food', 'curtain', 'kitchen_counter', 'chessboard', 'dishrack', 'dresser', 'laundry_detergent', 'door', 'light', 'shoe_rack']\nTask:Open window\nresponse:\n", "output": {"thoughts": "Unlock the latch at the top. Push the bottom half of the window upwards.", "actions": ["[WALK] <home_office>", "[WALK] <window>", "[OPEN] <window>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['scissors', 'dog', 'walllamp', 'clothes_underwear', 'bathroom_counter', 'phone', 'character', 'desk', 'tea_bag', 'envelope', 'toaster', 'ceilinglamp', 'window', 'mousepad', 'food_kiwi', 'nightstand', 'cutting_board', 'photoframe', 'coffe_maker', 'television', 'tray', 'rag', 'doorjamb', 'diary', 'cupboard', 'hairdryer', 'home_office', 'light', 'table', 'creditcard']\nTask:Receive credit card\nresponse:\n{\n    \"thoughts\": hear the dooble, go to door, take de envelope, open it with a scissor, take the creditcard,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <envelope>', '[FIND] <envelope>', '[GRAB] <envelope>', '[WALK] <home_office>', '[WALK] <scissors>', '[FIND] <scissors>', '[OPEN] <envelope>', '[FIND] <creditcard>', '[GRAB] <creditcard>']\n}\n", "input": "\nScene_Objects:['sheets', 'toilet', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'bathroom_counter', 'purse', 'alcohol', 'bookmark', 'stovefan', 'toaster', 'stereo', 'food_jam', 'dining_room', 'powersocket', 'food_food', 'mouthwash', 'tray', 'after_shave', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'cupboard', 'controller', 'hairdryer', 'sink', 'home_office', 'laser_pointer']\nTask:Walk through\nresponse:\n", "output": {"thoughts": "Walk through the hallway.", "actions": ["[WALK] <home_office>", "[WALK] <dining_room>", "[WALK] <home_office>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'trashcan', 'floor', 'tea_bag', 'thread', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'wall', 'bed', 'coffe_maker', 'food_food', 'check', 'oven_mitts', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'hairbrush', 'cupboard', 'hair', 'controller', 'bathroom_cabinet', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['spectacles', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'hanger', 'floor', 'ceiling', 'shampoo', 'bedroom', 'desk', 'envelope', 'table_cloth', 'bookmark', 'brush', 'toaster', 'window', 'couch', 'dustpan', 'food_jam', 'pillow', 'dining_room', 'wall', 'photoframe', 'check', 'tray', 'curtain', 'lighter', 'dresser', 'light']\nTask:Gaze out window\nresponse:\n", "output": {"thoughts": "Look at the yard from the window", "actions": ["[WALK] <home_office>", "[WALK] <window>", "[FIND] <window>", "[TURNTO] <window>", "[LOOKAT] <window>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'toilet', 'freezer', 'wallshelf', 'hanger', 'bathroom_counter', 'bookshelf', 'mail', 'brush', 'mat', 'shoe-shine_kit', 'homework', 'closetdrawer', 'couch', 'food_orange', 'towel', 'dining_room', 'wall', 'powersocket', 'box', 'novel', 'check', 'coffe_maker', 'tray', 'doorjamb', 'diary', 'cupboard', 'home_office', 'bathroom_cabinet', 'soap']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Pick up the book, open to current page, read the words.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['glue', 'chair', 'bathroom', 'detergent', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'purse', 'face', 'mat', 'tvstand', 'faucet', 'mousepad', 'wall', 'bench', 'face_soap', 'newspaper', 'novel', 'ice', 'curtain', 'doorjamb', 'chessboard', 'dresser', 'conditioner', 'sink', 'bathroom_cabinet', 'light', 'table']\nTask:Wash face\nresponse:\n", "output": {"thoughts": "Run warm water. Cleanse my face with soap. Rinse my face with water.", "actions": ["[WALK] <bathroom>", "[WALK] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <face_soap>", "[GRAB] <face_soap>", "[FIND] <face>", "[SCRUB] <face>", "[PUTOBJBACK] <face_soap>", "[WASH] <face>", "[RINSE] <face>", "[SWITCHOFF] <faucet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'walllamp', 'woman', 'drawing', 'phone', 'desk', 'man', 'toaster', 'laptop', 'mat', 'shower', 'electric_shaver', 'oil', 'form', 'pillow', 'dining_room', 'oven', 'shelf', 'bed', 'standingmirror', 'toothbrush_holder', 'tray', 'curtain', 'doorjamb', 'mouse', 'door', 'bathroom_cabinet', 'tooth_paste', 'scrabble']\nTask:Greet guests\nresponse:\n{\n    \"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.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']\n}\n", "input": "\nScene_Objects:['spectacles', 'pot', 'filing_cabinet', 'measuring_cup', 'walllamp', 'detergent', 'cat', 'milk', 'knifeblock', 'floor', 'ceiling', 'character', 'folder', 'bookshelf', 'piano_bench', 'table_cloth', 'faucet', 'window', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_cheese', 'bed', 'check', 'kitchen_counter', 'cupboard', 'sink', 'clothes_scarf', 'clothes_skirt']\nTask:Wipe down sink\nresponse:\n", "output": {"thoughts": "Use a cloth to wipe the edge of the sink. Then wipe the bowl of the sink as well.", "actions": ["[WALK] <dining_room>", "[WALK] <rag>", "[FIND] <rag>", "[GRAB] <rag>", "[WALK] <sink>", "[WIPE] <sink>", "[PUTOBJBACK] <rag>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'pot', 'food_pizza', 'tablelamp', 'mop', 'chair', 'freezer', 'walllamp', 'dough', 'drawing', 'knifeblock', 'wallshelf', 'orchid', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'stovefan', 'faucet', 'bowl', 'wall', 'oven', 'bench', 'toy', 'tray', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink']\nTask:Cook some food\nresponse:\n{\n    \"thoughts\": go to the kitchen and cook some thing to eat,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <oven>', '[OPEN] <oven>', '[FIND] <food_pizza>', '[GRAB] <food_pizza>', '[PUTIN] <food_pizza> <oven>', '[SWITCHON] <oven>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'scissors', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'faucet', 'mousepad', 'food_orange', 'wall', 'powersocket', 'wooden_spoon', 'after_shave', 'doorjamb', 'shaving_cream', 'mouse', 'door', 'table']\nTask:Computer work\nresponse:\n", "output": {"thoughts": "Find the computer, Turn on the computer, find keyboard, find mouse, go online", "actions": ["[WALK] <home_office>", "[WALK] <chair>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <computer>", "[SWITCHON] <computer>", "[FIND] <mouse>", "[GRAB] <mouse>", "[TURNTO] <computer>", "[POINTAT] <computer>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[PUTOBJBACK] <mouse>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'mop', 'toilet', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'floor', 'ceiling', 'computer', 'clothes_jacket', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'food_food', 'mouthwash', 'television', 'food_donut', 'curtain', 'after_shave', 'dresser', 'table']\nTask:Look at painting\nresponse:\n{\n    \"thoughts\": Walk to the painting.  Look up at the painting.  Admire it on the wall.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']\n}\n", "input": "\nScene_Objects:['walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_pants', 'form', 'pillow', 'towel', 'wall', 'powersocket', 'bench', 'newspaper', 'television', 'curtain', 'doorjamb', 'mouse', 'hair', 'door', 'bathroom_cabinet', 'table', 'dishwasher']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>", "[PUTOBJBACK] <remote_control>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'tablelamp', 'walllamp', 'cat', 'milk', 'orchid', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bookshelf', 'toaster', 'ceilinglamp', 'mat', 'stereo', 'picture', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'doorjamb', 'door', 'light', 'table']\nTask:Look at painting\nresponse:\n{\n    \"thoughts\": Walk to the painting.  Look up at the painting.  Admire it on the wall.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'chair', 'freezer', 'bathroom', 'food_butter', 'drawing', 'food_egg', 'floor', 'computer', 'mat', 'tvstand', 'stereo', 'laptop', 'clothes_pants', 'towel', 'wall', 'nightstand', 'tape', 'bed', 'food_food', 'coffe_maker', 'television', 'oven_mitts', 'tray', 'curtain', 'diary', 'cards', 'dishwasher']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "Turn on radio, put on favorite channel, listen to music.", "actions": ["[WALK] <bedroom>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>", "[FIND] <bed>", "[LIE] <bed>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'microwave', 'chair', 'trashcan', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'computer', 'table_cloth', 'tvstand', 'shower', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'photoframe', 'food_food', 'television', 'tray', 'doorjamb', 'cupboard', 'sink', 'bathroom_cabinet', 'light', 'board_game']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": walk into living room, walk to light, turn on light switch.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['food_bread', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'face', 'toaster', 'mat', 'faucet', 'foundation', 'mousepad', 'towel', 'dining_room', 'broom', 'wall', 'bowl', 'bench', 'face_soap', 'food_cheese', 'coin', 'water', 'after_shave', 'rag', 'curtain', 'mouse', 'conditioner', 'sink', 'napkin', 'bathroom_cabinet', 'hands_both']\nTask:Wash face\nresponse:\n", "output": {"thoughts": "Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel.", "actions": ["[WALK] <bathroom>", "[WALK] <rag>", "[FIND] <rag>", "[GRAB] <rag>", "[WALK] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[PUTBACK] <rag> <sink>", "[GRAB] <rag>", "[FIND] <face_soap>", "[GRAB] <face_soap>", "[POUR] <face_soap> <rag>", "[PUTOBJBACK] <face_soap>", "[FIND] <face>", "[SCRUB] <face>", "[PUTBACK] <rag> <sink>", "[FIND] <water>", "[GRAB] <water>", "[FIND] <hands_both>", "[POUR] <water> <hands_both>", "[RINSE] <face>", "[WASH] <rag>", "[GRAB] <rag>", "[PUTOBJBACK] <rag>", "[SWITCHOFF] <faucet>", "[FIND] <towel>", "[GRAB] <towel>", "[WIPE] <face>", "[PUTOBJBACK] <towel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'pot', 'filing_cabinet', 'tablelamp', 'freezer', 'bathroom', 'milk', 'drawing', 'floor', 'ceiling', 'bedroom', 'alcohol', 'computer', 'table_cloth', 'stovefan', 'mat', 'shower', 'oil', 'couch', 'pillow', 'wall', 'cutting_board', 'newspaper', 'food_food', 'television', 'kettle', 'kitchen_counter', 'cupboard', 'clothes_dress', 'shoe_rack']\nTask:Put groceries in Fridge\nresponse:\n{\n    \"thoughts\": Walk to kitchen. Find groceries. Grab groceries. Find fridge. Walk to fridge. Put groceries in fridge.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>']\n}\n", "input": "\nScene_Objects:['food_bread', 'food_ice_cream', 'freezer', 'milk', 'drawing', 'knife', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'dvd_player', 'stamp', 'desk', 'keyboard', 'computer', 'button', 'mat', 'plate', 'ceilinglamp', 'mousepad', 'candle', 'pillow', 'wall', 'bench', 'powersocket', 'cup', 'food_food', 'doorjamb', 'mouse', 'door', 'napkin', 'table', 'light']\nTask:Cut bread\nresponse:\n", "output": {"thoughts": "I get a slice of bread, grab a knife, and then cut the piece of bread in half.", "actions": ["[WALK] <dining_room>", "[WALK] <kitchen_cabinet>", "[FIND] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[FIND] <knife>", "[GRAB] <knife>", "[FIND] <plate>", "[GRAB] <plate>", "[CLOSE] <kitchen_cabinet>", "[FIND] <table>", "[PUTBACK] <plate> <table>", "[PUTBACK] <knife> <table>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_bread>", "[GRAB] <food_bread>", "[CLOSE] <freezer>", "[PUTBACK] <food_bread> <plate>", "[GRAB] <knife>", "[CUT] <food_bread>", "[PUTOBJBACK] <knife>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'tablelamp', 'food_ice_cream', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'bookshelf', 'computer', 'faucet', 'balanceball', 'window', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'nightstand', 'bench', 'powersocket', 'basket_for_clothes', 'novel', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'maindoor', 'sink', 'hairdryer']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": Enter the Home office, then walk to the phone, pickup the phone.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['pot', 'juice', 'jelly', 'freezer', 'walllamp', 'nail_polish', 'knifeblock', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'button', 'stovefan', 'ceilinglamp', 'mat', 'faucet', 'mousepad', 'pillow', 'wall', 'oven', 'powersocket', 'bench', 'cup', 'food_food', 'food_rice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'table', 'board_game']\nTask:Grab some juice\nresponse:\n", "output": {"thoughts": "I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass.", "actions": ["[WALK] <dining_room>", "[WALK] <cupboard>", "[FIND] <cupboard>", "[OPEN] <cupboard>", "[FIND] <cup>", "[GRAB] <cup>", "[CLOSE] <cupboard>", "[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <juice>", "[GRAB] <juice>", "[POUR] <juice> <cup>", "[PUTOBJBACK] <juice>", "[CLOSE] <freezer>", "[FIND] <table>", "[PUTBACK] <cup> <table>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'food_ice_cream', 'toilet', 'walllamp', 'dough', 'drawing', 'knifeblock', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'character', 'bedroom', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'basket_for_clothes', 'bed', 'food_food', 'television', 'doorjamb', 'mouse', 'pencil', 'dishrack', 'door', 'home_office', 'light', 'bathroom_cabinet']\nTask:Turn off light\nresponse:\n{\n    \"thoughts\": Grasp light switch, flip light switch.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[SWITCHOFF] <light>']\n}\n", "input": "\nScene_Objects:['pot', 'crayon', 'tea', 'beer', 'microwave', 'toilet', 'trashcan', 'food_carrot', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'bedroom', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'bed', 'photoframe', 'doorjamb', 'dishrack', 'cupboard', 'sink', 'home_office']\nTask:Open bathroom window\nresponse:\n", "output": {"thoughts": "Make sure bathroom window is unlocked. Lift up bathroom window so it is open.", "actions": ["[WALK] <bathroom>", "[WALK] <window>", "[FIND] <window>", "[OPEN] <window>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'bench', 'bed', 'coffe_maker', 'television', 'food_donut', 'doorjamb', 'mouse', 'door', 'table', 'shoe_rack']\nTask:Work\nresponse:\n{\n    \"thoughts\": Walk to living-room. Look at the desk where Computer stays. Sit in chair. Switch on computer. Work on computer. Switch off computer.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[TURNTO] <desk>', '[LOOKAT] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[WATCH] <computer>', '[SWITCHOFF] <computer>']\n}\n", "input": "\nScene_Objects:['pot', 'food_ice_cream', 'freezer', 'walllamp', 'milk', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'alcohol', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'wall', 'oven', 'powersocket', 'cup', 'ice', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']\nTask:Get something to drink\nresponse:\n", "output": {"thoughts": "Walk into the kitchen and to the cupboard to get a cup, walk to the fridge to look for a beverage to enjoy, open the freezer and get ice, pour beverage and enjoy", "actions": ["[WALK] <dining_room>", "[WALK] <cupboard>", "[FIND] <cupboard>", "[OPEN] <cupboard>", "[FIND] <cup>", "[GRAB] <cup>", "[CLOSE] <cupboard>", "[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <milk>", "[GRAB] <milk>", "[CLOSE] <freezer>", "[POUR] <milk> <cup>", "[DRINK] <cup>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['blender', 'freezer', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'brush', 'tvstand', 'stereo', 'window', 'closetdrawer', 'towel', 'wall', 'powersocket', 'tape', 'food_food', 'television', 'curtain', 'doorjamb', 'vacuum_cleaner', 'dresser', 'door', 'clothes_scarf', 'dishwasher', 'board_game']\nTask:vacuum carpet\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'chair', 'freezer', 'cat', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'folder', 'desk', 'keyboard', 'computer', 'faucet', 'stereo', 'mousepad', 'food_peanut_butter', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'check', 'toothbrush_holder', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'napkin', 'light']\nTask:Read\nresponse:\n", "output": {"thoughts": "I like to read books in my bedroom.", "actions": ["[WALK] <bedroom>", "[WALK] <desk>", "[FIND] <novel>", "[GRAB] <novel>", "[WALK] <bed>", "[LIE] <bed>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Pick up toys\nresponse:\n{\n    \"thoughts\": Grab toys off floor.  Put it in a container.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'microwave', 'freezer', 'walllamp', 'food_carrot', 'drawing', 'clothes_underwear', 'bathroom_counter', 'floor', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'floor_lamp', 'foundation', 'couch', 'pillow', 'bowl', 'dining_room', 'wall', 'nightstand', 'oven', 'bed', 'food_donut', 'console', 'cupboard', 'bathroom_cabinet']\nTask:Turn on lights\nresponse:\n", "output": {"thoughts": "Walk to your lamp, switch it on, and lay on your bed", "actions": ["[WALK] <bedroom>", "[WALK] <floor_lamp>", "[FIND] <floor_lamp>", "[TURNTO] <floor_lamp>", "[SWITCHON] <floor_lamp>", "[FIND] <bed>", "[LIE] <bed>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'scissors', 'jelly', 'walllamp', 'bathroom', 'ceilingfan', 'drawing', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'balanceball', 'shoe-shine_kit', 'window', 'couch', 'food_jam', 'wall', 'novel', 'television', 'curtain', 'doorjamb', 'comb', 'clothes_dress', 'sink', 'home_office', 'table']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": first i will go to living room and then take the remote and swtitch on television after that il change the channel,\n    \"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>']\n}\n", "input": "\nScene_Objects:['glue', 'food_bread', 'filing_cabinet', 'bathroom', 'ceiling', 'phone', 'keyboard', 'purse', 'bookshelf', 'laptop', 'ceilinglamp', 'faucet', 'nightstand', 'bench', 'photoframe', 'bed', 'clothes_gloves', 'food_food', 'coffe_maker', 'television', 'toothbrush_holder', 'curtain', 'shaving_cream', 'pencil', 'dresser', 'conditioner', 'door', 'spoon', 'bathroom_cabinet', 'table']\nTask:Shut front door\nresponse:\n", "output": {"thoughts": "Close the storm door. Lock the storm door.", "actions": ["[WALK] <home_office>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'mat', 'window', 'clothes_socks', 'couch', 'pillow', 'towel', 'broom', 'wall', 'bench', 'oven', 'toy', 'bed', 'coffe_maker', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'food_onion', 'towel_rack', 'mouse', 'bathroom_cabinet', 'table', 'scrabble']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": Walk to living room. Find couch. Sit on couch,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'juice', 'food_ice_cream', 'chair', 'walllamp', 'detergent', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'mousepad', 'clothes_hat', 'towel', 'wall', 'powersocket', 'bench', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'shoes', 'door', 'bathroom_cabinet']\nTask:Put in chair\nresponse:\n", "output": {"thoughts": "Take a comfortable chair. Place it in the entrance hall", "actions": ["[WALK] <home_office>", "[WALK] <chair>", "[FIND] <chair>", "[GRAB] <chair>", "[WALK] <home_office>", "[WALK] <floor>", "[FIND] <floor>", "[PUTBACK] <chair> <floor>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'microwave', 'chair', 'freezer', 'walllamp', 'floor', 'character', 'bookshelf', 'computer', 'toaster', 'mat', 'plate', 'window', 'food_noodles', 'food_orange', 'wall', 'oven', 'photoframe', 'keys', 'bed', 'coffe_maker', 'toothbrush_holder', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'clothes_dress', 'napkin', 'home_office', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['sponge', 'band-aids', 'toothbrush', 'orchid', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'faucet', 'picture', 'shower', 'mousepad', 'candle', 'food_orange', 'oven', 'basket_for_clothes', 'bed', 'check', 'food_food', 'television', 'tray', 'after_shave', 'headset', 'comb', 'dresser', 'laundry_detergent', 'napkin', 'bathroom_cabinet']\nTask:Sit in chair\nresponse:\n", "output": {"thoughts": "I sit in a chair to rest and eat.", "actions": ["[WALK] <dining_room>", "[WALK] <chair>", "[FIND] <chair>", "[PULL] <chair>", "[SIT] <chair>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Turn light off\nresponse:\n{\n    \"thoughts\": Put the light switch into the down, or off, position.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[SWITCHOFF] <light>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'freezer', 'blow_dryer', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'picture', 'iron', 'mousepad', 'bowl', 'wall', 'powersocket', 'bench', 'photoframe', 'toilet_paper', 'coffe_maker', 'toothbrush_holder', 'tray', 'doorjamb', 'dishrack', 'sink', 'bathroom_cabinet', 'home_office', 'light']\nTask:Get toilet paper\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['crayon', 'trashcan', 'orchid', 'cpuscreen', 'ceiling', 'bedroom', 'table_cloth', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bench', 'bed', 'novel', 'food_food', 'mouthwash', 'coffe_maker', 'oven_mitts', 'curtain', 'doorjamb', 'cards', 'dresser', 'cupboard', 'bathtub', 'home_office', 'light']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Go to the book shelf, get a book, open the book and read the book.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['spectacles', 'pot', 'sheets', 'walllamp', 'knifeblock', 'drawing', 'orchid', 'floor', 'bedroom', 'mail', 'food_bacon', 'laptop', 'mat', 'plate', 'faucet', 'food_orange', 'pillow', 'wall', 'bench', 'box', 'bed', 'photoframe', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'tooth_paste']\nTask:Bring dirty plate to sink\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'microwave', 'freezer', 'ground_coffee', 'cpuscreen', 'floor', 'ceiling', 'keyboard', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'food_orange', 'bowl', 'wall', 'wall_clock', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'mouthwash', 'coffee_filter', 'water', 'doorjamb', 'pencil', 'kitchen_counter', 'hair', 'controller', 'sink', 'soap']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']\n}\n", "input": "\nScene_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']\nTask:Walk to room\nresponse:\n", "output": {"thoughts": "Leave the living room and enter the hall", "actions": ["[WALK] <home_office>", "[WALK] <home_office>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'toilet', 'freezer', 'bathroom', 'detergent', 'bathroom_counter', 'floor', 'bedroom', 'toaster', 'plate', 'shower', 'dining_room', 'nightstand', 'oven', 'cup', 'coffe_maker', 'food_food', 'television', 'tray', 'kitchen_counter', 'dresser', 'door', 'sink', 'bathtub', 'home_office', 'table', 'dishwasher', 'soap', 'board_game']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <plate>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['juice', 'beer', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'folder', 'keyboard', 'computer', 'ceilinglamp', 'window', 'mousepad', 'couch', 'pillow', 'bowl', 'food_kiwi', 'wall', 'powersocket', 'food_food', 'curtain', 'doorjamb', 'mouse', 'door', 'light', 'table']\nTask:Drink\nresponse:\n", "output": {"thoughts": "Get a can of beer, open it, sit on couch, relax", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <beer>", "[GRAB] <beer>", "[CLOSE] <freezer>", "[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[DRINK] <beer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'pot', 'toilet', 'chair', 'bathroom', 'drawing', 'knife', 'clothes_underwear', 'floor', 'mail', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'plate', 'deck_of_cards', 'toaster', 'oil', 'wall', 'wall_clock', 'oven', 'cup', 'novel', 'food_food', 'television', 'oven_mitts', 'cards', 'cupboard', 'conditioner', 'table']\nTask:Eat dinner\nresponse:\n{\n    \"thoughts\": Sit down at the dinning table with my family and eat dinner.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[GRAB] <food_food>', '[FIND] <plate>', '[PUTBACK] <food_food> <plate>', '[GRAB] <food_food>', '[PUTOBJBACK] <food_food>', '[FIND] <fork>', '[GRAB] <fork>', '[EAT] <plate>']\n}\n", "input": "\nScene_Objects:['chair', 'ground_coffee', 'bathroom', 'detergent', 'dough', 'knifeblock', 'drawing', 'food_egg', 'floor', 'bedroom', 'keyboard', 'purse', 'mop_bucket', 'stovefan', 'mousepad', 'food_orange', 'bed', 'check', 'toilet_paper', 'food_rice', 'tray', 'shaving_cream', 'mouse', 'cd', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'clothes_skirt', 'creditcard']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "Twist the lamp switch until the light goes on.", "actions": ["[WALK] <home_office>", "[WALK] <floor_lamp>", "[FIND] <floor_lamp>", "[SWITCHON] <floor_lamp>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'toilet', 'detergent', 'hanger', 'floor', 'phone', 'stamp', 'toaster', 'balanceball', 'oil', 'pillow', 'dining_room', 'wall_clock', 'toy', 'newspaper', 'keys', 'photoframe', 'food_food', 'clothes_gloves', 'rag', 'doorjamb', 'mouse', 'dishrack', 'dresser', 'cupboard', 'hairdryer', 'spoon', 'table', 'light', 'scrabble']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Pet Cat,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'pot', 'jelly', 'freezer', 'bathroom', 'trashcan', 'milk', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'alcohol', 'table_cloth', 'faucet', 'shower', 'form', 'powersocket', 'bench', 'bed', 'food_food', 'kitchen_counter', 'headset', 'vacuum_cleaner', 'cupboard', 'door', 'clothes_scarf', 'food_steak', 'soap']\nTask:Grab things\nresponse:\n", "output": {"thoughts": "The robot will need some kind of hands or grabbing device to transport objects.", "actions": ["[WALK] <novel>", "[TURNTO] <novel>", "[GRAB] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'bills', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'mouse', 'shoes', 'comb', 'door', 'light']\nTask:Check email\nresponse:\n{\n    \"thoughts\": Turn on laptop.  Connect to Internet.  Type in the url.  Check for new email messages.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'tablelamp', 'food_salt', 'chair', 'walllamp', 'detergent', 'drawing', 'clothes_underwear', 'floor', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'food_noodles', 'garbage_can', 'mousepad', 'microphone', 'wall', 'nightstand', 'food_vegetable', 'bed', 'food_food', 'coffee_filter', 'mouse', 'sink', 'home_office', 'table', 'dishwasher', 'pantry']\nTask:Organize pantry\nresponse:\n", "output": {"thoughts": "Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.", "actions": ["[WALK] <dining_room>", "[WALK] <pantry>", "[FIND] <food_food>", "[GRAB] <food_food>", "[TURNTO] <food_food>", "[LOOKAT] <food_food>", "[FIND] <garbage_can>", "[PUTBACK] <food_food> <garbage_can>", "[FIND] <food_vegetable>", "[GRAB] <food_vegetable>", "[TURNTO] <food_vegetable>", "[LOOKAT] <food_vegetable>", "[PUTBACK] <food_vegetable> <garbage_can>", "[FIND] <dry_pasta>", "[GRAB] <dry_pasta>", "[TURNTO] <dry_pasta>", "[LOOKAT] <dry_pasta>", "[PUTOBJBACK] <dry_pasta>", "[FIND] <food_food>", "[TURNTO] <food_food>", "[LOOKAT] <food_food>", "[PUSH] <food_food>", "[FIND] <food_noodles>", "[GRAB] <food_noodles>", "[TURNTO] <food_noodles>", "[LOOKAT] <food_noodles>", "[PUTOBJBACK] <food_noodles>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Turn on tv.  Sit with kids.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'juice', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'picture', 'homework', 'mousepad', 'wall', 'oven', 'toy', 'newspaper', 'check', 'television', 'mouse', 'laundry_detergent', 'conditioner', 'laser_pointer']\nTask:Push in desk chair\nresponse:\n", "output": {"thoughts": "Push the desk chair until it is under the desk.", "actions": ["[WALK] <home_office>", "[WALK] <desk>", "[FIND] <chair>", "[TOUCH] <chair>", "[PUSH] <chair>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'food_salt', 'chair', 'detergent', 'trashcan', 'dough', 'drawing', 'character', 'computer', 'button', 'brush', 'mat', 'couch', 'clothes_pants', 'clothes_hat', 'wall', 'nightstand', 'basket_for_clothes', 'food_cheese', 'rag', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'laundry_detergent', 'conditioner', 'sink', 'home_office', 'table', 'clothes_shirt', 'washing_machine']\nTask:Wash clothes\nresponse:\n{\n    \"thoughts\": Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <clothes_shirt>', '[GRAB] <clothes_shirt>', '[PUTBACK] <clothes_shirt> <washing_machine>', '[PUTOBJBACK] <basket_for_clothes>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']\n}\n", "input": "\nScene_Objects:['sheets', 'filing_cabinet', 'juice', 'microwave', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'shower', 'faucet', 'window', 'mousepad', 'food_orange', 'wall', 'television', 'curtain', 'after_shave', 'mouse', 'dresser', 'door', 'napkin', 'table']\nTask:Clean screen\nresponse:\n", "output": {"thoughts": "Use a soft rag to wipe the screen until there are no marks on it.", "actions": ["[WALK] <home_office>", "[WALK] <rag>", "[FIND] <rag>", "[GRAB] <rag>", "[WALK] <computer>", "[WIPE] <computer>", "[PUTOBJBACK] <rag>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'microwave', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'character', 'stamp', 'keyboard', 'toaster', 'plate', 'faucet', 'tvstand', 'bowl', 'wall', 'oven', 'photoframe', 'coffe_maker', 'food_food', 'ice', 'curtain', 'shaving_cream', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Walk to the kitchen. Open the dishwasher and turn on the faucet. Rinse off the dishes. Put the dishes in the dishwasher. Put detergent in the dishwasher. Close the dishwasher. Switch on the dishwasher.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <detergent>', '[GRAB] <detergent>', '[PUTBACK] <detergent> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'brush', 'ceilinglamp', 'mat', 'laptop', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_food', 'oven_mitts', 'kettle', 'mouse', 'cd', 'door', 'hairdryer', 'napkin', 'sink', 'table', 'light']\nTask:Wash monitor\nresponse:\n", "output": {"thoughts": "Clean the grime off of my monitor screen when not in use", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[SWITCHOFF] <computer>", "[FIND] <brush>", "[TURNTO] <brush>", "[LOOKAT] <brush>", "[GRAB] <brush>", "[WIPE] <computer>", "[DROP] <brush>", "[FIND] <napkin>", "[GRAB] <napkin>", "[WASH] <napkin>", "[WIPE] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'tablelamp', 'toilet', 'chair', 'detergent', 'trashcan', 'orchid', 'floor', 'ceiling', 'stamp', 'man', 'bookshelf', 'purse', 'toaster', 'mat', 'oil', 'mousepad', 'nightstand', 'cup', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'mouse', 'headset', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher']\nTask:Answer door\nresponse:\n{\n    \"thoughts\": Wait until doorbell rings, look to see who it is outside and open the door if you feel so inclined.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>']\n}\n", "input": "\nScene_Objects:['sheets', 'filing_cabinet', 'food_salt', 'measuring_cup', 'toilet', 'jelly', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'alcohol', 'mat', 'shower', 'foundation', 'electric_shaver', 'mousepad', 'wall', 'toy', 'basket_for_clothes', 'photoframe', 'wine', 'dresser', 'laundry_detergent', 'food_steak', 'door', 'napkin', 'bathroom_cabinet', 'dishwasher']\nTask:Pick up toys\nresponse:\n", "output": {"thoughts": "Pickup toys from around the room. Organize toys back into their appropriate spaces on the shelves and into the toy boxes.", "actions": ["[WALK] <bedroom>", "[WALK] <toy>", "[FIND] <toy>", "[GRAB] <toy>", "[WALK] <filing_cabinet>", "[OPEN] <filing_cabinet>", "[PUTBACK] <toy> <filing_cabinet>", "[CLOSE] <filing_cabinet>", "[FIND] <toy>", "[GRAB] <toy>", "[WALK] <dresser>", "[OPEN] <dresser>", "[PUTBACK] <toy> <dresser>", "[CLOSE] <dresser>", "[FIND] <toy>", "[GRAB] <toy>", "[WALK] <filing_cabinet>", "[OPEN] <filing_cabinet>", "[PUTBACK] <toy> <filing_cabinet>", "[CLOSE] <filing_cabinet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dog', 'food_egg', 'bathroom_counter', 'folder', 'bedroom', 'computer', 'table_cloth', 'piano_bench', 'stovefan', 'tvstand', 'faucet', 'foundation', 'homework', 'couch', 'nightstand', 'powersocket', 'oven', 'basket_for_clothes', 'cup', 'keys', 'food_food', 'mouthwash', 'after_shave', 'doorjamb', 'shoes', 'controller', 'maindoor', 'bag', 'dirt', 'coffee']\nTask:Get ready to leave\nresponse:\n{\n    \"thoughts\": Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <keys>', '[GRAB] <keys>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'food_ice_cream', 'walllamp', 'nail_polish', 'cat', 'orchid', 'drawing', 'floor', 'ceiling', 'purse', 'alcohol', 'mail', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'towel', 'wall', 'oven', 'cup', 'food_cheese', 'television', 'curtain', 'doorjamb', 'door', 'table', 'clothes_shirt']\nTask:Straighten paintings on wall\nresponse:\n", "output": {"thoughts": "Go up to the painting and tilt it which ever way it is uneven until it looks straight.", "actions": ["[WALK] <home_office>", "[WALK] <wall>", "[WALK] <drawing>", "[FIND] <drawing>", "[TURNTO] <drawing>", "[LOOKAT] <drawing>", "[TOUCH] <drawing>", "[PULL] <drawing>", "[PUSH] <drawing>", "[WALK] <drawing>", "[FIND] <drawing>", "[TURNTO] <drawing>", "[LOOKAT] <drawing>", "[TOUCH] <drawing>", "[PULL] <drawing>", "[PUSH] <drawing>", "[WALK] <drawing>", "[FIND] <drawing>", "[TURNTO] <drawing>", "[LOOKAT] <drawing>", "[TOUCH] <drawing>", "[PULL] <drawing>", "[PUSH] <drawing>", "[TURNTO] <drawing>", "[LOOKAT] <drawing>", "[TURNTO] <drawing>", "[LOOKAT] <drawing>", "[TURNTO] <drawing>", "[LOOKAT] <drawing>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'keyboard', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'shower', 'window', 'tvstand', 'pillow', 'wall', 'wall_clock', 'powersocket', 'photoframe', 'coffe_maker', 'water', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'light', 'table']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'food_salt', 'toilet', 'chair', 'bathroom', 'food_carrot', 'cpuscreen', 'shampoo', 'phone', 'ceiling', 'bedroom', 'desk', 'computer', 'toaster', 'shower', 'foundation', 'dustpan', 'photoframe', 'coffe_maker', 'food_rice', 'tray', 'curtain', 'doorjamb', 'console', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher', 'creditcard']\nTask:Put umbrella away\nresponse:\n", "output": {"thoughts": "Place the umbrella in the umbrella bucket point first.", "actions": ["[WALK] <home_office>", "[WALK] <mop_bucket>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Put groceries in Fridge\nresponse:\n{\n    \"thoughts\": Put the groceries on the table into the fridge,\n    \"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>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'filing_cabinet', 'crayon', 'cat', 'food_butter', 'trashcan', 'bathroom_counter', 'floor', 'folder', 'mail', 'tvstand', 'window', 'mousepad', 'towel', 'wall', 'nightstand', 'bench', 'toy', 'basket_for_clothes', 'cup', 'food_cheese', 'light_bulb', 'food_food', 'television', 'curtain', 'shoes', 'dresser', 'door', 'sink']\nTask:Pick up toys\nresponse:\n", "output": {"thoughts": "Bend down and pick up the toys off of the floor.", "actions": ["[WALK] <bedroom>", "[WALK] <toy>", "[FIND] <toy>", "[GRAB] <toy>", "[WALK] <dresser>", "[OPEN] <dresser>", "[PUTIN] <toy> <dresser>", "[FIND] <toy>", "[GRAB] <toy>", "[WALK] <dresser>", "[PUTIN] <toy> <dresser>", "[FIND] <toy>", "[WALK] <dresser>", "[GRAB] <toy>", "[PUTIN] <toy> <dresser>", "[CLOSE] <dresser>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'filing_cabinet', 'food_pizza', 'knifeblock', 'food_egg', 'hanger', 'phone', 'desk', 'tea_bag', 'purse', 'envelope', 'clothes_jacket', 'table_cloth', 'faucet', 'window', 'closetdrawer', 'clothes_pants', 'food_jam', 'wall', 'basket_for_clothes', 'bed', 'cd', 'comb', 'laundry_detergent', 'clothes_scarf', 'napkin', 'home_office', 'bathroom_cabinet', 'washing_machine', 'teeth']\nTask:Wash clothes\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['beer', 'chair', 'band-aids', 'walllamp', 'bathroom', 'detergent', 'food_carrot', 'drawing', 'floor', 'ceiling', 'mat', 'faucet', 'mousepad', 'food_noodles', 'couch', 'wall', 'basket_for_clothes', 'photoframe', 'light_bulb', 'novel', 'television', 'coffee_filter', 'tray', 'diary', 'mouse', 'pencil', 'cd', 'chessboard', 'bathroom_cabinet', 'creditcard']\nTask:Wipe down baseboards please\nresponse:\n", "output": {"thoughts": "Use a rag to get all the dust off the baseboards please.", "actions": ["[WALK] <home_office>", "[WALK] <rag>", "[FIND] <rag>", "[GRAB] <rag>", "[WALK] <wall>", "[PUTOBJBACK] <rag>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'food_cheese', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'bathroom_cabinet', 'light', 'home_office']\nTask:Work\nresponse:\n{\n    \"thoughts\": Type on a computer in the home office.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']\n}\n", "input": "\nScene_Objects:['walllamp', 'food_carrot', 'drawing', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'stovefan', 'ceilinglamp', 'shower', 'faucet', 'window', 'oil', 'couch', 'clothes_pants', 'pillow', 'wall', 'tape', 'cup', 'novel', 'tray', 'curtain', 'mouse', 'chessboard', 'controller', 'table']\nTask:Read book\nresponse:\n", "output": {"thoughts": "Sit on a couch, grab a book, open it, and scan the pages", "actions": ["[WALK] <home_office>", "[WALK] <novel>", "[FIND] <novel>", "[GRAB] <novel>", "[WALK] <couch>", "[SIT] <couch>", "[TURNTO] <novel>", "[LOOKAT] <novel>", "[READ] <novel>", "[READ] <novel>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['ground_coffee', 'nail_polish', 'ceilingfan', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'button', 'mail', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'bench', 'tape', 'television', 'curtain', 'food_onion', 'cupboard', 'table', 'shoe_rack']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Go to the living room, sit on the couch, find the remote, switch on the TV and watch,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['pot', 'food_bread', 'food_ice_cream', 'tea', 'walllamp', 'drawing', 'bills', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'keyboard', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'iron', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'toy', 'television', 'tray', 'curtain', 'sink', 'bathroom_cabinet', 'table']\nTask:Read magazine\nresponse:\n", "output": {"thoughts": "Please sit on the couch and read a magazine", "actions": ["[WALK] <home_office>", "[WALK] <newspaper>", "[FIND] <newspaper>", "[GRAB] <newspaper>", "[WALK] <couch>", "[SIT] <couch>", "[TURNTO] <newspaper>", "[LOOKAT] <newspaper>", "[READ] <newspaper>", "[READ] <newspaper>", "[READ] <newspaper>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'ground_coffee', 'bathroom', 'trashcan', 'food_butter', 'knifeblock', 'needle', 'floor', 'ceiling', 'character', 'clothes_jacket', 'toaster', 'ceilinglamp', 'balanceball', 'mousepad', 'broom', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'rag', 'coffee_pot', 'laundry_detergent', 'maindoor', 'napkin', 'table', 'dishwasher']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['pot', 'food_pizza', 'jelly', 'chair', 'freezer', 'nail_polish', 'milk', 'hanger', 'floor', 'phone', 'ceiling', 'clothes_jacket', 'piano_bench', 'window', 'oil', 'wall', 'cup', 'keys', 'food_food', 'curtain', 'doorjamb', 'cards', 'pencil', 'vacuum_cleaner', 'dresser', 'pajamas', 'hairdryer', 'door', 'bag', 'bathroom_cabinet']\nTask:Vacuum\nresponse:\n", "output": {"thoughts": "Plug in the vacuum. Turn it on. Push it back and forth across the floor until all the debris is gone.", "actions": ["[WALK] <home_office>", "[WALK] <dresser>", "[OPEN] <dresser>", "[FIND] <vacuum_cleaner>", "[GRAB] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PLUGIN] <vacuum_cleaner>", "[SWITCHON] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PUSH] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PUSH] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PUSH] <vacuum_cleaner>", "[SWITCHOFF] <vacuum_cleaner>", "[PLUGOUT] <vacuum_cleaner>", "[WALK] <dresser>", "[PUTIN] <vacuum_cleaner> <dresser>", "[CLOSE] <dresser>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'juice', 'blow_dryer', 'walllamp', 'detergent', 'floor', 'ceiling', 'bedroom', 'keyboard', 'purse', 'tvstand', 'deck_of_cards', 'clothes_pants', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'keys', 'tray', 'kettle', 'shoes', 'hair', 'sink', 'home_office', 'table', 'dishwasher', 'soap', 'board_game', 'dirt']\nTask:Hang up car keys\nresponse:\n{\n    \"thoughts\": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'food_bread', 'freezer', 'food_carrot', 'milk', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'mousepad', 'garbage_can', 'clothes_hat', 'food_orange', 'food_dessert', 'wall', 'powersocket', 'food_vegetable', 'food_cheese', 'doorjamb', 'lighter', 'mouse', 'coffee', 'door', 'light', 'colander', 'teeth']\nTask:Rotate stock in refrigerator\nresponse:\n", "output": {"thoughts": "Throw out expired items, put older items in front.", "actions": ["[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <food_bread>", "[GRAB] <food_bread>", "[TURNTO] <food_bread>", "[LOOKAT] <food_bread>", "[PUTOBJBACK] <food_bread>", "[FIND] <food_cheese>", "[GRAB] <food_cheese>", "[TURNTO] <food_cheese>", "[LOOKAT] <food_cheese>", "[FIND] <garbage_can>", "[PUTBACK] <food_cheese> <garbage_can>", "[FIND] <food_cheese>", "[GRAB] <food_cheese>", "[TURNTO] <food_cheese>", "[LOOKAT] <food_cheese>", "[PUTOBJBACK] <food_cheese>", "[FIND] <food_dessert>", "[TURNTO] <food_dessert>", "[LOOKAT] <food_dessert>", "[PUSH] <food_dessert>", "[FIND] <food_vegetable>", "[GRAB] <food_vegetable>", "[TURNTO] <food_vegetable>", "[LOOKAT] <food_vegetable>", "[PUTBACK] <food_vegetable> <garbage_can>", "[FIND] <milk>", "[GRAB] <milk>", "[TURNTO] <milk>", "[LOOKAT] <milk>", "[PUTOBJBACK] <milk>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'food_bread', 'microwave', 'freezer', 'ground_coffee', 'dough', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'toaster', 'faucet', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'kitchen_counter', 'cupboard', 'sink']\nTask:Make coffee\nresponse:\n{\n    \"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,\n    \"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>']\n}\n", "input": "\nScene_Objects:['spectacles', 'dog', 'detergent', 'trashcan', 'orchid', 'needle', 'bathroom_counter', 'computer', 'button', 'table_cloth', 'deck_of_cards', 'stereo', 'shower', 'floor_lamp', 'towel', 'wall', 'love_seat', 'cup', 'newspaper', 'basket_for_clothes', 'photoframe', 'food_rice', 'wooden_spoon', 'doorjamb', 'dresser', 'controller', 'door', 'napkin', 'home_office', 'clothes_skirt']\nTask:Read\nresponse:\n", "output": {"thoughts": "Sit on an easy chair.  Turn on music.  Take a book and read.  Turn on lamp at night.", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>", "[FIND] <newspaper>", "[GRAB] <newspaper>", "[FIND] <love_seat>", "[SIT] <love_seat>", "[FIND] <floor_lamp>", "[SWITCHON] <floor_lamp>", "[READ] <newspaper>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'food_pizza', 'tablelamp', 'microwave', 'floor', 'ceiling', 'desk', 'bookshelf', 'stovefan', 'mat', 'ceilinglamp', 'laptop', 'window', 'homework', 'oil', 'closetdrawer', 'couch', 'nightstand', 'wall', 'cup', 'bed', 'food_food', 'mouthwash', 'toothbrush_holder', 'oven_mitts', 'razor', 'food_donut', 'check', 'clothes_scarf', 'bathroom_cabinet']\nTask:Go to sleep\nresponse:\n{\n    \"thoughts\": Walk to bedroom. Walk to bed, lie in bed.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <bed>', '[LIE] <bed>']\n}\n", "input": "\nScene_Objects:['glue', 'crayon', 'freezer', 'nail_polish', 'food_carrot', 'milk', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'cup', 'bed', 'food_food', 'doorjamb', 'mouse', 'pajamas', 'controller', 'door', 'spoon', 'napkin', 'light', 'dirt']\nTask:Get glass of milk\nresponse:\n", "output": {"thoughts": "Get an empty glass. Take milk from refrigerator and open it. Pour milk into glass.", "actions": ["[WALK] <dining_room>", "[WALK] <cup>", "[FIND] <cup>", "[GRAB] <cup>", "[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <milk>", "[GRAB] <milk>", "[POUR] <milk> <cup>", "[PUTOBJBACK] <milk>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'chair', 'walllamp', 'bathroom', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'clothes_jacket', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'pasta', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'cards', 'dresser', 'door', 'colander']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']\n}\n", "input": "\nScene_Objects:['fork', 'filing_cabinet', 'tablelamp', 'toilet', 'jelly', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'coffee_filter', 'curtain', 'doorjamb', 'centerpiece', 'door', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "I sit down on sofa, get the remote, turn on tv, change channel to show I want to watch", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'tablelamp', 'food_salt', 'freezer', 'orchid', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'phone', 'bookshelf', 'stovefan', 'pillow', 'wall', 'wall_clock', 'cutting_board', 'box', 'shelf', 'newspaper', 'bed', 'novel', 'coffe_maker', 'toilet_paper', 'wooden_spoon', 'hairbrush', 'door', 'home_office', 'table', 'light', 'vase']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Pick up the book, open to current page, read the words.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['ironing_board', 'dry_pasta', 'food_pizza', 'beer', 'dog', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'phone', 'folder', 'character', 'keyboard', 'stovefan', 'laptop', 'iron', 'picture', 'mousepad', 'microphone', 'powersocket', 'cup', 'novel', 'food_food', 'food_donut', 'wine', 'pencil', 'bag', 'table', 'soap', 'clothes_shirt']\nTask:Iron shirt\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'keyboard', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'closetdrawer', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'rag', 'doorjamb', 'cards', 'dresser', 'sink', 'dishwasher']\nTask:Watch  TV\nresponse:\n{\n    \"thoughts\": Sit on my couch  directly opposite  my tv , switch  on my tv with the  remote control  and watch,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'food_ice_cream', 'tea', 'knifeblock', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'envelope', 'alcohol', 'mat', 'faucet', 'shower', 'towel', 'wall', 'toy', 'bed', 'wooden_spoon', 'doorjamb', 'vacuum_cleaner', 'pajamas', 'laundry_detergent', 'door', 'sink', 'bathroom_cabinet', 'light', 'clothes_skirt', 'soap', 'hands_both']\nTask:Hand washing\nresponse:\n", "output": {"thoughts": "Turn on the faucet. Soap up your hands. Then rinse under the running water of the faucet. Turn off faucet and dry hands.", "actions": ["[WALK] <bathroom>", "[WALK] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <soap>", "[GRAB] <soap>", "[FIND] <hands_both>", "[SCRUB] <hands_both>", "[PUTOBJBACK] <soap>", "[WASH] <hands_both>", "[SWITCHOFF] <faucet>", "[FIND] <towel>", "[GRAB] <towel>", "[WIPE] <hands_both>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'blender', 'food_ice_cream', 'toilet', 'walllamp', 'detergent', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'computer', 'toaster', 'mat', 'tvstand', 'laptop', 'ceilinglamp', 'brush', 'couch', 'pillow', 'dining_room', 'wall', 'child', 'oven', 'photoframe', 'bed', 'television', 'doorjamb', 'mouse', 'dishwasher']\nTask:Let baby learn how to walk\nresponse:\n{\n    \"thoughts\": The baby tries to stand up and balances on the couch and there are no sharp edges so it's safe.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TOUCH] <child>', '[GREET] <child>', '[FIND] <couch>', '[TURNTO] <couch>', '[POINTAT] <couch>', '[TURNTO] <child>', '[LOOKAT] <child>']\n}\n", "input": "\nScene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'scissors', 'microwave', 'chair', 'freezer', 'food_butter', 'drawing', 'knife', 'cpuscreen', 'floor', 'folder', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'shower', 'mousepad', 'wall', 'nightstand', 'bed', 'ice', 'after_shave', 'doorjamb', 'mouse', 'kitchen_counter', 'food_steak', 'light']\nTask:Work\nresponse:\n", "output": {"thoughts": "I work on my HP computer.", "actions": ["[WALK] <bedroom>", "[WALK] <laptop>", "[FIND] <laptop>", "[GRAB] <laptop>", "[WALK] <bed>", "[SIT] <bed>", "[SWITCHON] <laptop>", "[TURNTO] <laptop>", "[LOOKAT] <laptop>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'mop', 'microwave', 'toilet', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'computer', 'piano_bench', 'ceilinglamp', 'plate', 'deck_of_cards', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'bed', 'novel', 'television', 'doorjamb', 'door', 'coffee_cup', 'table', 'light']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[DRINK] <coffee_cup>']\n}\n", "input": "\nScene_Objects:['spectacles', 'pot', 'walllamp', 'nail_polish', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'bookshelf', 'computer', 'faucet', 'oil', 'dining_room', 'wall', 'nightstand', 'oven', 'powersocket', 'toy', 'cup', 'coffee_filter', 'shaving_cream', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'home_office', 'table', 'dishwasher', 'bathroom_cabinet']\nTask:Get glass of water\nresponse:\n", "output": {"thoughts": "Get a glass from a cabinet. Hold it under the sink and turn the cold water on. Fill the glass. Turn off the water.", "actions": ["[WALK] <dining_room>", "[WALK] <kitchen_cabinet>", "[FIND] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[FIND] <cup>", "[GRAB] <cup>", "[CLOSE] <kitchen_cabinet>", "[WALK] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[PUTBACK] <cup> <sink>", "[GRAB] <cup>", "[SWITCHOFF] <faucet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'pot', 'tablelamp', 'chair', 'dog', 'walllamp', 'ceilingfan', 'knifeblock', 'needle', 'bathroom_counter', 'floor', 'computer', 'shoe-shine_kit', 'dustpan', 'box', 'cup', 'bed', 'keys', 'television', 'food_donut', 'tray', 'curtain', 'doorjamb', 'kettle', 'kitchen_counter', 'shoes', 'comb', 'sink', 'bathroom_cabinet', 'board_game']\nTask:Brush teeth\nresponse:\n{\n    \"thoughts\": go to the bathroom and brush your teeth,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <toothbrush>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[POUR] <tooth_paste> <toothbrush>']\n}\n", "input": "\nScene_Objects:['pot', 'walllamp', 'toothbrush', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'shampoo', 'floor', 'ceiling', 'desk', 'mop_bucket', 'stovefan', 'laptop', 'tvstand', 'faucet', 'wall', 'nightstand', 'oven', 'tape', 'food_food', 'tray', 'curtain', 'kettle', 'kitchen_counter', 'cupboard', 'conditioner', 'sink', 'bathroom_cabinet', 'table']\nTask:Wipe down counter\nresponse:\n", "output": {"thoughts": "Clean counter", "actions": ["[WALK] <dining_room>", "[WALK] <rag>", "[FIND] <rag>", "[GRAB] <rag>", "[WALK] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[RINSE] <rag>", "[SQUEEZE] <rag>", "[SWITCHOFF] <faucet>", "[WALK] <kitchen_counter>", "[WIPE] <kitchen_counter>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'tape', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'comb', 'dresser', 'door', 'light']\nTask:Work\nresponse:\n{\n    \"thoughts\": Walk to home office, walk to desk, sit in chair, turn on computer, look at computer, click mouse and type on keyboard.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['fork', 'food_bread', 'dog', 'ground_coffee', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'bedroom', 'alcohol', 'mop_bucket', 'stovefan', 'laptop', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'window', 'mat', 'mousepad', 'food_orange', 'pillow', 'powersocket', 'coffe_maker', 'fly', 'coffee_pot', 'kitchen_counter', 'cupboard', 'dishwasher', 'soap']\nTask:Watch fly\nresponse:\n", "output": {"thoughts": "Look around for a fly, often on a wall or ceiling.  Follow it's movements.", "actions": ["[WALK] <bedroom>", "[WALK] <fly>", "[FIND] <fly>", "[TURNTO] <fly>", "[LOOKAT] <fly>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'ground_coffee', 'walllamp', 'knife', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bedroom', 'button', 'stovefan', 'mat', 'shower', 'clothes_socks', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'bed', 'light_bulb', 'check', 'video_game_controller', 'mouthwash', 'food_onion', 'vacuum_cleaner', 'pajamas', 'cupboard', 'hair', 'instrument_guitar']\nTask:Go to sleep\nresponse:\n{\n    \"thoughts\": go to bedroom, put pajamas on, lie in bed, sleep,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <pajamas>', '[FIND] <pajamas>', '[GRAB] <pajamas>', '[PUTON] <pajamas>', '[FIND] <bed>', '[LIE] <bed>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'detergent', 'food_carrot', 'orchid', 'drawing', 'needle', 'hanger', 'floor', 'computer', 'bookmark', 'mat', 'laptop', 'faucet', 'shower', 'couch', 'candle', 'wall', 'nightstand', 'pasta', 'bed', 'photoframe', 'toilet_paper', 'toothbrush_holder', 'tray', 'kitchen_counter', 'controller', 'spoon', 'table']\nTask:Read book\nresponse:\n", "output": {"thoughts": "I lie on my bed and read a book.", "actions": ["[WALK] <bedroom>", "[WALK] <novel>", "[FIND] <novel>", "[GRAB] <novel>", "[WALK] <bed>", "[LIE] <bed>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'freezer', 'bathroom', 'food_carrot', 'drawing', 'orchid', 'wallshelf', 'food_egg', 'bathroom_counter', 'shampoo', 'phone', 'mat', 'ceilinglamp', 'shower', 'electric_shaver', 'clothes_socks', 'couch', 'microphone', 'dining_room', 'food_kiwi', 'nightstand', 'wall', 'check', 'food_food', 'after_shave', 'mouse', 'kitchen_counter', 'cupboard', 'home_office', 'laser_pointer']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": I go home and it's dark so I can not see anything,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'band-aids', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'stamp', 'desk', 'cleaning_solution', 'computer', 'stovefan', 'deck_of_cards', 'faucet', 'tvstand', 'window', 'couch', 'wall', 'nightstand', 'coffe_maker', 'television', 'mirror', 'after_shave', 'paper_towel', 'clothes_dress', 'sink', 'bag', 'bathroom_cabinet', 'dishwasher', 'laser_pointer']\nTask:Clean mirror\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['chair', 'freezer', 'ground_coffee', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'bedroom', 'ceilinglamp', 'tvstand', 'stereo', 'food_orange', 'cup', 'bed', 'keys', 'novel', 'food_food', 'coffe_maker', 'mouthwash', 'coin', 'check', 'diary', 'coffee_pot', 'mouse', 'dresser', 'hair', 'table', 'light']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": I go to my bedroom, and then I switch on the radio,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']\n}\n", "input": "\nScene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'video_game_console', 'desk', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'video_game_controller', 'television', 'food_rice', 'ice', 'curtain', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet', 'table', 'laser_pointer']\nTask:Play games\nresponse:\n", "output": {"thoughts": "Turn on game.  Use controller", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[PLUGIN] <television>", "[SWITCHON] <television>", "[FIND] <video_game_console>", "[PLUGIN] <video_game_console>", "[SWITCHON] <video_game_console>", "[FIND] <video_game_console>", "[FIND] <video_game_controller>", "[GRAB] <video_game_controller>", "[WALK] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'crayon', 'microwave', 'toilet', 'knife', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'shampoo', 'computer', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'cupboard', 'bathroom_cabinet', 'light', 'instrument_violin']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": I walk over to the phone. .I reach my arm out. I open my hand. I place my hand on the phone. I close my fingers around the phone. I pick up the phone.,\n    \"actions\": ['[WALK] <phone>', '[TOUCH] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['pot', 'food_pizza', 'filing_cabinet', 'microwave', 'toilet', 'dog', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'folder', 'keyboard', 'thread', 'computer', 'mat', 'window', 'dining_room', 'wall', 'nightstand', 'bench', 'cup', 'wine', 'curtain', 'kitchen_counter', 'hairbrush', 'clothes_dress', 'food_steak']\nTask:Look out window\nresponse:\n", "output": {"thoughts": "I head into my child's room and look out the window to view the neighborhood from a different area in the house.", "actions": ["[WALK] <bedroom>", "[WALK] <window>", "[TURNTO] <window>", "[LOOKAT] <window>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'toilet', 'chair', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'computer', 'mail', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cutting_board', 'photoframe', 'bed', 'television', 'doorjamb', 'dishrack', 'dresser', 'door', 'dishwasher']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": go to the living room to watch TV,\n    \"actions\": ['[RUN] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[TOUCH] <remote_control>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[DROP] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['fork', 'sheets', 'scissors', 'microwave', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'toothbrush', 'floor', 'phone', 'toaster', 'mat', 'tvstand', 'dustpan', 'wall', 'box', 'photoframe', 'coffe_maker', 'check', 'oven_mitts', 'food_rice', 'curtain', 'coffee_pot', 'kitchen_counter', 'cupboard', 'hairdryer', 'dishwasher', 'soap', 'coffee']\nTask:Take dishes out of dishwasher\nresponse:\n", "output": {"thoughts": "Take clean dishes out of the dishwasher and put away", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[OPEN] <dishwasher>", "[CLOSE] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": I walk into my home office and walk up to my desk. I pull out the chair and sit down. I turn on the computer. After the computer is turned on I click on the google icon. I enter Disney Cruise Line into the search bar and browse the internet.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[PULL] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[TURNTO] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TURNTO] <keyboard>', '[LOOKAT] <keyboard>', '[TYPE] <keyboard>']\n}\n", "input": "\nScene_Objects:['toilet', 'chair', 'dog', 'trashcan', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stamp', 'bookshelf', 'thread', 'computer', 'food_bacon', 'brush', 'ceilinglamp', 'shower', 'window', 'mousepad', 'food_jam', 'pillow', 'wall', 'check', 'curtain', 'doorjamb', 'shoes', 'dresser', 'light', 'laser_pointer']\nTask:Dust\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'blender', 'freezer', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'orchid', 'hanger', 'floor', 'bedroom', 'keyboard', 'computer', 'stereo', 'window', 'oil', 'couch', 'pillow', 'wall', 'cup', 'bed', 'food_donut', 'curtain', 'centerpiece', 'console', 'shoes', 'dresser', 'maindoor', 'home_office', 'light']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": Turn on radio, put on favorite channel, listen to music.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[LIE] <bed>']\n}\n", "input": "\nScene_Objects:['pot', 'toilet', 'freezer', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'alcohol', 'stovefan', 'brush', 'tvstand', 'picture', 'dustpan', 'wall', 'powersocket', 'cup', 'keys', 'light_bulb', 'food_food', 'doorjamb', 'controller', 'door', 'clothes_scarf', 'bathroom_cabinet', 'light', 'dishwasher', 'home_office', 'clothes_shirt']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "Hit light switch", "actions": ["[WALK] <bedroom>", "[WALK] <light>", "[SWITCHON] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'measuring_cup', 'cd_player', 'knife', 'character', 'tea_bag', 'remote_control', 'button', 'table_cloth', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'food_peanut_butter', 'candle', 'nightstand', 'bench', 'cutting_board', 'shelf', 'bed', 'photoframe', 'oven_mitts', 'food_rice', 'doorjamb', 'shaving_cream', 'mouse', 'dresser', 'controller', 'sink', 'table', 'clothes_skirt']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[PLUGIN] <cd_player>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']\n}\n", "input": "\nScene_Objects:['food_salt', 'freezer', 'walllamp', 'drawing', 'floor', 'ceiling', 'bookshelf', 'mail', 'table_cloth', 'shower', 'foundation', 'dustpan', 'microphone', 'wall', 'powersocket', 'food_food', 'check', 'television', 'rag', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'sink', 'hairdryer', 'light', 'clothes_skirt', 'scrabble', 'creditcard']\nTask:Turn off light\nresponse:\n", "output": {"thoughts": "Hit the switch.", "actions": ["[WALK] <bedroom>", "[WALK] <light>", "[SWITCHOFF] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Sit on the couch nd watch t.V,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>']\n}\n", "input": "\nScene_Objects:['fork', 'filing_cabinet', 'food_bread', 'microwave', 'trashcan', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'bathroom_counter', 'bedroom', 'tea_bag', 'tvstand', 'window', 'form', 'pillow', 'broom', 'bench', 'basket_for_clothes', 'newspaper', 'bed', 'check', 'coffe_maker', 'tray', 'door', 'home_office', 'light', 'bathroom_cabinet', 'tooth_paste', 'coffee']\nTask:Get dressed\nresponse:\n", "output": {"thoughts": "I get dressed in my bedroom in the mornings.", "actions": ["[WALK] <bedroom>", "[WALK] <shoes>", "[FIND] <shoes>", "[GRAB] <shoes>", "[PUTON] <shoes>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'freezer', 'detergent', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'desk', 'bookshelf', 'mail', 'toaster', 'ceilinglamp', 'faucet', 'window', 'pillow', 'dining_room', 'wall', 'powersocket', 'oven', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'pencil', 'vacuum_cleaner', 'light']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": switching on light in an area,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['pot', 'food_pizza', 'food_ice_cream', 'chair', 'band-aids', 'toothbrush', 'orchid', 'needle', 'hanger', 'bedroom', 'desk', 'bookshelf', 'piano_bench', 'ceilinglamp', 'mat', 'clothes_socks', 'microphone', 'dining_room', 'bowl', 'nightstand', 'tray', 'curtain', 'diary', 'dresser', 'cupboard', 'spoon', 'bathroom_cabinet', 'table', 'dishwasher', 'light']\nTask:Open door\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'tablelamp', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'wallshelf', 'clothes_underwear', 'floor', 'desk', 'mail', 'button', 'stovefan', 'toaster', 'mousepad', 'soap', 'pillow', 'dining_room', 'photoframe', 'television', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'controller', 'bathtub', 'bathroom_cabinet', 'colander', 'clothes_shirt', 'coffee']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Find a cat in the kitchen and touch it,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'chair', 'band-aids', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'envelope', 'computer', 'ceilinglamp', 'tvstand', 'stereo', 'form', 'wall', 'nightstand', 'powersocket', 'cup', 'bed', 'photoframe', 'coffe_maker', 'check', 'centerpiece', 'dresser', 'food_steak', 'napkin', 'tooth_paste', 'shoe_rack']\nTask:Listen to music\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'pot', 'chair', 'freezer', 'food_carrot', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'thread', 'mail', 'ceilinglamp', 'mat', 'iron', 'balanceball', 'faucet', 'food_orange', 'pillow', 'wall', 'pasta', 'box', 'cup', 'newspaper', 'food_food', 'check', 'toilet_paper', 'chessboard', 'maindoor', 'napkin', 'creditcard']\nTask:Put groceries in Fridge\nresponse:\n{\n    \"thoughts\": Putting groceries in refridgerator,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[FIND] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']\n}\n", "input": "\nScene_Objects:['microwave', 'chair', 'walllamp', 'orchid', 'bills', 'cpuscreen', 'knifeblock', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'microphone', 'form', 'towel', 'wall', 'oven', 'food_food', 'television', 'ice', 'cards', 'mouse', 'pencil', 'cupboard', 'door', 'clothes_scarf', 'table']\nTask:Clean\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['band-aids', 'trashcan', 'wallshelf', 'clothes_underwear', 'desk', 'keyboard', 'mail', 'computer', 'tvstand', 'shower', 'window', 'clothes_socks', 'couch', 'food_peanut_butter', 'pillow', 'basket_for_clothes', 'keys', 'coffe_maker', 'television', 'food_donut', 'tray', 'rag', 'headset', 'clothes_scarf', 'bathtub', 'sink', 'light', 'dishwasher', 'soap', 'washing_machine']\nTask:Wash clothes\nresponse:\n{\n    \"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,\n    \"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>']\n}\n", "input": "\nScene_Objects:['sheets', 'mop', 'bathroom', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'desk', 'food_cake', 'window', 'electric_shaver', 'microphone', 'food_jam', 'dining_room', 'wall', 'photoframe', 'food_food', 'television', 'curtain', 'mouse', 'kitchen_counter', 'cd', 'chessboard', 'dresser', 'hairbrush', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher', 'instrument_violin']\nTask:Put on coat\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Wash teeth\nresponse:\n{\n    \"thoughts\": WALK TO THE BATHROOM USE PASTE AND BRUSH TO WASH YOUR TEETH,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <toothbrush_holder>', '[FIND] <toothbrush_holder>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'toilet', 'jelly', 'chair', 'trashcan', 'woman', 'orchid', 'bathroom_counter', 'thread', 'mail', 'toaster', 'mousepad', 'clothes_socks', 'candle', 'towel', 'dining_room', 'broom', 'pasta', 'powersocket', 'oven', 'food_food', 'after_shave', 'pencil', 'hair', 'hairdryer', 'door', 'napkin', 'home_office', 'colander', 'shoe_rack']\nTask:Greet guests\nresponse:\n", "output": {"thoughts": "Greet people into my home", "actions": ["[WALK] <home_office>", "[WALK] <woman>", "[FIND] <woman>", "[GREET] <woman>", "[FIND] <woman>", "[GREET] <woman>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'light']\nTask:Write an email\nresponse:\n{\n    \"thoughts\": I need to write an e-mail to my boss about the meeting at work tomorrow.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[TYPE] <keyboard>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>']\n}\n", "input": "\nScene_Objects:['microwave', 'walllamp', 'bathroom', 'detergent', 'food_carrot', 'orchid', 'drawing', 'cpuscreen', 'food_egg', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'stereo', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'basket_for_clothes', 'television', 'curtain', 'doorjamb', 'door', 'sink', 'table']\nTask:Watch TV\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'cat', 'ceilingfan', 'food_butter', 'drawing', 'longboard', 'floor', 'ceiling', 'shampoo', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'couch', 'clothes_pants', 'wall', 'wall_clock', 'bench', 'television', 'curtain', 'kettle', 'towel_rack', 'hair', 'pajamas', 'maindoor', 'home_office', 'table', 'vase']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": Changing channel,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[DROP] <remote_control>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'toilet', 'chair', 'ground_coffee', 'detergent', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'bookshelf', 'envelope', 'mat', 'shower', 'faucet', 'homework', 'mousepad', 'wall', 'toy', 'photoframe', 'check', 'coffee_filter', 'food_onion', 'shaving_cream', 'cards', 'mouse', 'dresser', 'hairbrush', 'door', 'soap', 'scrabble']\nTask:Clean\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'walllamp', 'dough', 'drawing', 'orchid', 'cpuscreen', 'food_egg', 'hanger', 'floor', 'keyboard', 'bookshelf', 'food_bacon', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'cup', 'novel', 'check', 'curtain', 'doorjamb', 'diary', 'pencil', 'kitchen_counter', 'bag', 'home_office', 'table', 'dishwasher', 'soap']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": move to living room, locate sofa, move to sofa, sit on sofa, lie on sofa,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'microwave', 'toilet', 'food_carrot', 'knife', 'drawing', 'bills', 'floor', 'desk', 'computer', 'food_bacon', 'bookmark', 'homework', 'candle', 'dining_room', 'wall', 'nightstand', 'toy', 'basket_for_clothes', 'bed', 'check', 'coffe_maker', 'television', 'mouse', 'hair', 'controller', 'conditioner', 'sink', 'spoon', 'home_office']\nTask:Breakfast\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Drink\nresponse:\n{\n    \"thoughts\": I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['walllamp', 'nail_polish', 'bathroom', 'detergent', 'knife', 'cpuscreen', 'dvd_player', 'bedroom', 'computer', 'table_cloth', 'mop_bucket', 'brush', 'toaster', 'shower', 'window', 'couch', 'dining_room', 'wall', 'pasta', 'cup', 'photoframe', 'after_shave', 'pencil', 'kitchen_counter', 'dresser', 'clothes_dress', 'sink', 'instrument_guitar', 'light', 'creditcard']\nTask:Sit\nresponse:\n", "output": {"thoughts": "We sit at the dining room table", "actions": ["[WALK] <dining_room>", "[WALK] <chair>", "[FIND] <chair>", "[PULL] <chair>", "[SIT] <chair>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'food_salt', 'chair', 'jelly', 'walllamp', 'milk', 'floor', 'bedroom', 'keyboard', 'button', 'plate', 'tvstand', 'shower', 'window', 'dustpan', 'dining_room', 'nightstand', 'oven', 'basket_for_clothes', 'check', 'coffe_maker', 'tray', 'controller', 'clothes_dress', 'food_steak', 'napkin', 'soap', 'clothes_shirt', 'scrabble', 'washing_machine']\nTask:Wash clothes\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['spectacles', 'pot', 'filing_cabinet', 'crayon', 'toilet', 'ground_coffee', 'drawing', 'bills', 'cpuscreen', 'clothes_underwear', 'orchid', 'floor', 'phone', 'ceiling', 'bookshelf', 'mat', 'shower', 'foundation', 'homework', 'dining_room', 'wall', 'tape', 'cutting_board', 'photoframe', 'newspaper', 'food_food', 'toothbrush_holder', 'curtain', 'kitchen_counter', 'soap']\nTask:Put clothes away\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'cd_player', 'walllamp', 'trashcan', 'food_carrot', 'drawing', 'needle', 'bathroom_counter', 'dvd_player', 'bedroom', 'bookshelf', 'alcohol', 'piano_bench', 'bookmark', 'laptop', 'stereo', 'couch', 'pillow', 'broom', 'bench', 'basket_for_clothes', 'mouse', 'shoes', 'headset', 'food_steak', 'sink', 'hairdryer', 'instrument_guitar', 'door', 'bag']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": Find the playback device you want to listen to. turn on. press play. enjoyu music.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']\n}\n", "input": "\nScene_Objects:['food_bread', 'food_salt', 'beer', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'clothes_underwear', 'floor', 'folder', 'man', 'computer', 'toaster', 'ceilinglamp', 'stereo', 'window', 'homework', 'mousepad', 'couch', 'microphone', 'pillow', 'wall', 'nightstand', 'keys', 'food_food', 'wooden_spoon', 'curtain', 'doorjamb', 'hair', 'table']\nTask:Have conversation with boyfriend\nresponse:\n", "output": {"thoughts": "Sit on sofa, talk", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[WALK] <couch>", "[SIT] <couch>", "[FIND] <man>", "[GREET] <man>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'toilet', 'chair', 'freezer', 'detergent', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'purse', 'toaster', 'mat', 'faucet', 'iron', 'mousepad', 'wall', 'powersocket', 'cup', 'coffe_maker', 'water', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'clothes_scarf', 'colander']\nTask:Drink\nresponse:\n{\n    \"thoughts\": I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'shower', 'mousepad', 'pillow', 'dining_room', 'wall', 'wall_clock', 'nightstand', 'tape', 'bed', 'console', 'mouse', 'clothes_scarf', 'light', 'soap', 'teeth']\nTask:Check email\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'microwave', 'toilet', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bedroom', 'bookshelf', 'plate', 'faucet', 'drying_rack', 'dish_soap', 'couch', 'dining_room', 'wall', 'oven', 'newspaper', 'photoframe', 'check', 'toilet_paper', 'kitchen_counter', 'cupboard', 'sink', 'bathtub', 'table']\nTask:Wash dishes by hand\nresponse:\n{\n    \"thoughts\": I walk in to the Kitchen. I find a plate, a sponge, and the dish soap. I find the faucet. I turn the faucet on. I pour water on the sponge and plate. I add dish soap to the sponge. I put the dish soap back. I scrub the plate. I rinse the plate. I place the plate on the drying rack. I rinse the sponge. I turn the faucet off.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <sponge>', '[GRAB] <sponge>', '[RINSE] <sponge>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[FIND] <drying_rack>', '[PUTBACK] <plate> <plate>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[SWITCHOFF] <faucet>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'crayon', 'walllamp', 'woman', 'knifeblock', 'hanger', 'ceiling', 'folder', 'character', 'man', 'mop_bucket', 'bookmark', 'shower', 'window', 'electric_shaver', 'pillow', 'dining_room', 'wall_clock', 'cutting_board', 'bed', 'television', 'wine', 'curtain', 'mouse', 'pencil', 'sink', 'home_office', 'light', 'dirt', 'shoe_rack']\nTask:Greet people\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'beer', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'stovefan', 'mat', 'toaster', 'shower', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'food_food', 'food_donut', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']\nTask:Cook some food\nresponse:\n{\n    \"thoughts\": Walk into the kitchen. Open the fridge. Take out the chicken. Open the kitchen cabinet. Take out the frying pan. Put the chicken in the frying pan. Put the frying pan on the stove. Turn on the stove. Cook the chicken.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[CLOSE] <freezer>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <pot>', '[GRAB] <pot>', '[CLOSE] <kitchen_cabinet>', '[WALK] <oven>', '[PUTBACK] <pot> <oven>', '[PUTBACK] <food_chicken> <oven>', '[SWITCHON] <oven>']\n}\n", "input": "\nScene_Objects:['walllamp', 'drawing', 'orchid', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'basket_for_clothes', 'food_cheese', 'television', 'curtain', 'doorjamb', 'cd', 'conditioner', 'door', 'clothes_scarf', 'home_office', 'table', 'dishwasher', 'instrument_guitar']\nTask:Watch TV\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['chair', 'trashcan', 'orchid', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'window', 'food_noodles', 'couch', 'pillow', 'wall', 'photoframe', 'toothbrush_holder', 'curtain', 'doorjamb', 'chessboard', 'door', 'bathtub', 'bag', 'home_office', 'light', 'table', 'dishwasher', 'instrument_violin']\nTask:Admire art\nresponse:\n{\n    \"thoughts\": Looking at painting, art,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']\n}\n", "input": "\nScene_Objects:['glue', 'pot', 'toilet', 'chair', 'freezer', 'band-aids', 'bathroom', 'food_carrot', 'drawing', 'floor', 'mat', 'window', 'couch', 'clothes_hat', 'form', 'pillow', 'bench', 'food_food', 'check', 'coffe_maker', 'toilet_paper', 'ice', 'centerpiece', 'doorjamb', 'cupboard', 'home_office', 'table', 'light', 'bathroom_cabinet', 'scrabble']\nTask:Eat dinner\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'trashcan', 'drawing', 'floor', 'character', 'desk', 'purse', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'couch', 'pillow', 'nightstand', 'powersocket', 'novel', 'tray', 'mouse', 'bathroom_cabinet', 'soap', 'teeth']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['chair', 'walllamp', 'cat', 'food_carrot', 'toothbrush', 'drawing', 'orchid', 'floor', 'mail', 'stovefan', 'ceilinglamp', 'window', 'mousepad', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'photoframe', 'mouthwash', 'tray', 'curtain', 'coffee_pot', 'pajamas', 'door', 'sink', 'bathroom_cabinet', 'table', 'light', 'tooth_paste']\nTask:Relax\nresponse:\n", "output": {"thoughts": "Lie down on the couch.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[LIE] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Go to the book shelf, get a book, open the book and read the book.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'tea', 'chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'pasta', 'powersocket', 'coffe_maker', 'doorjamb', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'home_office', 'table', 'tooth_paste']\nTask:Turn on computer\nresponse:\n", "output": {"thoughts": "Push power button.", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light']\nTask:Greet guests\nresponse:\n{\n    \"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.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']\n}\n", "input": "\nScene_Objects:['blender', 'detergent', 'orchid', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'purse', 'envelope', 'mat', 'window', 'foundation', 'broom', 'wall', 'nightstand', 'keys', 'novel', 'check', 'toothbrush_holder', 'oven_mitts', 'curtain', 'doorjamb', 'mouse', 'dresser', 'hairdryer', 'home_office', 'clothes_shirt', 'coffee', 'creditcard']\nTask:Put on coat\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'fork', 'blender', 'food_ice_cream', 'food_butter', 'phone', 'character', 'bookshelf', 'brush', 'ceilinglamp', 'plate', 'shower', 'iron', 'stereo', 'toaster', 'oil', 'food_orange', 'pillow', 'cup', 'food_food', 'check', 'oven_mitts', 'food_donut', 'food_onion', 'after_shave', 'mouse', 'hairdryer', 'bag', 'bathroom_cabinet', 'home_office']\nTask:Set up table\nresponse:\n{\n    \"thoughts\": Walk into kitchen, find plate, drop plate on table in living room, walk into kitchen, find cup, bring cup to table in living room, walk into kitchen find fork, bring fork to table in living room,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <home_office>', '[DROP] <plate>', '[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <home_office>', '[DROP] <cup>', '[WALK] <dining_room>', '[WALK] <fork>', '[FIND] <fork>', '[GRAB] <fork>', '[WALK] <home_office>', '[DROP] <fork>']\n}\n", "input": "\nScene_Objects:['chair', 'band-aids', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'mousepad', 'oil', 'broom', 'wall', 'nightstand', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'coin', 'food_donut', 'lighter', 'mouse', 'chessboard', 'door', 'table', 'dirt']\nTask:Turking\nresponse:\n", "output": {"thoughts": "Do a random variety very small jobs from different clients on mturk.Com", "actions": ["[WALK] <home_office>", "[WALK] <desk>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <computer>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'toilet', 'dog', 'cat', 'drawing', 'wallshelf', 'ceiling', 'folder', 'character', 'cleaning_solution', 'envelope', 'computer', 'brush', 'toaster', 'iron', 'mousepad', 'closetdrawer', 'couch', 'bed', 'photoframe', 'novel', 'coffe_maker', 'centerpiece', 'hair', 'cupboard', 'sink', 'home_office', 'light', 'dirt', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": walk to bathroom , find cleaning solution , squeeze cleaning solution , wash hands,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[SQUEEZE] <cleaning_solution>', '[FIND] <hands_both>', '[WASH] <hands_both>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'tablelamp', 'food_salt', 'cd_player', 'chair', 'freezer', 'bathroom', 'food_carrot', 'orchid', 'knifeblock', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'remote_control', 'computer', 'window', 'mousepad', 'wall', 'nightstand', 'light_bulb', 'check', 'food_onion', 'curtain', 'mouse', 'door', 'light', 'tooth_paste']\nTask:Listen to music\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'food_ice_cream', 'toilet', 'bathroom', 'detergent', 'ceilingfan', 'food_butter', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'pillow', 'wall', 'food_food', 'television', 'tray', 'curtain', 'after_shave', 'cupboard', 'table', 'laser_pointer']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": TURN ON TV, SIT ON COUCH ACROSS THE ROOM, USE REMOTE TO LOOK FOR SHOW TO WATCH,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['food_bread', 'filing_cabinet', 'toilet', 'jelly', 'walllamp', 'drawing', 'orchid', 'needle', 'bathroom_counter', 'floor', 'folder', 'keyboard', 'toaster', 'ceilinglamp', 'window', 'food_noodles', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'light_bulb', 'television', 'curtain', 'food_onion', 'chessboard', 'cupboard', 'door', 'napkin', 'instrument_guitar', 'table']\nTask:Relax on sofa\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Get dressed\nresponse:\n{\n    \"thoughts\": Open drawer. Pull out pants and put them on. Take a shirt out and put it on. Put on socks and shoes.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'filing_cabinet', 'food_pizza', 'tablelamp', 'microwave', 'toilet', 'freezer', 'bathroom', 'drawing', 'needle', 'floor', 'shampoo', 'desk', 'bookshelf', 'shower', 'food_noodles', 'wall', 'powersocket', 'cup', 'photoframe', 'novel', 'food_donut', 'tray', 'curtain', 'doorjamb', 'shaving_cream', 'pencil', 'door', 'home_office']\nTask:Go to toilet\nresponse:\n", "output": {"thoughts": "I go to the bathroom. I locate the toilet. I walk to the toilet.", "actions": ["[WALK] <bathroom>", "[WALK] <toilet>", "[FIND] <toilet>", "[WALK] <toilet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'food_carrot', 'drawing', 'floor', 'character', 'computer', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'candle', 'wall', 'wall_clock', 'oven', 'cup', 'photoframe', 'bed', 'novel', 'check', 'toilet_paper', 'television', 'curtain', 'towel_rack', 'mouse', 'hairbrush', 'laundry_detergent', 'table', 'clothes_skirt']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Walk to the couch in the living room, sit on ti and read the book,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['microwave', 'walllamp', 'dough', 'drawing', 'orchid', 'cpuscreen', 'food_egg', 'hanger', 'floor', 'keyboard', 'bookshelf', 'food_bacon', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'cup', 'novel', 'check', 'curtain', 'doorjamb', 'diary', 'pencil', 'kitchen_counter', 'bag', 'home_office', 'table', 'dishwasher', 'soap']\nTask:Relax on sofa\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'tablelamp', 'chair', 'walllamp', 'bathroom', 'trashcan', 'ceilingfan', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'computer', 'laptop', 'balanceball', 'mousepad', 'pillow', 'wall', 'cup', 'bed', 'television', 'razor', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'spoon', 'light', 'vase']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": push any ligth button to turn it on, for example in the living room,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'walllamp', 'orchid', 'drawing', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'iron', 'window', 'shower', 'couch', 'pillow', 'food_kiwi', 'wall', 'pasta', 'powersocket', 'bed', 'check', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'controller', 'door', 'table']\nTask:Watch TV\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'pot', 'food_salt', 'jelly', 'walllamp', 'detergent', 'knife', 'drawing', 'hanger', 'floor', 'dvd_player', 'character', 'desk', 'bedroom', 'plate', 'dish_soap', 'oil', 'wall', 'powersocket', 'bed', 'light_bulb', 'coffe_maker', 'toilet_paper', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Put dishes in the dishwasher and start the dishwasher.,\n    \"actions\": ['[RUN] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[WALK] <dishwasher>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_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']\nTask:Work\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'pot', 'tea', 'microwave', 'walllamp', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'stovefan', 'toaster', 'faucet', 'stereo', 'bowl', 'food_kiwi', 'wall', 'oven', 'bed', 'coffe_maker', 'food_food', 'drinking_glass', 'food_donut', 'tray', 'after_shave', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'clothes_skirt']\nTask:Drink\nresponse:\n{\n    \"thoughts\": First I go into the kitchen, open the cupboard and find a glass.Then I close the cupboard. Then I go to the sink, turn the faucet on fill the glass under the faucet. I turn off the faucet and then I drink.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>']\n}\n", "input": "\nScene_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']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "find a cat, touch it gently", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'scissors', 'microwave', 'chair', 'freezer', 'food_butter', 'drawing', 'knife', 'cpuscreen', 'floor', 'folder', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'shower', 'mousepad', 'wall', 'nightstand', 'bed', 'ice', 'after_shave', 'doorjamb', 'mouse', 'kitchen_counter', 'food_steak', 'light']\nTask:Work\nresponse:\n{\n    \"thoughts\": I work on my HP computer.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <bed>', '[SIT] <bed>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>']\n}\n", "input": "\nScene_Objects:['toilet', 'freezer', 'walllamp', 'food_butter', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'stereo', 'faucet', 'window', 'mousepad', 'pillow', 'wall', 'powersocket', 'bed', 'coffee_table', 'television', 'doorjamb', 'pencil', 'dresser', 'clothes_dress', 'door', 'table', 'dishwasher']\nTask:Change TV channel\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'measuring_cup', 'chair', 'nail_polish', 'cat', 'drawing', 'hanger', 'floor', 'phone', 'desk', 'keyboard', 'food_bacon', 'table_cloth', 'bookmark', 'stovefan', 'plate', 'shower', 'dish_soap', 'couch', 'wall', 'powersocket', 'basket_for_clothes', 'toilet_paper', 'pencil', 'hair', 'home_office', 'light', 'dishwasher', 'shoe_rack']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['pot', 'microwave', 'nail_polish', 'bathroom', 'cat', 'detergent', 'trashcan', 'milk', 'orchid', 'knife', 'computer', 'food_bacon', 'faucet', 'stereo', 'oil', 'food_noodles', 'microphone', 'dining_room', 'nightstand', 'oven', 'food_cheese', 'novel', 'check', 'coffe_maker', 'food_onion', 'coffee_pot', 'kitchen_counter', 'dresser', 'hairdryer', 'home_office']\nTask:Read book\nresponse:\n", "output": {"thoughts": "go to bedroom, sit down, pick up book, read", "actions": ["[WALK] <home_office>", "[WALK] <novel>", "[FIND] <novel>", "[GRAB] <novel>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'pot', 'measuring_cup', 'microwave', 'chair', 'orchid', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'cleaning_solution', 'keyboard', 'mop_bucket', 'stovefan', 'faucet', 'couch', 'clothes_pants', 'coffe_maker', 'mirror', 'curtain', 'rag', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'sink', 'dishwasher']\nTask:Clean mirror\nresponse:\n{\n    \"thoughts\": Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'food_bread', 'toilet', 'bathroom', 'milk', 'drawing', 'floor', 'ceiling', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'towel', 'wall', 'bench', 'cup', 'photoframe', 'toothbrush_holder', 'water', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'clothes_skirt', 'soap']\nTask:Take shower\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'detergent', 'food_butter', 'dough', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'faucet', 'stereo', 'picture', 'dustpan', 'bowl', 'dining_room', 'wall', 'oven', 'powersocket', 'photoframe', 'wine', 'tray', 'console', 'pencil', 'sink', 'bathroom_cabinet', 'dishwasher', 'hands_both', 'shoe_rack']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'walllamp', 'knifeblock', 'drawing', 'cpuscreen', 'clothes_underwear', 'knife', 'floor', 'ceiling', 'cleaning_solution', 'piano_bench', 'toaster', 'ceilinglamp', 'faucet', 'stereo', 'iron', 'wall', 'oven', 'cutting_board', 'tape', 'check', 'coin', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bag', 'home_office', 'instrument_violin', 'hands_both']\nTask:Wash hands\nresponse:\n", "output": {"thoughts": "Washing hands", "actions": ["[WALK] <dining_room>", "[WALK] <faucet>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <hands_both>", "[RINSE] <hands_both>", "[SWITCHOFF] <faucet>", "[FIND] <cleaning_solution>", "[SQUEEZE] <cleaning_solution>", "[SCRUB] <hands_both>", "[SWITCHON] <faucet>", "[RINSE] <hands_both>", "[SWITCHOFF] <faucet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'blender', 'freezer', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'orchid', 'hanger', 'floor', 'bedroom', 'keyboard', 'computer', 'stereo', 'window', 'oil', 'couch', 'pillow', 'wall', 'cup', 'bed', 'food_donut', 'curtain', 'centerpiece', 'console', 'shoes', 'dresser', 'maindoor', 'home_office', 'light']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": Turn on radio, put on favorite channel, listen to music.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>', '[FIND] <bed>', '[LIE] <bed>']\n}\n", "input": "\nScene_Objects:['toilet', 'detergent', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'bedroom', 'food_cake', 'stovefan', 'mat', 'faucet', 'window', 'wall', 'oven', 'cup', 'photoframe', 'curtain', 'after_shave', 'doorjamb', 'cards', 'shoes', 'food_steak', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_ice_cream', 'toilet', 'freezer', 'trashcan', 'drawing', 'floor', 'phone', 'ceiling', 'character', 'bedroom', 'desk', 'keyboard', 'toaster', 'mat', 'faucet', 'window', 'wall', 'wall_clock', 'powersocket', 'box', 'cup', 'bed', 'video_game_controller', 'television', 'doorjamb', 'console', 'kitchen_counter', 'door', 'light', 'teeth']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": I walk over to the phone and pick it up.,\n    \"actions\": ['[WALK] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'shoe_rack', 'toilet', 'chair', 'band-aids', 'freezer', 'walllamp', 'cat', 'trashcan', 'folder', 'bookshelf', 'deck_of_cards', 'shower', 'mousepad', 'food_kiwi', 'wall', 'powersocket', 'cup', 'bed', 'clothes_gloves', 'keys', 'television', 'kitchen_counter', 'dishrack', 'controller', 'napkin', 'light', 'soap', 'creditcard']\nTask:Pet cat\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['measuring_cup', 'microwave', 'toilet', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'phone', 'food_cake', 'computer', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'stereo', 'electric_shaver', 'homework', 'balanceball', 'picture', 'window', 'dining_room', 'powersocket', 'cup', 'photoframe', 'mirror', 'tray', 'pencil', 'shoes', 'conditioner', 'sink', 'creditcard']\nTask:Shave\nresponse:\n{\n    \"thoughts\": Pick up razor.  Push the button to turn it on.  Move it in a linear motion against the beard growth.  Make sure to get the bottom of your chin, your cheeks, and mustache area.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <electric_shaver>', '[FIND] <electric_shaver>', '[GRAB] <electric_shaver>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[SWITCHON] <electric_shaver>', '[SWITCHOFF] <electric_shaver>', '[PUTOBJBACK] <electric_shaver>']\n}\n", "input": "\nScene_Objects:['sheets', 'spectacles', 'food_salt', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'purse', 'computer', 'ceilinglamp', 'window', 'mousepad', 'food_noodles', 'wall', 'powersocket', 'clothes_gloves', 'food_food', 'toilet_paper', 'television', 'check', 'tray', 'doorjamb', 'cards', 'mouse', 'door', 'light', 'table']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['mop', 'microwave', 'bathroom', 'detergent', 'wallshelf', 'clothes_underwear', 'hanger', 'ceiling', 'bookshelf', 'tvstand', 'faucet', 'deck_of_cards', 'window', 'clothes_socks', 'clothes_pants', 'cup', 'standingmirror', 'photoframe', 'check', 'tray', 'kitchen_counter', 'hair', 'laundry_detergent', 'door', 'bathroom_cabinet', 'tooth_paste', 'clothes_shirt', 'washing_machine', 'coffee', 'shoe_rack']\nTask:Wash clothes\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['pot', 'beer', 'microwave', 'jelly', 'freezer', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'tea_bag', 'keyboard', 'purse', 'computer', 'iron', 'window', 'mousepad', 'oil', 'wall', 'powersocket', 'bed', 'keys', 'mouthwash', 'wine', 'doorjamb', 'mouse', 'cupboard', 'door', 'sink', 'light']\nTask:Turn on light\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'beer', 'chair', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'cleaning_solution', 'bookmark', 'iron', 'mousepad', 'couch', 'dustpan', 'food_jam', 'tape', 'television', 'wooden_spoon', 'curtain', 'rag', 'doorjamb', 'hairbrush', 'cupboard', 'door', 'bathroom_cabinet', 'table', 'vase', 'colander', 'teeth']\nTask:Clean mirror\nresponse:\n{\n    \"thoughts\": Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']\n}\n", "input": "\nScene_Objects:['food_ice_cream', 'microwave', 'freezer', 'trashcan', 'toothbrush', 'orchid', 'hanger', 'desk', 'keyboard', 'bookmark', 'shoe-shine_kit', 'iron', 'tvstand', 'plate', 'mousepad', 'microphone', 'wall', 'bench', 'toilet_paper', 'television', 'toothbrush_holder', 'ice', 'shoes', 'chessboard', 'hairbrush', 'cupboard', 'bathroom_cabinet', 'tooth_paste', 'teeth', 'creditcard']\nTask:Wash teeth\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'glue', 'tablelamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'purse', 'computer', 'clothes_jacket', 'toaster', 'stereo', 'mousepad', 'closetdrawer', 'couch', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'bed', 'novel', 'mouse', 'shoes', 'dresser', 'clothes_dress', 'light', 'table']\nTask:Get ready for day\nresponse:\n{\n    \"thoughts\": Grab shoes, purse etc and head out the door!,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <purse>', '[GRAB] <purse>', '[CLOSE] <dresser>', '[WALK] <home_office>']\n}\n", "input": "\nScene_Objects:['glue', 'fork', 'food_pizza', 'tablelamp', 'crayon', 'measuring_cup', 'dough', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'food_cake', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'powersocket', 'bench', 'cup', 'colander', 'mouse', 'hairbrush', 'sink', 'spoon', 'bathroom_cabinet', 'light', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'character', 'desk', 'bedroom', 'keyboard', 'thread', 'toaster', 'plate', 'couch', 'wall', 'light_bulb', 'novel', 'coffe_maker', 'food_rice', 'tray', 'food_onion', 'after_shave', 'curtain', 'kettle', 'kitchen_counter', 'shoes', 'cupboard', 'conditioner', 'door', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['spectacles', 'water_glass', 'glue', 'walllamp', 'detergent', 'food_carrot', 'toothbrush', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'computer', 'ceilinglamp', 'tvstand', 'window', 'couch', 'clothes_pants', 'form', 'pillow', 'wall', 'nightstand', 'box', 'curtain', 'pencil', 'headset', 'dresser', 'table', 'board_game', 'shoe_rack']\nTask:Relax on sofa\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'walllamp', 'nail_polish', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'toaster', 'stovefan', 'faucet', 'towel', 'pillow', 'wall', 'wall_clock', 'bed', 'check', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'controller', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": Cleaning hands,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']\n}\n", "input": "\nScene_Objects:['sheets', 'tablelamp', 'blender', 'freezer', 'walllamp', 'dough', 'orchid', 'drawing', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'picture', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'dishrack', 'door', 'sink', 'table']\nTask:Watch TV\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'juice', 'microwave', 'freezer', 'blow_dryer', 'ground_coffee', 'cat', 'floor', 'legs_both', 'face', 'toaster', 'laptop', 'homework', 'closetdrawer', 'towel', 'feet_both', 'arms_both', 'basket_for_clothes', 'newspaper', 'photoframe', 'coffe_maker', 'mouthwash', 'centerpiece', 'doorjamb', 'headset', 'dresser', 'cupboard', 'napkin', 'soap', 'clothes_shirt']\nTask:Try yourself off\nresponse:\n{\n    \"thoughts\": After your shower, go into your bedroom and use a towel to dry water off of yourself before dressing.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[OPEN] <dresser>', '[FIND] <towel>', '[GRAB] <towel>', '[CLOSE] <dresser>', '[FIND] <face>', '[WIPE] <face>', '[FIND] <arms_both>', '[WIPE] <arms_both>', '[FIND] <legs_both>', '[WIPE] <legs_both>', '[FIND] <feet_both>', '[WIPE] <feet_both>', '[FIND] <basket_for_clothes>', '[PUTBACK] <towel> <basket_for_clothes>']\n}\n", "input": "\nScene_Objects:['pot', 'chair', 'walllamp', 'ground_coffee', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'plate', 'homework', 'mousepad', 'dining_room', 'wall', 'bench', 'newspaper', 'novel', 'check', 'mouse', 'kitchen_counter', 'hair', 'door', 'sink', 'home_office', 'table']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "I sit at my computer desk and open the browser.", "actions": ["[WALK] <home_office>", "[WALK] <desk>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <computer>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'toilet', 'chair', 'freezer', 'walllamp', 'ceiling', 'bedroom', 'keyboard', 'toaster', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'clothes_pants', 'food_orange', 'nightstand', 'bench', 'photoframe', 'bed', 'food_food', 'tray', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'bathroom_cabinet', 'table', 'washing_machine']\nTask:Wash clothes\nresponse:\n{\n    \"thoughts\": Walk into laundry room. Open washing machine door. Put dirty clothes into washing machine. Measure laundry detergent and place into washing machine. Turn dial to appropriate wash setting. Power on.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[PUTBACK] <clothes_pants> <washing_machine>', '[CLOSE] <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[OPEN] <washing_machine>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']\n}\n", "input": "\nScene_Objects:['fork', 'pot', 'microwave', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'toaster', 'stovefan', 'faucet', 'wall', 'pasta', 'oven', 'coffe_maker', 'food_food', 'check', 'coffee_filter', 'television', 'water', 'tray', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'clothes_scarf', 'dishwasher']\nTask:Make coffee\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'detergent', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'remote_control', 'button', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'clothes_socks', 'couch', 'wall', 'basket_for_clothes', 'light_bulb', 'television', 'razor', 'curtain', 'food_onion', 'towel_rack', 'coffee_pot', 'pencil', 'kitchen_counter', 'bag', 'table']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": turn on the tv,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']\n}\n", "input": "\nScene_Objects:['scissors', 'blender', 'freezer', 'walllamp', 'trashcan', 'orchid', 'knife', 'bathroom_counter', 'shampoo', 'character', 'desk', 'folder', 'keyboard', 'stovefan', 'mat', 'picture', 'window', 'food_noodles', 'bench', 'toothbrush_holder', 'food_donut', 'after_shave', 'doorjamb', 'cards', 'kitchen_counter', 'vacuum_cleaner', 'dishrack', 'door', 'home_office', 'bathroom_cabinet']\nTask:Pick up phone\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'microwave', 'toilet', 'chair', 'dog', 'cpuscreen', 'keyboard', 'ceilinglamp', 'plate', 'laptop', 'faucet', 'window', 'stereo', 'oil', 'food_noodles', 'mousepad', 'dining_room', 'nightstand', 'food_food', 'check', 'wine', 'curtain', 'after_shave', 'comb', 'dresser', 'napkin', 'home_office', 'table', 'bathroom_cabinet', 'light']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": I reach out arm. I put hand on radio. I turn on radio. I pick a station.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <stereo>', '[TOUCH] <stereo>', '[TURNTO] <stereo>']\n}\n", "input": "\nScene_Objects:['fork', 'microwave', 'chair', 'detergent', 'trashcan', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'purse', 'computer', 'toaster', 'mat', 'tvstand', 'clothes_socks', 'food_peanut_butter', 'microphone', 'food_jam', 'pillow', 'wall', 'powersocket', 'after_shave', 'doorjamb', 'cd', 'pajamas', 'laundry_detergent', 'door', 'light', 'tooth_paste']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "Coming home turning on lights.", "actions": ["[WALK] <home_office>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'mousepad', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'bathroom_cabinet', 'table']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": Walk to the Home Office.  Find the computer.  Turn on the computer.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']\n}\n", "input": "\nScene_Objects:['fork', 'pot', 'microwave', 'walllamp', 'trashcan', 'knife', 'drawing', 'floor', 'computer', 'toaster', 'mat', 'plate', 'faucet', 'ceilinglamp', 'stovefan', 'dish_soap', 'oil', 'wall', 'powersocket', 'tape', 'coffe_maker', 'television', 'drinking_glass', 'rag', 'shaving_cream', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'clothes_skirt']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "Walk to the kitchen and turn to the dishwasher, put the knife, glass, fork and plate into the dishwasher. Turn on the dishwasher.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[TURNTO] <dishwasher>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[OPEN] <dishwasher>", "[PUTBACK] <dish_soap> <dishwasher>", "[FIND] <drinking_glass>", "[GRAB] <drinking_glass>", "[PUTBACK] <drinking_glass> <dishwasher>", "[FIND] <fork>", "[GRAB] <fork>", "[PUTBACK] <fork> <dishwasher>", "[FIND] <knife>", "[GRAB] <knife>", "[PUTBACK] <knife> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": I sit on my couch and watch TV in my living room,\n    \"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>']\n}\n", "input": "\nScene_Objects:['toilet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'iron', 'faucet', 'mousepad', 'bowl', 'wall', 'nightstand', 'oven', 'mouse', 'cupboard', 'door', 'clothes_scarf', 'bathroom_cabinet', 'table', 'instrument_guitar']\nTask:Work\nresponse:\n", "output": {"thoughts": "For doing homework walk to home office. Walk to computer. Switch on Computer. Sit in a chair and do homework in computer.", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[WALK] <computer>", "[FIND] <chair>", "[SIT] <chair>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'food_salt', 'beer', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'clothes_underwear', 'floor', 'folder', 'man', 'computer', 'toaster', 'ceilinglamp', 'stereo', 'window', 'homework', 'mousepad', 'couch', 'microphone', 'pillow', 'wall', 'nightstand', 'keys', 'food_food', 'wooden_spoon', 'curtain', 'doorjamb', 'hair', 'table']\nTask:Have conversation with boyfriend\nresponse:\n{\n    \"thoughts\": Sit on sofa, talk,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <man>', '[GREET] <man>']\n}\n", "input": "\nScene_Objects:['microwave', 'chair', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'electric_shaver', 'mousepad', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'newspaper', 'bed', 'food_food', 'wine', 'doorjamb', 'cards', 'mouse', 'shoes', 'dresser', 'door', 'light', 'dirt']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"thoughts": "walk to kitchen, walk to fridge, look at bags, grab groceries, put groceries in fridge.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <food_food>", "[GRAB] <food_food>", "[OPEN] <freezer>", "[PUTIN] <food_food> <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'woman', 'knifeblock', 'needle', 'cpuscreen', 'desk', 'man', 'keyboard', 'bedroom', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'nightstand', 'oven', 'cup', 'food_food', 'check', 'doorjamb', 'mouse', 'kitchen_counter', 'bathtub', 'bathroom_cabinet', 'table', 'light']\nTask:Greet guests\nresponse:\n{\n    \"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.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'freezer', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'phone', 'ceiling', 'character', 'bookshelf', 'food_cake', 'mat', 'tvstand', 'shoe-shine_kit', 'homework', 'oil', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'bench', 'oven', 'powersocket', 'toilet_paper', 'kitchen_counter', 'door', 'tooth_paste']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "walk over and pick up the phone", "actions": ["[WALK] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'freezer', 'knife', 'floor', 'ceiling', 'folder', 'stamp', 'brush', 'mat', 'ceilinglamp', 'shower', 'faucet', 'toaster', 'pillow', 'bowl', 'food_kiwi', 'wall', 'powersocket', 'toilet_paper', 'mouthwash', 'doorjamb', 'door', 'home_office', 'light', 'table']\nTask:Turn light off\nresponse:\n{\n    \"thoughts\": Put the light switch into the down, or off, position.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>']\n}\n", "input": "\nScene_Objects:['fork', 'glue', 'board_game', 'toilet', 'bathroom', 'dough', 'toothbrush', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'mat', 'faucet', 'window', 'wall', 'photoframe', 'food_food', 'toothbrush_holder', 'razor', 'tray', 'after_shave', 'doorjamb', 'vacuum_cleaner', 'conditioner', 'sink', 'napkin', 'bathroom_cabinet', 'soap', 'tooth_paste']\nTask:Wash teeth\nresponse:\n", "output": {"thoughts": "I go into the bathroom, go to the sink, get toothbrush and toothpaste. Put toothpaste on the toothbrush, brush teeth, turn on faucet, rinse brush, and return toothbrush.", "actions": ["[WALK] <bathroom>", "[WALK] <sink>", "[FIND] <toothbrush_holder>", "[TURNTO] <toothbrush_holder>", "[LOOKAT] <toothbrush_holder>", "[FIND] <toothbrush>", "[GRAB] <toothbrush>", "[FIND] <tooth_paste>", "[GRAB] <tooth_paste>", "[PUTBACK] <tooth_paste> <toothbrush_holder>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[RINSE] <toothbrush>", "[PUTBACK] <toothbrush> <toothbrush_holder>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'filing_cabinet', 'food_pizza', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'cleaning_solution', 'mail', 'brush', 'toaster', 'tvstand', 'balanceball', 'window', 'food_noodles', 'mousepad', 'food_peanut_butter', 'clothes_hat', 'dining_room', 'pasta', 'bench', 'photoframe', 'oven_mitts', 'ice', 'rag', 'dresser', 'cupboard', 'food_steak', 'maindoor', 'table']\nTask:Clean  mirror\nresponse:\n{\n    \"thoughts\": GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']\n}\n", "input": "\nScene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'walllamp', 'trashcan', 'dough', 'toothbrush', 'floor', 'dvd_player', 'bedroom', 'stovefan', 'mat', 'tvstand', 'window', 'food_noodles', 'dining_room', 'nightstand', 'powersocket', 'oven', 'cutting_board', 'cup', 'light_bulb', 'coffe_maker', 'mouthwash', 'oven_mitts', 'doorjamb', 'diary', 'bag', 'home_office', 'scrabble']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "go to living room, find phone, pick up phone", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['freezer', 'walllamp', 'ground_coffee', 'knifeblock', 'cpuscreen', 'longboard', 'floor', 'phone', 'bedroom', 'toaster', 'faucet', 'pillow', 'wall', 'bed', 'novel', 'water', 'tray', 'centerpiece', 'cards', 'kitchen_counter', 'shoes', 'dresser', 'cupboard', 'conditioner', 'sink', 'bag', 'napkin', 'table', 'dishwasher', 'board_game']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['pot', 'jelly', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'food_chicken', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'mousepad', 'oil', 'wall', 'powersocket', 'oven', 'food_food', 'tray', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']\nTask:Cook some food\nresponse:\n", "output": {"thoughts": "I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_chicken>", "[GRAB] <food_chicken>", "[FIND] <pot>", "[GRAB] <pot>", "[FIND] <oven>", "[PUTBACK] <pot> <oven>", "[PUTBACK] <food_chicken> <oven>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'chair', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'floor_lamp', 'mousepad', 'couch', 'dining_room', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'doorjamb', 'cd', 'door', 'bathtub', 'home_office', 'light']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": walk to wall, find light switch, turn on lights,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[WALK] <bedroom>', '[WALK] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'dry_pasta', 'bathroom', 'toothbrush', 'drawing', 'knifeblock', 'phone', 'character', 'clothes_jacket', 'piano_bench', 'mat', 'shoe-shine_kit', 'stereo', 'window', 'oil', 'nightstand', 'cup', 'clothes_gloves', 'check', 'wine', 'tray', 'console', 'pencil', 'dresser', 'hair', 'door', 'clothes_skirt', 'dishwasher', 'clothes_shirt']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Pet Cat", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[WALK] <cat>", "[TURNTO] <cat>", "[LOOKAT] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'chair', 'freezer', 'food_butter', 'drawing', 'bills', 'cpuscreen', 'longboard', 'floor', 'bedroom', 'desk', 'bookshelf', 'button', 'bookmark', 'toaster', 'ceilinglamp', 'deck_of_cards', 'iron', 'tvstand', 'pillow', 'pasta', 'bench', 'powersocket', 'bed', 'coffe_maker', 'television', 'ice', 'mouse', 'dresser', 'controller']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": walk into living room, look at the phone when it ringing, grab the phone or pickup the phone,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>']\n}\n", "input": "\nScene_Objects:['walllamp', 'toothbrush', 'drawing', 'orchid', 'floor', 'ceiling', 'remote_control', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'box', 'basket_for_clothes', 'novel', 'check', 'television', 'tray', 'curtain', 'doorjamb', 'door', 'table', 'clothes_skirt', 'creditcard']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "Walk to living room. Walk to and sit at the sofa. Grab remote control and switch on TV.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[SIT] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Clean\nresponse:\n{\n    \"thoughts\": Wipe down computer desk and monitor,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <desk>', '[FIND] <computer>', '[WIPE] <computer>', '[WIPE] <desk>', '[PUTOBJBACK] <rag>']\n}\n", "input": "\nScene_Objects:['microwave', 'walllamp', 'trashcan', 'drawing', 'floor', 'character', 'toaster', 'plate', 'tvstand', 'foundation', 'dish_soap', 'tooth_paste', 'wall', 'cup', 'coffe_maker', 'food_food', 'food_onion', 'centerpiece', 'cards', 'kettle', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'door', 'sink', 'light', 'dishwasher', 'board_game', 'clothes_shirt', 'creditcard']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "Wash a plate using the dishwasher in the kitchen.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[PUTBACK] <dish_soap> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'sheets', 'pot', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mail', 'tvstand', 'stereo', 'window', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'powersocket', 'pasta', 'oven', 'light_bulb', 'coffe_maker', 'food_rice', 'doorjamb', 'shaving_cream', 'mouse', 'kitchen_counter', 'door', 'light']\nTask:Turn light off\nresponse:\n{\n    \"thoughts\": Put the light switch into the down, or off, position.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHOFF] <light>']\n}\n", "input": "\nScene_Objects:['walllamp', 'trashcan', 'toothbrush', 'drawing', 'orchid', 'needle', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'bookshelf', 'remote_control', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'wall', 'powersocket', 'television', 'food_rice', 'doorjamb', 'pencil', 'chessboard', 'door', 'hairdryer', 'bathroom_cabinet', 'table', 'scrabble']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "I go to the livingroom. The TV is on. I pick up the remote and press the next channel button. I look at the television, and see that the channel has changed.", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[TURNTO] <television>", "[LOOKAT] <television>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <button>", "[PUSH] <button>", "[TURNTO] <television>", "[LOOKAT] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'chair', 'jelly', 'trashcan', 'toothbrush', 'orchid', 'cpuscreen', 'character', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'faucet', 'shower', 'pillow', 'powersocket', 'bench', 'photoframe', 'bed', 'novel', 'coin', 'kitchen_counter', 'headset', 'chessboard', 'comb', 'dresser', 'table', 'coffee', 'creditcard']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": Walk to the entrance hall. Find the telephone. Grab the telephone.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'chair', 'jelly', 'trashcan', 'toothbrush', 'orchid', 'cpuscreen', 'character', 'bookshelf', 'button', 'mat', 'deck_of_cards', 'faucet', 'shower', 'pillow', 'powersocket', 'bench', 'photoframe', 'bed', 'novel', 'coin', 'kitchen_counter', 'headset', 'chessboard', 'comb', 'dresser', 'table', 'coffee', 'creditcard']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "Walk to the entrance hall. Find the telephone. Grab the telephone.", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[WALK] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'filing_cabinet', 'tablelamp', 'toilet', 'jelly', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'coffee_filter', 'curtain', 'doorjamb', 'centerpiece', 'door', 'table']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": I sit down on sofa, get the remote, turn on tv, change channel to show I want to watch,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['freezer', 'cat', 'milk', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mousepad', 'towel', 'wall', 'powersocket', 'oven', 'food_food', 'coffe_maker', 'coin', 'doorjamb', 'mouse', 'headset', 'shoes', 'pajamas', 'door', 'light', 'colander', 'coffee']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"thoughts": "I walk to the kitchen, open the fridge and put the groceries in the fridge. Then I close the fridge.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>", "[GRAB] <food_food>", "[PUTIN] <food_food> <freezer>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'food_salt', 'microwave', 'jelly', 'detergent', 'food_carrot', 'toothbrush', 'needle', 'hanger', 'floor', 'phone', 'shampoo', 'character', 'tvstand', 'iron', 'balanceball', 'stereo', 'mousepad', 'food_jam', 'pillow', 'nightstand', 'toothbrush_holder', 'diary', 'console', 'shaving_cream', 'kitchen_counter', 'sink', 'light', 'dishwasher', 'vase']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": Find the playback device you want to listen to. turn on. press play. enjoyu music.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']\n}\n", "input": "\nScene_Objects:['pot', 'food_ice_cream', 'freezer', 'bathroom', 'knifeblock', 'hanger', 'character', 'desk', 'bedroom', 'folder', 'toaster', 'mat', 'laptop', 'stereo', 'foundation', 'homework', 'bed', 'newspaper', 'television', 'water', 'wine', 'tray', 'kitchen_counter', 'chessboard', 'laundry_detergent', 'food_steak', 'bag', 'home_office', 'light', 'soap']\nTask:Wash hands\nresponse:\n", "output": {"thoughts": "put soap on hands, scrub it and rinse with water", "actions": ["[WALK] <bathroom>", "[WALK] <soap>", "[FIND] <soap>", "[SCRUB] <soap>", "[FIND] <water>", "[RINSE] <water>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'ceilinglamp', 'faucet', 'shower', 'towel', 'dining_room', 'wall', 'powersocket', 'bed', 'check', 'wooden_spoon', 'cards', 'mouse', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": Go to the bathroom. turn on the water in the sink. apply soap to hands. rub hands together. rinse hands with water. turn off the water.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[WIPE] <hands_both>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'food_pizza', 'scissors', 'band-aids', 'nail_polish', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'bookshelf', 'thread', 'computer', 'button', 'stereo', 'window', 'clothes_socks', 'couch', 'food_peanut_butter', 'dining_room', 'toilet_paper', 'tray', 'mouse', 'dishrack', 'comb', 'bag', 'home_office', 'clothes_shirt', 'shoe_rack']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "Enter living room. Walk to telephone. Pick up from hook.", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'food_bread', 'microwave', 'walllamp', 'ceilingfan', 'food_butter', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'food_orange', 'wall', 'bench', 'photoframe', 'keys', 'check', 'food_food', 'television', 'curtain', 'table']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": Go to the living room, Switch on the television. Find the remote and press the change channel button, change the channel,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[FIND] <button>', '[TOUCH] <button>']\n}\n", "input": "\nScene_Objects:['glue', 'tablelamp', 'tea', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'desk', 'bedroom', 'computer', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'food_cheese', 'bed', 'food_donut', 'curtain', 'food_onion', 'mouse', 'pajamas', 'controller', 'table', 'dishwasher', 'light', 'board_game']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "lie in the sofa, relax", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[LIE] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'microwave', 'toilet', 'jelly', 'freezer', 'band-aids', 'drawing', 'knifeblock', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'powersocket', 'cup', 'basket_for_clothes', 'photoframe', 'food_food', 'water', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']\nTask:Get drink\nresponse:\n{\n    \"thoughts\": I go to the fridge and open the door. I look for the water pitcher, and take it out, making sure to close the fridge door behind me. Then I take a pint glass out of the upper cabinet over the sink and use the water pitcher to pour a full glass of water. Then I return the pitcher to the fridge and shut the door again, and take my glass of water out of the kitche.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <kitchen_cabinet>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[OPEN] <freezer>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'crayon', 'toilet', 'chair', 'walllamp', 'bathroom', 'food_butter', 'drawing', 'orchid', 'hanger', 'floor', 'desk', 'tea_bag', 'computer', 'stovefan', 'ceilinglamp', 'shower', 'window', 'couch', 'candle', 'food_orange', 'pillow', 'wall', 'cup', 'bed', 'curtain', 'kettle', 'pencil', 'pajamas', 'table']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "Walk to living room. Sit on sofa. Lie down on sofa.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[LIE] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'tablelamp', 'freezer', 'knifeblock', 'knife', 'bathroom_counter', 'shampoo', 'ceiling', 'keyboard', 'stovefan', 'mat', 'stereo', 'clothes_socks', 'oil', 'nightstand', 'powersocket', 'toy', 'novel', 'food_food', 'coffe_maker', 'rag', 'kettle', 'shoes', 'cupboard', 'hair', 'controller', 'door', 'instrument_guitar', 'table', 'light']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": walk into living room, walk to stereo, turn on stereo, listen to music,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']\n}\n", "input": "\nScene_Objects:['crayon', 'mop', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'ceilinglamp', 'mat', 'faucet', 'mousepad', 'clothes_hat', 'pillow', 'wall', 'bed', 'newspaper', 'food_food', 'coffee_filter', 'mouse', 'pencil', 'door', 'sink', 'table']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "Go to home office and browse the internet.", "actions": ["[RUN] <home_office>", "[WALK] <computer>", "[SWITCHON] <computer>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <mouse>", "[GRAB] <mouse>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[FIND] <keyboard>", "[GRAB] <keyboard>", "[TYPE] <keyboard>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[TOUCH] <mouse>", "[TYPE] <keyboard>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[TOUCH] <mouse>", "[TURNTO] <computer>", "[LOOKAT] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'measuring_cup', 'toilet', 'chair', 'ground_coffee', 'bathroom', 'dough', 'wallshelf', 'phone', 'character', 'keyboard', 'computer', 'ceilinglamp', 'deck_of_cards', 'stereo', 'mousepad', 'couch', 'powersocket', 'cutting_board', 'bed', 'food_food', 'food_rice', 'tray', 'wooden_spoon', 'pencil', 'headset', 'cupboard', 'laundry_detergent', 'sink', 'dishwasher']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": find the cat, go near the cat and pet the cat,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'tablelamp', 'dog', 'cat', 'drawing', 'food_egg', 'floor', 'phone', 'piano_bench', 'mat', 'mousepad', 'oil', 'food_jam', 'pillow', 'wall_clock', 'photoframe', 'coffe_maker', 'food_donut', 'food_rice', 'tray', 'after_shave', 'kitchen_counter', 'clothes_dress', 'door', 'sink', 'bag', 'bathroom_cabinet', 'table', 'dishwasher', 'creditcard']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "walk to living room , find phone ,pick up phone 3", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'pot', 'microwave', 'walllamp', 'knifeblock', 'food_egg', 'floor', 'ceiling', 'desk', 'bedroom', 'ceilinglamp', 'plate', 'faucet', 'window', 'dish_soap', 'mousepad', 'bowl', 'wall', 'oven', 'powersocket', 'check', 'mouthwash', 'after_shave', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'bathtub', 'dishwasher']\nTask:Wash dishes by hand\nresponse:\n{\n    \"thoughts\": I go to the kitchen and turn on the faucet. I get dish soap and put it into the sink. I grab a sponge and a bowl and start cleaning it. I put the bowl into the dishrack. I find a plate and clean it as well. I put it into the dishrack, turn off the faucet and put the sponge back.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <bowl>', '[GRAB] <bowl>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[FIND] <bowl>', '[SCRUB] <bowl>', '[RINSE] <bowl>', '[FIND] <dishrack>', '[PUTBACK] <bowl> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'toilet', 'nail_polish', 'detergent', 'cat', 'trashcan', 'milk', 'knifeblock', 'phone', 'ceiling', 'desk', 'keyboard', 'mousepad', 'couch', 'pillow', 'bench', 'oven', 'cup', 'bed', 'light_bulb', 'food_food', 'lighter', 'kitchen_counter', 'hairbrush', 'dresser', 'laundry_detergent', 'table', 'clothes_skirt', 'tooth_paste', 'dirt']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food.", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[TURNTO] <cat>", "[LOOKAT] <cat>", "[FIND] <cup>", "[GRAB] <cup>", "[WALK] <milk>", "[FIND] <milk>", "[GRAB] <milk>", "[POUR] <milk> <cup>", "[TURNTO] <cat>", "[POINTAT] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'bookshelf', 'mat', 'mousepad', 'dining_room', 'wall', 'nightstand', 'bench', 'basket_for_clothes', 'bed', 'photoframe', 'coffe_maker', 'food_food', 'wooden_spoon', 'mouse', 'dresser', 'sink', 'dishwasher']\nTask:Go to sleep\nresponse:\n{\n    \"thoughts\": go t the bedroom and go to sleep,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>']\n}\n", "input": "\nScene_Objects:['sheets', 'water_glass', 'pot', 'spectacles', 'chair', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'ceiling', 'character', 'stovefan', 'mat', 'faucet', 'food_orange', 'wall', 'oven', 'cutting_board', 'food_food', 'water', 'tray', 'food_onion', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'instrument_guitar', 'home_office']\nTask:Drink\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'pot', 'microwave', 'toilet', 'cat', 'wallshelf', 'bathroom_counter', 'floor', 'dvd_player', 'bookshelf', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'shower', 'faucet', 'tvstand', 'couch', 'towel', 'wall', 'bench', 'cutting_board', 'bed', 'razor', 'television', 'curtain', 'kitchen_counter', 'dresser', 'home_office', 'light']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Pet Cat,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'pot', 'food_pizza', 'filing_cabinet', 'tablelamp', 'beer', 'chair', 'freezer', 'blow_dryer', 'bathroom', 'cat', 'cpuscreen', 'phone', 'character', 'food_cake', 'computer', 'piano_bench', 'brush', 'clothes_pants', 'dining_room', 'nightstand', 'cutting_board', 'toilet_paper', 'coffe_maker', 'check', 'curtain', 'kitchen_counter', 'table', 'scrabble', 'creditcard']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner.", "actions": ["[WALK] <home_office>", "[WALK] <bedroom>", "[WALK] <bedroom>", "[WALK] <home_office>", "[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[FIND] <brush>", "[GRAB] <brush>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_salt', 'beer', 'microwave', 'chair', 'drawing', 'hanger', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'bookmark', 'laptop', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'couch', 'food_peanut_butter', 'photoframe', 'newspaper', 'razor', 'tray', 'kitchen_counter', 'vacuum_cleaner', 'clothes_dress', 'door', 'bathroom_cabinet', 'tooth_paste']\nTask:Write an email\nresponse:\n{\n    \"thoughts\": I go to my bed room and sit on the chair and in front of me is my desktop computer and start writing an email.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']\n}\n", "input": "\nScene_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']\nTask:Wash clothes\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'toilet', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'character', 'bedroom', 'desk', 'bookshelf', 'computer', 'mat', 'tvstand', 'window', 'pillow', 'wall', 'powersocket', 'tray', 'towel_rack', 'mouse', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'bathtub', 'light', 'teeth', 'shoe_rack']\nTask:Go to toilet\nresponse:\n{\n    \"thoughts\": walk to bathroom , run to toilet,\n    \"actions\": ['[WALK] <bathroom>', '[RUN] <toilet>']\n}\n", "input": "\nScene_Objects:['blender', 'band-aids', 'freezer', 'walllamp', 'nail_polish', 'trashcan', 'dough', 'drawing', 'bills', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'character', 'desk', 'purse', 'alcohol', 'clothes_jacket', 'toaster', 'mat', 'faucet', 'oil', 'couch', 'broom', 'oven', 'photoframe', 'tray', 'kitchen_counter', 'dresser', 'laser_pointer']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Find a cat in the kitchen and touch it", "actions": ["[WALK] <dining_room>", "[WALK] <cat>", "[FIND] <cat>", "[WALK] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'sponge', 'food_bread', 'blender', 'chair', 'walllamp', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'tvstand', 'window', 'mousepad', 'clothes_socks', 'wall', 'oven', 'cup', 'television', 'mouse', 'cupboard', 'door', 'home_office', 'table']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": go to the office, turn computer on, open an browser or any application to open any website.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <computer>']\n}\n", "input": "\nScene_Objects:['food_salt', 'tea', 'microwave', 'freezer', 'ground_coffee', 'walllamp', 'bathroom', 'trashcan', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'picture', 'electric_shaver', 'pillow', 'wall', 'coffe_maker', 'food_food', 'coffee_filter', 'oven_mitts', 'water', 'ice', 'coffee_pot', 'kitchen_counter', 'cd', 'dishrack', 'cupboard', 'instrument_guitar', 'home_office', 'dishwasher']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Making Coffee", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[FIND] <water>", "[GRAB] <water>", "[OPEN] <coffe_maker>", "[POUR] <water> <coffe_maker>", "[FIND] <ground_coffee>", "[GRAB] <ground_coffee>", "[FIND] <coffee_filter>", "[GRAB] <coffee_filter>", "[PUTBACK] <coffee_filter> <coffe_maker>", "[PUTBACK] <ground_coffee> <coffe_maker>", "[FIND] <coffee_pot>", "[GRAB] <coffee_pot>", "[PUTBACK] <coffee_pot> <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Take off shoes\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['scissors', 'food_ice_cream', 'walllamp', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'shampoo', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'check', 'television', 'coin', 'curtain', 'doorjamb', 'cards', 'shoes', 'cupboard', 'door', 'sink', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "go to the living room to watch TV", "actions": ["[RUN] <home_office>", "[WALK] <remote_control>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[WALK] <couch>", "[SIT] <couch>", "[FIND] <television>", "[TURNTO] <television>", "[POINTAT] <television>", "[TOUCH] <remote_control>", "[SWITCHON] <television>", "[TURNTO] <television>", "[LOOKAT] <television>", "[WATCH] <television>", "[DROP] <remote_control>", "[TURNTO] <television>", "[LOOKAT] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'blender', 'toilet', 'jelly', 'chair', 'drawing', 'bathroom_counter', 'floor', 'character', 'food_bacon', 'mat', 'shoe-shine_kit', 'shower', 'clothes_pants', 'pillow', 'dining_room', 'wall', 'pasta', 'oven', 'newspaper', 'check', 'television', 'ice', 'tray', 'doorjamb', 'pencil', 'comb', 'dresser', 'bathroom_cabinet']\nTask:Go to toilet\nresponse:\n{\n    \"thoughts\": Walk to the bathroom. Pull down pants. Use the toilet.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[PULL] <clothes_pants>', '[FIND] <toilet>', '[SIT] <toilet>']\n}\n", "input": "\nScene_Objects:['sheets', 'tablelamp', 'juice', 'walllamp', 'bathroom', 'drawing', 'hanger', 'floor', 'character', 'desk', 'tea_bag', 'mop_bucket', 'plate', 'faucet', 'couch', 'dining_room', 'broom', 'nightstand', 'bench', 'powersocket', 'box', 'photoframe', 'coffe_maker', 'food_food', 'television', 'dresser', 'cupboard', 'home_office', 'tooth_paste', 'coffee']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "I walk into the living room. I find the stereo and turn it on, and I listen to the music.", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'toilet', 'chair', 'freezer', 'food_egg', 'cpuscreen', 'floor', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'stovefan', 'laptop', 'picture', 'mousepad', 'dining_room', 'wall', 'nightstand', 'photoframe', 'bed', 'mouse', 'kitchen_counter', 'maindoor', 'home_office', 'light', 'clothes_skirt']\nTask:Write an email\nresponse:\n{\n    \"thoughts\": walk to home office and switch on laptop and with the useof mouse and keyboard send mail,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'tea', 'band-aids', 'walllamp', 'nail_polish', 'knifeblock', 'bills', 'cpuscreen', 'hanger', 'shampoo', 'phone', 'floor', 'bedroom', 'desk', 'toaster', 'stereo', 'clothes_socks', 'clothes_pants', 'clothes_hat', 'bowl', 'dining_room', 'bench', 'newspaper', 'clothes_gloves', 'coffe_maker', 'curtain', 'diary', 'hairbrush', 'bathroom_cabinet']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'tablelamp', 'chair', 'freezer', 'cat', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'stereo', 'faucet', 'picture', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'home_office', 'light']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": I go to the bedroom and sit at my desk. I turn my radio on and listen to music.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <stereo>', '[SWITCHON] <stereo>']\n}\n", "input": "\nScene_Objects:['fork', 'juice', 'food_ice_cream', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'faucet', 'food_noodles', 'mousepad', 'clothes_socks', 'wall', 'nightstand', 'box', 'photoframe', 'coffe_maker', 'mouse', 'kitchen_counter', 'door', 'food_steak', 'table', 'colander', 'creditcard']\nTask:Work\nresponse:\n", "output": {"thoughts": "turn computer on, open application to work with", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['walllamp', 'drawing', 'orchid', 'wallshelf', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'foundation', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'television', 'tray', 'curtain', 'doorjamb', 'cards', 'door', 'table', 'light', 'coffee']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": I walk into the living room and sit on the sofa to watch tv,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['tea', 'microwave', 'toilet', 'walllamp', 'detergent', 'trashcan', 'floor', 'ceiling', 'envelope', 'toaster', 'plate', 'shower', 'stereo', 'dish_soap', 'wall', 'powersocket', 'basket_for_clothes', 'coffe_maker', 'food_food', 'mouthwash', 'check', 'curtain', 'kitchen_counter', 'cupboard', 'pajamas', 'conditioner', 'sink', 'spoon', 'home_office', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[WALK] <dishwasher>", "[OPEN] <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <spoon>", "[GRAB] <spoon>", "[PUTBACK] <spoon> <dishwasher>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[PUTBACK] <dish_soap> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": The task is browse and surf on the internet regarding a particular topic,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>']\n}\n", "input": "\nScene_Objects:['food_bread', 'microwave', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'ceiling', 'stamp', 'keyboard', 'computer', 'alcohol', 'toaster', 'stovefan', 'shower', 'dustpan', 'pillow', 'wall', 'nightstand', 'bench', 'coffe_maker', 'check', 'food_food', 'coffee_filter', 'water', 'kitchen_counter', 'cupboard', 'table', 'dishwasher', 'tooth_paste', 'coffee']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Go to the kitchen and make coffee.", "actions": ["[RUN] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffee_filter>", "[GRAB] <coffee_filter>", "[OPEN] <coffe_maker>", "[PUTBACK] <coffee_filter> <coffe_maker>", "[FIND] <coffee>", "[GRAB] <coffee>", "[POUR] <coffee> <coffe_maker>", "[PUTOBJBACK] <coffee>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[POUR] <water> <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'detergent', 'food_butter', 'dough', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'faucet', 'stereo', 'picture', 'dustpan', 'bowl', 'dining_room', 'wall', 'oven', 'powersocket', 'photoframe', 'wine', 'tray', 'console', 'pencil', 'sink', 'bathroom_cabinet', 'dishwasher', 'hands_both', 'shoe_rack']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>']\n}\n", "input": "\nScene_Objects:['scissors', 'chair', 'walllamp', 'drawing', 'orchid', 'floor', 'phone', 'keyboard', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'window', 'stereo', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'coffe_maker', 'curtain', 'cd', 'dishrack', 'dresser', 'cupboard', 'table', 'laser_pointer', 'clothes_shirt', 'creditcard']\nTask:Relax on sofa\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'toilet', 'trashcan', 'dough', 'food_carrot', 'knife', 'drawing', 'clothes_underwear', 'hanger', 'dvd_player', 'character', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'tape', 'food_food', 'television', 'coffee_filter', 'ice', 'wooden_spoon', 'tray', 'lighter', 'chessboard', 'spoon', 'home_office', 'table', 'clothes_shirt']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>', '[SWITCHON] <phone>']\n}\n", "input": "\nScene_Objects:['fork', 'food_salt', 'toilet', 'bathroom', 'nail_polish', 'toothbrush', 'phone', 'character', 'mat', 'shower', 'stereo', 'towel', 'dining_room', 'oven', 'basket_for_clothes', 'novel', 'television', 'oven_mitts', 'food_donut', 'tray', 'doorjamb', 'cards', 'kitchen_counter', 'dishrack', 'pajamas', 'door', 'napkin', 'light', 'table', 'soap']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Walk into the living room, sit down by the cat, put out hand, stroke the cat from head to tail", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'mop', 'microwave', 'ground_coffee', 'walllamp', 'cat', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'toaster', 'brush', 'tvstand', 'shower', 'faucet', 'food_jam', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'mouthwash', 'coffee_filter', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'dishwasher', 'scrabble']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Make coffee in the kitchen.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[PLUGIN] <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>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']\n}\n", "input": "\nScene_Objects:['pot', 'food_ice_cream', 'microwave', 'walllamp', 'bathroom', 'cat', 'trashcan', 'knifeblock', 'hanger', 'floor', 'faucet', 'shower', 'clothes_hat', 'wall', 'nightstand', 'tape', 'cup', 'food_food', 'water', 'tray', 'diary', 'pencil', 'kitchen_counter', 'headset', 'hairbrush', 'cupboard', 'hair', 'sink', 'instrument_guitar', 'soap']\nTask:Drink\nresponse:\n", "output": {"thoughts": "Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass.", "actions": ["[WALK] <dining_room>", "[WALK] <cup>", "[FIND] <cup>", "[GRAB] <cup>", "[WALK] <sink>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[POUR] <water> <cup>", "[DRINK] <cup>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'toilet', 'freezer', 'bathroom', 'orchid', 'phone', 'dvd_player', 'character', 'bedroom', 'ceilinglamp', 'balanceball', 'iron', 'window', 'couch', 'food_orange', 'wall', 'tape', 'cup', 'basket_for_clothes', 'check', 'wooden_spoon', 'console', 'mouse', 'kitchen_counter', 'hairbrush', 'food_steak', 'sink', 'home_office', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": Wash hands with soap,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <soap>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>']\n}\n", "input": "\nScene_Objects:['pot', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'bathroom_counter', 'floor', 'mop_bucket', 'table_cloth', 'toaster', 'stovefan', 'plate', 'microphone', 'clothes_pants', 'dining_room', 'wall', 'pasta', 'cup', 'coffe_maker', 'food_food', 'mouse', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'home_office', 'light', 'dishwasher', 'colander', 'tooth_paste']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "Walk to Kitchen, find dishwasher. Find vessels to be washed. Open dishwasher, put vessels in dish washer, close dish washer and switch it on.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[FIND] <cup>", "[GRAB] <cup>", "[PUTBACK] <cup> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[GRAB] <cup>", "[PUTBACK] <cup> <plate>", "[GRAB] <cup>", "[PUTBACK] <cup> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'microwave', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door', 'bag', 'light', 'table']\nTask:Turn on computer\nresponse:\n{\n    \"thoughts\": Press the power button on the computer to turn it on,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']\n}\n", "input": "\nScene_Objects:['chair', 'jelly', 'walllamp', 'dough', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'stamp', 'keyboard', 'food_cake', 'computer', 'mop_bucket', 'mat', 'tvstand', 'mousepad', 'dining_room', 'wall', 'bench', 'toy', 'food_cheese', 'novel', 'curtain', 'mouse', 'shoes', 'sink', 'table', 'creditcard']\nTask:Read book\nresponse:\n", "output": {"thoughts": "I walk to home office and search for a book, and sit to the chair with a table, and start reading.", "actions": ["[WALK] <home_office>", "[WALK] <chair>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <novel>", "[GRAB] <novel>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'picture', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'bathroom_cabinet', 'light']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Go to entrance hall, switch on TV, sit back in a chair and using remote watch your favorite program.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[WALK] <chair>', '[SIT] <chair>', '[TURNTO] <television>', '[WATCH] <television>', '[SWITCHOFF] <television>']\n}\n", "input": "\nScene_Objects:['sheets', 'filing_cabinet', 'crayon', 'dog', 'freezer', 'knife', 'orchid', 'bathroom_counter', 'character', 'bedroom', 'faucet', 'couch', 'food_orange', 'towel', 'nightstand', 'oven', 'powersocket', 'photoframe', 'check', 'video_game_controller', 'food_donut', 'food_rice', 'food_onion', 'diary', 'dresser', 'hairbrush', 'clothes_scarf', 'napkin', 'bathroom_cabinet', 'colander']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Walk into the living room. Walk up to the cat. Pet the cat with your hand.", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_salt', 'toilet', 'dog', 'freezer', 'drawing', 'cpuscreen', 'phone', 'tea_bag', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'window', 'oil', 'food_orange', 'food_cheese', 'clothes_gloves', 'toilet_paper', 'food_food', 'television', 'coffee_filter', 'check', 'curtain', 'kettle', 'mouse', 'food_steak', 'spoon', 'instrument_guitar', 'light', 'dishwasher']\nTask:Walk to room\nresponse:\n{\n    \"thoughts\": Leave the living room and enter the hall,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <home_office>']\n}\n", "input": "\nScene_Objects:['pot', 'water_glass', 'dog', 'walllamp', 'knifeblock', 'bills', 'floor', 'ceiling', 'stovefan', 'brush', 'mat', 'faucet', 'homework', 'wall', 'pasta', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'coffee_pot', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'board_game', 'clothes_shirt', 'dirt']\nTask:Drink\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'toilet', 'bathroom', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'floor', 'bedroom', 'bookshelf', 'keyboard', 'computer', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'oven', 'photoframe', 'novel', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'light', 'table']\nTask:Read\nresponse:\n{\n    \"thoughts\": Read a book in the living room,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'chair', 'walllamp', 'toothbrush', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'remote_control', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'mat', 'picture', 'window', 'faucet', 'couch', 'clothes_hat', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'door', 'table', 'light']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "Go into the living room. Walk over to the sofa. Lie down on the sofa. Turn on and watch TV.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[LIE] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'juice', 'microwave', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'shower', 'faucet', 'window', 'mousepad', 'food_orange', 'wall', 'television', 'curtain', 'after_shave', 'mouse', 'dresser', 'door', 'napkin', 'table']\nTask:Clean screen\nresponse:\n{\n    \"thoughts\": Use a soft rag to wipe the screen until there are no marks on it.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <computer>', '[WIPE] <computer>', '[PUTOBJBACK] <rag>']\n}\n", "input": "\nScene_Objects:['sponge', 'microwave', 'walllamp', 'trashcan', 'drawing', 'floor', 'ceiling', 'button', 'toaster', 'window', 'mousepad', 'clothes_pants', 'wall', 'basket_for_clothes', 'coffe_maker', 'check', 'television', 'toothbrush_holder', 'ice', 'diary', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'pajamas', 'napkin', 'coffee_cup', 'dishwasher', 'soap', 'coffee']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Walk to the kitchen at the coffee maker, grab coffee, pour coffee into coffee maker, put coffee into coffee maker, push coffee maker's button, wait to complete, grab coffee cup", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffee>", "[GRAB] <coffee>", "[OPEN] <coffe_maker>", "[POUR] <coffee> <coffe_maker>", "[FIND] <coffee_cup>", "[GRAB] <coffee_cup>", "[PUTBACK] <coffee_cup> <coffe_maker>", "[FIND] <button>", "[PUSH] <button>", "[GRAB] <coffee_cup>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'pot', 'toilet', 'chair', 'freezer', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'keyboard', 'mat', 'ceilinglamp', 'shower', 'oil', 'food_peanut_butter', 'food_orange', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'food_onion', 'doorjamb', 'pencil', 'dresser', 'door', 'napkin', 'light', 'shoe_rack']\nTask:Put groceries in Fridge\nresponse:\n{\n    \"thoughts\": put away groceries in fridge. open the door, put on shelf, close the door.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']\n}\n", "input": "\nScene_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']\nTask:Wash teeth\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'blender', 'tea', 'toilet', 'chair', 'freezer', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'dvd_player', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'food_jam', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'cup', 'food_vegetable', 'photoframe', 'basket_for_clothes', 'doorjamb', 'mouse', 'door', 'table', 'light']\nTask:Chop vegetables\nresponse:\n{\n    \"thoughts\": Cut up veggies with knife,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <knife>', '[GRAB] <knife>', '[FIND] <cutting_board>', '[GRAB] <cutting_board>', '[CLOSE] <kitchen_cabinet>', '[WALK] <table>', '[PUTBACK] <knife> <table>', '[PUTBACK] <cutting_board> <table>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[CLOSE] <freezer>', '[WALK] <table>', '[PUTBACK] <food_vegetable> <cutting_board>', '[GRAB] <knife>', '[CUT] <food_vegetable>', '[PUTOBJBACK] <knife>']\n}\n", "input": "\nScene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'ground_coffee', 'walllamp', 'bathroom', 'trashcan', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'stovefan', 'homework', 'wall', 'novel', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'after_shave', 'diary', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'food_steak', 'dishwasher']\nTask:Make coffee\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'microwave', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'window', 'dish_soap', 'food_noodles', 'closetdrawer', 'couch', 'towel', 'dining_room', 'wall', 'wine', 'rag', 'shaving_cream', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'conditioner', 'sink', 'table', 'dishwasher', 'soap']\nTask:Wash dishes\nresponse:\n{\n    \"thoughts\": Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[WASH] <plate>', '[RINSE] <plate>', '[RINSE] <sponge>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <sponge>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <plate>', '[PUTOBJBACK] <towel>', '[WALK] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[PUTIN] <plate> <kitchen_cabinet>', '[CLOSE] <kitchen_cabinet>']\n}\n", "input": "\nScene_Objects:['toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'dresser', 'hairbrush', 'clothes_dress', 'door', 'sink', 'spoon', 'table', 'light']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "I walk into the living room. I sit on the couch and grab the remote. Then I turn on the TV and change the channel.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'pot', 'microwave', 'walllamp', 'food_carrot', 'character', 'desk', 'keyboard', 'shower', 'washing_machine', 'window', 'mousepad', 'clothes_pants', 'towel', 'wall', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'headset', 'chessboard', 'hair', 'napkin', 'table', 'soap', 'scrabble', 'dirt', 'coffee', 'creditcard']\nTask:Wash clothes\nresponse:\n{\n    \"thoughts\": walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[WALK] <washing_machine>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']\n}\n", "input": "\nScene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'bedroom', 'bookshelf', 'remote_control', 'thread', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'toaster', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'doorjamb', 'pencil', 'dresser', 'door', 'home_office', 'table', 'light']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "Change the channel on the TV in the living room", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[SWITCHON] <television>", "[FIND] <remote_control>", "[GRAB] <remote_control>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'food_bread', 'microwave', 'freezer', 'ground_coffee', 'dough', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'toaster', 'faucet', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'kitchen_counter', 'cupboard', 'sink']\nTask:Make coffee\nresponse:\n{\n    \"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,\n    \"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>']\n}\n", "input": "\nScene_Objects:['glue', 'filing_cabinet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'shoe-shine_kit', 'mousepad', 'pillow', 'wall', 'powersocket', 'cup', 'bed', 'wooden_spoon', 'coffee_pot', 'mouse', 'kitchen_counter', 'door', 'home_office', 'table']\nTask:Write an email\nresponse:\n", "output": {"thoughts": "I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer off.", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[FIND] <chair>", "[SIT] <chair>", "[SWITCHON] <computer>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>", "[SWITCHOFF] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Wash clothes\nresponse:\n{\n    \"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\",\n    \"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>']\n}\n", "input": "\nScene_Objects:['sponge', 'pot', 'blender', 'food_ice_cream', 'microwave', 'chair', 'walllamp', 'bathroom', 'trashcan', 'milk', 'floor', 'bedroom', 'computer', 'toaster', 'plate', 'shoe-shine_kit', 'oil', 'wall', 'newspaper', 'coffe_maker', 'tray', 'centerpiece', 'console', 'pencil', 'kitchen_counter', 'cupboard', 'spoon', 'dishwasher', 'laser_pointer', 'clothes_shirt']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "I walk to the kitchen. I take plate. I open the dishwasher. I put plate in the dishwasher. I switch on the dishwasher.", "actions": ["[WALK] <dining_room>", "[WALK] <plate>", "[FIND] <plate>", "[GRAB] <plate>", "[WALK] <dishwasher>", "[OPEN] <dishwasher>", "[PUTBACK] <plate> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'chair', 'freezer', 'detergent', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'stovefan', 'shower', 'faucet', 'window', 'closetdrawer', 'wall', 'wall_clock', 'powersocket', 'bench', 'photoframe', 'coffe_maker', 'check', 'television', 'food_food', 'ice', 'rag', 'towel_rack', 'kitchen_counter', 'cupboard']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": I go home and it's dark so I can not see anything,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'filing_cabinet', 'toilet', 'food_carrot', 'toothbrush', 'drawing', 'cpuscreen', 'floor', 'bedroom', 'bookshelf', 'thread', 'tvstand', 'shower', 'clothes_pants', 'towel', 'wall', 'pasta', 'bench', 'photoframe', 'light_bulb', 'food_food', 'television', 'curtain', 'doorjamb', 'kettle', 'door', 'sink', 'hairdryer', 'light']\nTask:Go to toilet\nresponse:\n", "output": {"thoughts": "Walk to the bathroom. Pull down pants. Use the toilet.", "actions": ["[WALK] <bathroom>", "[WALK] <clothes_pants>", "[FIND] <clothes_pants>", "[PULL] <clothes_pants>", "[FIND] <toilet>", "[SIT] <toilet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'desk', 'brush', 'mat', 'ceilinglamp', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'wall', 'powersocket', 'cup', 'photoframe', 'coffee_filter', 'food_rice', 'doorjamb', 'towel_rack', 'dresser', 'clothes_dress', 'door', 'light', 'table']\nTask:Change clothes\nresponse:\n{\n    \"thoughts\": Switch your clothes.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <dresser>', '[OPEN] <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[PUTON] <clothes_dress>', '[CLOSE] <dresser>']\n}\n", "input": "\nScene_Objects:['blender', 'beer', 'freezer', 'trashcan', 'orchid', 'floor', 'ceiling', 'bedroom', 'computer', 'toaster', 'window', 'couch', 'candle', 'dining_room', 'broom', 'oven', 'toy', 'check', 'video_game_controller', 'tray', 'kettle', 'coffee_pot', 'mouse', 'cd', 'cupboard', 'controller', 'bathroom_cabinet', 'light', 'dishwasher', 'laser_pointer']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "I pick up my phone. I touch it to navigate to the web browser. I can swipe and tap the screen to visit different websites. Then I read or watch the content within those websites.", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[GRAB] <phone>", "[TOUCH] <phone>", "[TURNTO] <phone>", "[LOOKAT] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'microwave', 'jelly', 'freezer', 'walllamp', 'drawing', 'character', 'tea_bag', 'stovefan', 'mat', 'tvstand', 'stereo', 'shoe-shine_kit', 'window', 'ceilinglamp', 'dustpan', 'food_jam', 'pillow', 'wall', 'wall_clock', 'newspaper', 'coffe_maker', 'food_donut', 'doorjamb', 'coffee_pot', 'cards', 'door', 'bathroom_cabinet', 'colander', 'scrabble']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": I reach out arm. I put hand on radio. I turn on radio. I pick a station.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <stereo>', '[TOUCH] <stereo>', '[TURNTO] <stereo>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'sheets', 'toilet', 'chair', 'freezer', 'ground_coffee', 'bathroom', 'cat', 'milk', 'food_egg', 'phone', 'clothes_jacket', 'mat', 'plate', 'tvstand', 'stereo', 'faucet', 'shower', 'couch', 'food_jam', 'pillow', 'cup', 'novel', 'coffe_maker', 'coffee_filter', 'ice', 'curtain', 'kitchen_counter', 'spoon', 'clothes_shirt']\nTask:Give milk to cat\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'chair', 'freezer', 'walllamp', 'trashcan', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'faucet', 'mat', 'mousepad', 'closetdrawer', 'wall', 'powersocket', 'toy', 'television', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'table']\nTask:Pay bills\nresponse:\n{\n    \"thoughts\": Check my bills, on the computer, open the appropriate sites, pay my due bills,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <desk>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <computer>']\n}\n", "input": "\nScene_Objects:['mop', 'walllamp', 'drawing', 'orchid', 'knife', 'floor', 'ceiling', 'folder', 'remote_control', 'food_cake', 'button', 'ceilinglamp', 'tvstand', 'mat', 'clothes_socks', 'pillow', 'dining_room', 'wall', 'powersocket', 'bed', 'toilet_paper', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'dishrack', 'clothes_dress', 'door', 'table', 'dishwasher']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "Walk to the living room. Find the television. Switch on the television. Find the remote control. Grab the remote control. Point at television. Find the button. Push button.", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[SWITCHON] <television>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[TURNTO] <television>", "[POINTAT] <television>", "[FIND] <button>", "[PUSH] <button>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'filing_cabinet', 'blow_dryer', 'walllamp', 'knife', 'orchid', 'cpuscreen', 'floor', 'computer', 'button', 'ceilinglamp', 'oil', 'mousepad', 'cup', 'bed', 'keys', 'novel', 'check', 'coffe_maker', 'toothbrush_holder', 'coffee_filter', 'food_food', 'curtain', 'pencil', 'shoes', 'controller', 'hairdryer', 'bathroom_cabinet', 'table', 'board_game']\nTask:Get ready to leave\nresponse:\n{\n    \"thoughts\": Get your jacket and shoes on, locate the keys off the side table, walk out the front door and secure building with keys when you leave,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>', '[FIND] <keys>', '[GRAB] <keys>']\n}\n", "input": "\nScene_Objects:['pot', 'measuring_cup', 'toilet', 'chair', 'band-aids', 'freezer', 'walllamp', 'food_carrot', 'toothbrush', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'button', 'mat', 'tvstand', 'faucet', 'mousepad', 'food_kiwi', 'wall', 'light_bulb', 'coffe_maker', 'toothbrush_holder', 'rag', 'pencil', 'sink', 'bathroom_cabinet', 'soap', 'tooth_paste', 'teeth']\nTask:Brush teeth\nresponse:\n", "output": {"thoughts": "getting ready for bed", "actions": ["[WALK] <bathroom_counter>", "[FIND] <toothbrush>", "[GRAB] <toothbrush>", "[PUTBACK] <toothbrush> <bathroom_counter>", "[FIND] <tooth_paste>", "[SQUEEZE] <tooth_paste>", "[GRAB] <toothbrush>", "[SCRUB] <toothbrush>", "[RINSE] <toothbrush>", "[FIND] <toothbrush_holder>", "[PUTBACK] <toothbrush> <toothbrush_holder>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'pot', 'blender', 'chair', 'bathroom', 'hanger', 'floor', 'tea_bag', 'food_cake', 'food_bacon', 'piano_bench', 'mat', 'plate', 'dish_soap', 'mousepad', 'closetdrawer', 'couch', 'clothes_socks', 'wall', 'powersocket', 'coffe_maker', 'curtain', 'console', 'kitchen_counter', 'cupboard', 'door', 'sink', 'napkin', 'dishwasher', 'colander']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['spectacles', 'food_bread', 'crayon', 'measuring_cup', 'chair', 'walllamp', 'trashcan', 'bedroom', 'bookshelf', 'purse', 'table_cloth', 'faucet', 'clothes_socks', 'pillow', 'wall', 'oven', 'newspaper', 'photoframe', 'coffe_maker', 'food_food', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'headset', 'dishrack', 'comb', 'dresser', 'spoon', 'instrument_guitar']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "walk to living room, find lamp, switch on.", "actions": ["[WALK] <home_office>", "[WALK] <floor_lamp>", "[FIND] <floor_lamp>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['chair', 'dough', 'drawing', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'tvstand', 'stereo', 'mousepad', 'pillow', 'food_kiwi', 'wall', 'powersocket', 'photoframe', 'television', 'curtain', 'doorjamb', 'mouse', 'door', 'sink', 'bathtub', 'light']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": I go to the bedroom and sit at my desk. I turn my radio on and listen to music.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <stereo>', '[SWITCHON] <stereo>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'food_salt', 'freezer', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'homework', 'window', 'wall', 'powersocket', 'oven', 'toy', 'bed', 'toilet_paper', 'television', 'toothbrush_holder', 'food_donut', 'tray', 'doorjamb', 'door', 'sink', 'spoon', 'table']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "Lift the remote and change the channel", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[SWITCHON] <television>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_salt', 'beer', 'microwave', 'chair', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'mop_bucket', 'toaster', 'brush', 'plate', 'faucet', 'stereo', 'ceilinglamp', 'tvstand', 'dish_soap', 'wall', 'food_food', 'video_game_controller', 'toothbrush_holder', 'doorjamb', 'mouse', 'kitchen_counter', 'headset', 'cupboard', 'sink', 'light', 'table']\nTask:Wash dishes by hand\nresponse:\n{\n    \"thoughts\": i go to the kitchen, i find the faucet. I turn the faucet on, i grab the plate to wash , i then get the soap. I wash the dishes by hand,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <plate>', '[GRAB] <plate>', '[WASH] <plate>']\n}\n", "input": "\nScene_Objects:['microwave', 'freezer', 'walllamp', 'nail_polish', 'food_carrot', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'plate', 'mousepad', 'wall', 'powersocket', 'oven', 'food_food', 'coffe_maker', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'napkin', 'light', 'dishwasher']\nTask:Cook some food\nresponse:\n", "output": {"thoughts": "Walk Into Kitchen. Open Refrigerator. Grab Food. Walk to Microwave. Insert food into microwave. Cook until warm.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>", "[CLOSE] <freezer>", "[WALK] <microwave>", "[SWITCHON] <microwave>", "[SWITCHOFF] <microwave>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'walllamp', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'toaster', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'plate', 'couch', 'pillow', 'wall', 'newspaper', 'coffe_maker', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'bathtub', 'light', 'table']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": My cat looks like it wants attention, so I will go pet it on the couch.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'bookmark', 'stovefan', 'ceilinglamp', 'mat', 'mousepad', 'oil', 'food_peanut_butter', 'broom', 'wall', 'novel', 'diary', 'mouse', 'cupboard', 'clothes_dress', 'door', 'table', 'light', 'dirt']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "Go to office. Turn on computer. Pull out chair. Sit in chair. Use keyboard and mouse.", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>", "[FIND] <chair>", "[PULL] <chair>", "[SIT] <chair>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>", "[FIND] <mouse>", "[GRAB] <mouse>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'juice', 'toilet', 'walllamp', 'toothbrush', 'drawing', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stamp', 'faucet', 'balanceball', 'clothes_pants', 'wall', 'powersocket', 'photoframe', 'novel', 'toothbrush_holder', 'television', 'food_donut', 'tray', 'towel_rack', 'cupboard', 'controller', 'sink', 'bathroom_cabinet', 'tooth_paste']\nTask:Wash teeth\nresponse:\n{\n    \"thoughts\": I go into the bathroom, go to the sink, get toothbrush and toothpaste. Put toothpaste on the toothbrush, brush teeth, turn on faucet, rinse brush, and return toothbrush.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[PUTBACK] <toothbrush> <toothbrush_holder>']\n}\n", "input": "\nScene_Objects:['tea', 'cat', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'mail', 'alcohol', 'mat', 'faucet', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'bench', 'coffee_filter', 'ice', 'paper_towel', 'conditioner', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'soap', 'hands_both', 'shoe_rack']\nTask:Wash hands\nresponse:\n", "output": {"thoughts": "I walk to the bathroom and find the sink. I grab the soap and rub some on my hands. I turn the faucet on and put my hands in the water. I rinse my hands and then turn off the faucet. Then I dry my hands on a paper towel.", "actions": ["[WALK] <bathroom>", "[WALK] <sink>", "[FIND] <sink>", "[FIND] <soap>", "[GRAB] <soap>", "[FIND] <hands_both>", "[SCRUB] <hands_both>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[RINSE] <hands_both>", "[FIND] <paper_towel>", "[GRAB] <paper_towel>", "[WIPE] <hands_both>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'orchid', 'floor', 'desk', 'computer', 'stovefan', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'pillow', 'nightstand', 'wall_clock', 'oven', 'wall', 'coffe_maker', 'mouthwash', 'television', 'tray', 'towel_rack', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'light']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": walk to phone, grab phone, pick up phone, put to ear,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['juice', 'food_salt', 'cd_player', 'toilet', 'freezer', 'walllamp', 'nail_polish', 'drawing', 'orchid', 'knifeblock', 'floor', 'phone', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'window', 'couch', 'pillow', 'bowl', 'wall', 'oven', 'photoframe', 'check', 'curtain', 'kettle', 'pajamas', 'table', 'light']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "Walk to living room, walk to cd player, turn on cd player, press play button, walk to sofa, sit in sofa and listen to music", "actions": ["[WALK] <home_office>", "[WALK] <cd_player>", "[SWITCHON] <cd_player>", "[FIND] <button>", "[PUSH] <button>", "[WALK] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'wooden_spoon', 'doorjamb', 'mouse', 'dresser', 'door']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": I go to my home office. I sit on the chair right in front of my computer. I turn on the computer. Use the mouse to open the web browser. Use the keyboard to type the URL that I want to visit.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[TOUCH] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']\n}\n", "input": "\nScene_Objects:['toilet', 'bathroom', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'alcohol', 'mat', 'electric_shaver', 'oil', 'wall', 'powersocket', 'box', 'food_cheese', 'photoframe', 'bed', 'food_food', 'coffe_maker', 'doorjamb', 'lighter', 'dishrack', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'coffee']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "push any ligth button to turn it on, for example in the living room", "actions": ["[WALK] <home_office>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'shoe-shine_kit', 'faucet', 'couch', 'form', 'wall', 'bench', 'toy', 'cup', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse hands,,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <soap>']\n}\n", "input": "\nScene_Objects:['juice', 'microwave', 'toilet', 'freezer', 'bathroom', 'orchid', 'knifeblock', 'phone', 'character', 'stovefan', 'mat', 'shower', 'dustpan', 'food_orange', 'pillow', 'broom', 'box', 'newspaper', 'check', 'television', 'coffee_pot', 'controller', 'door', 'home_office', 'table', 'bathroom_cabinet', 'dishwasher', 'colander', 'teeth', 'shoe_rack']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "Enter the Home office, then walk to the phone, pickup the phone.", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'nail_polish', 'bathroom', 'cat', 'orchid', 'cpuscreen', 'longboard', 'bedroom', 'keyboard', 'clothes_jacket', 'bookmark', 'toaster', 'balanceball', 'stereo', 'mousepad', 'clothes_pants', 'pillow', 'nightstand', 'wall', 'photoframe', 'food_food', 'mouthwash', 'tray', 'diary', 'comb', 'pajamas', 'maindoor', 'bag', 'spoon', 'light']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Go to the living room where the cat sleeps. Find cat. Proceed to petting cat.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['freezer', 'band-aids', 'dough', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'dvd_player', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'powersocket', 'cup', 'bed', 'photoframe', 'newspaper', 'water', 'food_donut', 'doorjamb', 'mouse', 'door', 'light', 'table', 'shoe_rack']\nTask:Drink\nresponse:\n", "output": {"thoughts": "Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <cup>", "[GRAB] <cup>", "[CLOSE] <freezer>", "[FIND] <water>", "[GRAB] <water>", "[FIND] <cup>", "[POUR] <water> <cup>", "[FIND] <cup>", "[DRINK] <cup>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'freezer', 'walllamp', 'cat', 'ceilingfan', 'drawing', 'cpuscreen', 'clothes_underwear', 'longboard', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'oil', 'couch', 'pillow', 'wall', 'photoframe', 'food_food', 'television', 'ice', 'curtain', 'after_shave', 'door', 'table', 'dishwasher', 'vase']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Sit on couch and watch the tv,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'blender', 'mop', 'bathroom', 'cat', 'trashcan', 'knifeblock', 'stamp', 'button', 'piano_bench', 'faucet', 'mousepad', 'bowl', 'nightstand', 'wall_clock', 'oven', 'wall', 'bench', 'photoframe', 'novel', 'food_food', 'coffe_maker', 'curtain', 'pencil', 'shoes', 'hairbrush', 'hair', 'instrument_guitar', 'dishwasher', 'tooth_paste']\nTask:Read book\nresponse:\n", "output": {"thoughts": "pick up  the book open the book and read", "actions": ["[WALK] <bedroom>", "[WALK] <novel>", "[GRAB] <novel>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['chair', 'band-aids', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'picture', 'homework', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'keys', 'television', 'doorjamb', 'kitchen_counter', 'dresser', 'light', 'soap']\nTask:Change TV channels\nresponse:\n{\n    \"thoughts\": Take remote. Change to desired channel by you.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[TOUCH] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['fork', 'tablelamp', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'needle', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'brush', 'mousepad', 'wall', 'nightstand', 'bed', 'photoframe', 'check', 'food_food', 'doorjamb', 'mouse', 'kitchen_counter', 'headset', 'door', 'table', 'light', 'shoe_rack']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "I'll walk to my bedroom, where I have my computer. I'll walk to my computer and sit down in front of it. I'll put on my headphones and unlock my computer. I'll then navigate to music stored locally or streamed through the web.", "actions": ["[WALK] <bedroom>", "[WALK] <computer>", "[FIND] <computer>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[WALK] <computer>", "[FIND] <chair>", "[PULL] <chair>", "[SIT] <chair>", "[FIND] <headset>", "[GRAB] <headset>", "[PUTON] <headset>", "[SWITCHON] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'filing_cabinet', 'jelly', 'drawing', 'orchid', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'computer', 'bookmark', 'faucet', 'clothes_socks', 'couch', 'pillow', 'broom', 'wall', 'wall_clock', 'tape', 'photoframe', 'novel', 'check', 'food_onion', 'doorjamb', 'door', 'bathtub', 'table', 'light']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": Go to the living room and relax on the sofa with a book,\n    \"actions\": ['[RUN] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[DROP] <bookmark>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[READ] <novel>', '[READ] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['cd_player', 'walllamp', 'drawing', 'knife', 'knifeblock', 'ceiling', 'character', 'keyboard', 'ceilinglamp', 'tvstand', 'stereo', 'shower', 'faucet', 'window', 'food_noodles', 'mousepad', 'couch', 'dustpan', 'dining_room', 'food_kiwi', 'wall_clock', 'bench', 'powersocket', 'oven', 'toy', 'photoframe', 'ice', 'dishrack', 'clothes_skirt', 'coffee']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "I walk in the living room, then I go the the stereo and the cd player and turn them on.", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>", "[FIND] <cd_player>", "[SWITCHON] <cd_player>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'crayon', 'chair', 'cat', 'dough', 'milk', 'hanger', 'floor', 'keyboard', 'mail', 'table_cloth', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'couch', 'form', 'dining_room', 'cutting_board', 'photoframe', 'check', 'wine', 'dresser', 'hairbrush', 'pajamas', 'conditioner', 'home_office', 'bathroom_cabinet', 'table']\nTask:Give milk to cat\nresponse:\n{\n    \"thoughts\": Grab milk and pour it into the plate so that the cat can drink,\n    \"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>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'freezer', 'band-aids', 'trashcan', 'dough', 'food_egg', 'cpuscreen', 'floor', 'ceiling', 'folder', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'pillow', 'wall', 'powersocket', 'newspaper', 'food_food', 'check', 'oven_mitts', 'food_donut', 'food_onion', 'doorjamb', 'kettle', 'mouse', 'pajamas', 'door', 'light']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"thoughts": "go to the kitchen and put the groceries in the fridge", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>", "[GRAB] <food_food>", "[PUTIN] <food_food> <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'pot', 'microwave', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'keyboard', 'food_cake', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'oil', 'tooth_paste', 'couch', 'closetdrawer', 'dining_room', 'toy', 'basket_for_clothes', 'light_bulb', 'check', 'centerpiece', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'light', 'board_game']\nTask:Brush teeth\nresponse:\n{\n    \"thoughts\": EARLY MORNING AND BEFORE GOING TO BED,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'scissors', 'mop', 'microwave', 'toilet', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'tvstand', 'shower', 'stereo', 'mousepad', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'chessboard', 'laundry_detergent', 'door', 'board_game']\nTask:Go to toilet\nresponse:\n", "output": {"thoughts": "walk to bathroom , run to toilet", "actions": ["[WALK] <bathroom>", "[RUN] <toilet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'food_ice_cream', 'microwave', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'table_cloth', 'stovefan', 'toaster', 'faucet', 'mousepad', 'wall', 'wall_clock', 'oven', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'cards', 'kitchen_counter', 'cupboard', 'sink', 'light', 'dishwasher']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Walk to kitchen, grab a cup, fill with water and then drink it.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'beer', 'freezer', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'foundation', 'window', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'door', 'table', 'light']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "Walk into the Living room.  Find the television remote.  Use it to turn on the television.  Point the remote at the television. Press the channel button on the remote.", "actions": ["[WALK] <home_office>", "[WALK] <remote_control>", "[FIND] <remote_control>", "[FIND] <television>", "[TURNTO] <television>", "[POINTAT] <television>", "[SWITCHON] <television>", "[FIND] <button>", "[PUSH] <button>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['blender', 'microwave', 'chair', 'freezer', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'stereo', 'picture', 'mat', 'closetdrawer', 'couch', 'dining_room', 'wall_clock', 'bench', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'cupboard', 'home_office', 'instrument_guitar']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": I walk into the living room and then I walk to the light switch in there and turn the lights on,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'chair', 'walllamp', 'food_butter', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'shower', 'picture', 'mousepad', 'pillow', 'wall', 'oven', 'powersocket', 'bed', 'photoframe', 'food_donut', 'tray', 'mouse', 'pencil', 'bag', 'soap']\nTask:Read book\nresponse:\n", "output": {"thoughts": "go to living room,find the text book on the self ,sat on the chair ,open and read the book", "actions": ["[WALK] <home_office>", "[WALK] <novel>", "[FIND] <novel>", "[GRAB] <novel>", "[WALK] <home_office>", "[WALK] <chair>", "[FIND] <chair>", "[SIT] <chair>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'chair', 'freezer', 'band-aids', 'walllamp', 'cat', 'drawing', 'floor', 'alcohol', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'deck_of_cards', 'window', 'shower', 'couch', 'pillow', 'wall', 'wall_clock', 'oven', 'photoframe', 'keys', 'television', 'curtain', 'doorjamb', 'mouse', 'home_office', 'table', 'bathroom_cabinet']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Walk into bedrrom and to the sofa. Sit on the sofa and touch cat.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'blender', 'trashcan', 'drawing', 'floor', 'phone', 'ceiling', 'desk', 'purse', 'mat', 'tvstand', 'ceilinglamp', 'window', 'food_peanut_butter', 'food_jam', 'pillow', 'wall', 'bench', 'check', 'toothbrush_holder', 'colander', 'tray', 'rag', 'lighter', 'kitchen_counter', 'comb', 'door', 'table', 'dishwasher', 'soap']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "Pick up phone", "actions": ["[WALK] <table>", "[FIND] <phone>", "[TURNTO] <phone>", "[LOOKAT] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['beer', 'crayon', 'ceilingfan', 'drawing', 'needle', 'floor', 'ceiling', 'shampoo', 'keyboard', 'remote_control', 'thread', 'food_bacon', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'window', 'couch', 'wall', 'photoframe', 'bed', 'television', 'coffee_filter', 'curtain', 'mouse', 'table', 'light', 'laser_pointer']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": I go into the living room. I find the remote. I turn on the tv. I sit on the couch and watch tv.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['sheets', 'tablelamp', 'freezer', 'knifeblock', 'knife', 'bathroom_counter', 'shampoo', 'ceiling', 'keyboard', 'stovefan', 'mat', 'stereo', 'clothes_socks', 'oil', 'nightstand', 'powersocket', 'toy', 'novel', 'food_food', 'coffe_maker', 'rag', 'kettle', 'shoes', 'cupboard', 'hair', 'controller', 'door', 'instrument_guitar', 'table', 'light']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "walk into living room, walk to stereo, turn on stereo, listen to music", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_pants', 'form', 'pillow', 'towel', 'wall', 'powersocket', 'bench', 'newspaper', 'television', 'curtain', 'doorjamb', 'mouse', 'hair', 'door', 'bathroom_cabinet', 'table', 'dishwasher']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['spectacles', 'pot', 'filing_cabinet', 'food_pizza', 'walllamp', 'cat', 'toothbrush', 'orchid', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'food_bacon', 'table_cloth', 'plate', 'food_jam', 'bench', 'oven', 'tape', 'photoframe', 'toothbrush_holder', 'oven_mitts', 'wooden_spoon', 'diary', 'mouse', 'sink', 'home_office', 'light', 'tooth_paste', 'clothes_shirt']\nTask:Brush teeth\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'light']\nTask:Work\nresponse:\n{\n    \"thoughts\": Walk to over to desk, sit down on chair and face the computer, turn the computer on, use arms to place hands on the keyboard, type work into the computer and use eyes to review.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>']\n}\n", "input": "\nScene_Objects:['fork', 'pot', 'tablelamp', 'freezer', 'bathroom', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'mousepad', 'food_jam', 'pillow', 'wall', 'powersocket', 'light_bulb', 'drinking_glass', 'food_onion', 'doorjamb', 'mouse', 'cd', 'door', 'light', 'clothes_skirt', 'coffee']\nTask:Drink\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'chair', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'mouse', 'dresser', 'conditioner', 'door', 'table', 'shoe_rack']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": For relaxing walk to living room. Find the sofa to relax. Arrange the sofa to relax. Sit on the sofa to relaxing.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <conditioner>', '[FIND] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[LIE] <couch>']\n}\n", "input": "\nScene_Objects:['pot', 'chair', 'band-aids', 'bathroom', 'trashcan', 'phone', 'bedroom', 'bookshelf', 'computer', 'stovefan', 'picture', 'window', 'couch', 'bowl', 'broom', 'wall', 'oven', 'bench', 'cup', 'food_food', 'oven_mitts', 'colander', 'curtain', 'pencil', 'kitchen_counter', 'clothes_dress', 'sink', 'dishwasher', 'soap', 'instrument_violin']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Find Cat in living room.  Walk to cat.  Pet cat.", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[TURNTO] <cat>", "[LOOKAT] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'folder', 'character', 'desk', 'faucet', 'stereo', 'mousepad', 'food_orange', 'wall', 'oven', 'photoframe', 'oven_mitts', 'water', 'drinking_glass', 'wooden_spoon', 'towel_rack', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'spoon', 'board_game']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Go to kitchen, open cabinet, get glass, close cabinet, put glass under faucet, turn on water, turn off water when glass has 85% water, lift glass to mouth, open mouth and put on glass, tilt glass up and swallow water.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[TURNTO] <kitchen_cabinet>', '[LOOKAT] <kitchen_cabinet>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[SWITCHOFF] <faucet>', '[DRINK] <drinking_glass>']\n}\n", "input": "\nScene_Objects:['glue', 'tea', 'microwave', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'phone', 'toaster', 'shower', 'faucet', 'food_noodles', 'mousepad', 'microphone', 'pillow', 'wall', 'bed', 'light_bulb', 'coffe_maker', 'toothbrush_holder', 'coffee_filter', 'oven_mitts', 'razor', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'dishwasher', 'coffee']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on.", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[FIND] <coffee_filter>", "[GRAB] <coffee_filter>", "[OPEN] <coffe_maker>", "[PUTBACK] <coffee_filter> <coffe_maker>", "[WALK] <coffee>", "[FIND] <coffee>", "[GRAB] <coffee>", "[POUR] <coffee> <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'tvstand', 'window', 'mousepad', 'dustpan', 'pillow', 'wall', 'wall_clock', 'powersocket', 'television', 'tray', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'table']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": Browsing the internet for information.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <mouse>', '[TOUCH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'cd_player', 'walllamp', 'trashcan', 'food_carrot', 'drawing', 'needle', 'bathroom_counter', 'dvd_player', 'bedroom', 'bookshelf', 'alcohol', 'piano_bench', 'bookmark', 'laptop', 'stereo', 'couch', 'pillow', 'broom', 'bench', 'basket_for_clothes', 'mouse', 'shoes', 'headset', 'food_steak', 'sink', 'hairdryer', 'instrument_guitar', 'door', 'bag']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "Find the playback device you want to listen to. turn on. press play. enjoyu music.", "actions": ["[WALK] <bedroom>", "[WALK] <cd_player>", "[FIND] <cd_player>", "[SWITCHON] <cd_player>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'tablelamp', 'food_salt', 'chair', 'walllamp', 'detergent', 'drawing', 'clothes_underwear', 'floor', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'shower', 'food_noodles', 'garbage_can', 'mousepad', 'microphone', 'wall', 'nightstand', 'food_vegetable', 'bed', 'food_food', 'coffee_filter', 'mouse', 'sink', 'home_office', 'table', 'dishwasher', 'pantry']\nTask:Organize pantry\nresponse:\n{\n    \"thoughts\": Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <pantry>', '[FIND] <food_food>', '[GRAB] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[FIND] <garbage_can>', '[PUTBACK] <food_food> <garbage_can>', '[FIND] <food_vegetable>', '[GRAB] <food_vegetable>', '[TURNTO] <food_vegetable>', '[LOOKAT] <food_vegetable>', '[PUTBACK] <food_vegetable> <garbage_can>', '[FIND] <dry_pasta>', '[GRAB] <dry_pasta>', '[TURNTO] <dry_pasta>', '[LOOKAT] <dry_pasta>', '[PUTOBJBACK] <dry_pasta>', '[FIND] <food_food>', '[TURNTO] <food_food>', '[LOOKAT] <food_food>', '[PUSH] <food_food>', '[FIND] <food_noodles>', '[GRAB] <food_noodles>', '[TURNTO] <food_noodles>', '[LOOKAT] <food_noodles>', '[PUTOBJBACK] <food_noodles>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'food_ice_cream', 'walllamp', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'deck_of_cards', 'homework', 'wall', 'powersocket', 'check', 'television', 'doorjamb', 'mouse', 'cupboard', 'controller', 'door', 'bag', 'table', 'teeth']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "Go to the living room, Switch on the television. Find the remote and press the change channel button, change the channel", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[SWITCHON] <television>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[TURNTO] <television>", "[POINTAT] <television>", "[FIND] <button>", "[TOUCH] <button>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'food_salt', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'mat', 'faucet', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'toothbrush_holder', 'wine', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'door', 'sink', 'clothes_scarf', 'light']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": Walk into living room. Find wall. Find light button. Switch on light button.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'plate', 'stereo', 'mousepad', 'wall', 'bench', 'television', 'wine', 'rag', 'lighter', 'shaving_cream', 'mouse', 'hairbrush', 'door', 'table']\nTask:Write an email\nresponse:\n", "output": {"thoughts": "walk to living room, look at computer, find chair, sit in chair, grab keyboard, grab mouse, type using keyboard and mouse", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[WALK] <computer>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <keyboard>", "[GRAB] <keyboard>", "[FIND] <mouse>", "[GRAB] <mouse>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'chair', 'jelly', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'stovefan', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'window', 'homework', 'closetdrawer', 'couch', 'pillow', 'wall', 'newspaper', 'coffe_maker', 'television', 'tray', 'curtain', 'towel_rack', 'cupboard', 'home_office', 'table']\nTask:Read newspaper\nresponse:\n{\n    \"thoughts\": Read the newspaper on the couch,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <newspaper>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <newspaper>']\n}\n", "input": "\nScene_Objects:['microwave', 'walllamp', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'remote_control', 'mop_bucket', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'cup', 'newspaper', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'shoes', 'dresser', 'door', 'home_office', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "I get home from work and decide to watch tv. I go to the living room and turn on the tv. I sit on the couch and use the remote to switch the channels to find what I want to watch.", "actions": ["[WALK] <home_office>", "[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[SWITCHON] <television>", "[WALK] <couch>", "[SIT] <couch>", "[TURNTO] <television>", "[LOOKAT] <television>", "[FIND] <remote_control>", "[GRAB] <remote_control>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'microwave', 'walllamp', 'bathroom', 'hanger', 'bathroom_counter', 'man', 'bookshelf', 'keyboard', 'piano_bench', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'window', 'closetdrawer', 'dining_room', 'photoframe', 'tray', 'curtain', 'food_onion', 'mouse', 'dresser', 'cupboard', 'door', 'sink', 'home_office', 'light', 'clothes_skirt', 'bathroom_cabinet']\nTask:Greet guests\nresponse:\n{\n    \"thoughts\": When someone knocks I n the door walk through the hallway and greet them.,\n    \"actions\": ['[RUN] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']\n}\n", "input": "\nScene_Objects:['pot', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'toaster', 'stovefan', 'faucet', 'mousepad', 'couch', 'wall', 'pasta', 'oven', 'box', 'food_food', 'water', 'tray', 'pencil', 'kitchen_counter', 'sauce_pan', 'cupboard', 'instrument_guitar', 'bathroom_cabinet']\nTask:Cook some food\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'tablelamp', 'tea', 'microwave', 'toilet', 'freezer', 'bathroom', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'folder', 'bookshelf', 'computer', 'toaster', 'mat', 'shower', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'bench', 'cup', 'food_food', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'napkin']\nTask:Put groceries in Fridge\nresponse:\n{\n    \"thoughts\": Find groceries. Grab groceries. Walk to refrigerator. Open refrigerator door. Place groceries into refrigerator. Close refrigerator door.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <food_food>', '[FIND] <food_food>', '[GRAB] <food_food>', '[WALK] <freezer>', '[OPEN] <freezer>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'tea', 'toilet', 'dog', 'trashcan', 'orchid', 'drawing', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'alcohol', 'toaster', 'mat', 'shower', 'picture', 'stereo', 'clothes_socks', 'wall', 'nightstand', 'photoframe', 'check', 'razor', 'curtain', 'doorjamb', 'pencil', 'door', 'napkin', 'laser_pointer']\nTask:Go to toilet\nresponse:\n", "output": {"thoughts": "i go to the bathroom. I find the toilet", "actions": ["[WALK] <bathroom>", "[WALK] <toilet>", "[FIND] <toilet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'microwave', 'toilet', 'cat', 'drawing', 'floor', 'dvd_player', 'bookshelf', 'food_cake', 'keyboard', 'computer', 'bookmark', 'mat', 'shower', 'faucet', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'television', 'curtain', 'towel_rack', 'mouse', 'door', 'sink', 'bathtub', 'light']\nTask:Breakfast\nresponse:\n{\n    \"thoughts\": I have breakfast in bed, watching tv.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['water_glass', 'mop', 'freezer', 'bathroom', 'trashcan', 'knifeblock', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'table_cloth', 'stovefan', 'mat', 'mousepad', 'pillow', 'bench', 'oven', 'photoframe', 'bed', 'coffee_filter', 'wine', 'centerpiece', 'dresser', 'sink', 'table', 'tooth_paste', 'laser_pointer', 'teeth']\nTask:Drink\nresponse:\n", "output": {"thoughts": "walk to kitchen, walk to table, grab water glass and drink water", "actions": ["[WALK] <dining_room>", "[WALK] <table>", "[FIND] <water_glass>", "[GRAB] <water_glass>", "[DRINK] <water_glass>", "[PUTBACK] <water_glass> <table>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'jelly', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'food_chicken', 'desk', 'keyboard', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'stovefan', 'faucet', 'mousepad', 'oil', 'wall', 'powersocket', 'oven', 'food_food', 'tray', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']\nTask:Cook some food\nresponse:\n{\n    \"thoughts\": I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_chicken>', '[GRAB] <food_chicken>', '[FIND] <pot>', '[GRAB] <pot>', '[FIND] <oven>', '[PUTBACK] <pot> <oven>', '[PUTBACK] <food_chicken> <oven>']\n}\n", "input": "\nScene_Objects:['pot', 'freezer', 'walllamp', 'food_carrot', 'milk', 'drawing', 'knifeblock', 'cpuscreen', 'kitchen_cabinet', 'floor', 'ceiling', 'food_chicken', 'desk', 'keyboard', 'computer', 'toaster', 'ceilinglamp', 'mat', 'stereo', 'stovefan', 'faucet', 'mousepad', 'oil', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'food_food', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'napkin', 'light', 'table']\nTask:Cook some food\nresponse:\n", "output": {"thoughts": "Walk to the kitchen and open the fridge. From the fridge take some chicken and close the fridge. Walk to the table and put the chicken on the table. Plug in oven and put the chicken into the oven.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_chicken>", "[GRAB] <food_chicken>", "[CLOSE] <freezer>", "[WALK] <table>", "[PUTBACK] <food_chicken> <table>", "[FIND] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[FIND] <pot>", "[GRAB] <pot>", "[PUTBACK] <pot> <table>", "[FIND] <oven>", "[PLUGIN] <oven>", "[OPEN] <oven>", "[GRAB] <food_chicken>", "[PUTIN] <food_chicken> <oven>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Wash teeth\nresponse:\n{\n    \"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,\n    \"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>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'food_bread', 'microwave', 'toilet', 'drawing', 'orchid', 'floor', 'phone', 'tea_bag', 'bookshelf', 'plate', 'shower', 'faucet', 'oil', 'candle', 'form', 'dining_room', 'wall', 'basket_for_clothes', 'photoframe', 'bed', 'food_food', 'coffee_filter', 'curtain', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'door', 'dishwasher']\nTask:Go to toilet\nresponse:\n", "output": {"thoughts": "I walk into the bath room and go to the toilet", "actions": ["[WALK] <bathroom>", "[WALK] <toilet>", "[FIND] <toilet>", "[SIT] <toilet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'bathroom', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'knifeblock', 'floor', 'dvd_player', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'faucet', 'electric_shaver', 'floor_lamp', 'mousepad', 'wall', 'powersocket', 'novel', 'food_food', 'check', 'television', 'after_shave', 'cupboard', 'sink', 'home_office', 'table', 'tooth_paste']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": Twist the lamp switch until the light goes on.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']\n}\n", "input": "\nScene_Objects:['fork', 'pot', 'food_bread', 'microwave', 'walllamp', 'trashcan', 'knife', 'cpuscreen', 'floor', 'phone', 'bookshelf', 'computer', 'toaster', 'ceilinglamp', 'plate', 'shower', 'foundation', 'clothes_pants', 'wall', 'coffe_maker', 'television', 'water', 'kitchen_counter', 'hairbrush', 'cupboard', 'sink', 'spoon', 'bathroom_cabinet', 'light', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "first i will take all the dishes to the dish washer and with the help of dishwasher and water i will clean all the dishes", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[FIND] <fork>", "[GRAB] <fork>", "[PUTBACK] <fork> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <spoon>", "[GRAB] <spoon>", "[PUTBACK] <spoon> <dishwasher>", "[FIND] <water>", "[TURNTO] <water>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": Walk to living room. Find couch. Sit on couch,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['spectacles', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'toilet', 'walllamp', 'cat', 'drawing', 'floor', 'ceiling', 'character', 'bookshelf', 'food_cake', 'piano_bench', 'shower', 'faucet', 'pillow', 'wall', 'photoframe', 'bed', 'curtain', 'doorjamb', 'diary', 'dresser', 'cupboard', 'door', 'bathroom_cabinet', 'soap', 'instrument_violin']\nTask:Go to toilet\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'tablelamp', 'microwave', 'toilet', 'chair', 'freezer', 'band-aids', 'trashcan', 'drawing', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'mat', 'tvstand', 'shower', 'pillow', 'wall', 'bed', 'photoframe', 'food_food', 'doorjamb', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'door']\nTask:Put groceries in Fridge\nresponse:\n{\n    \"thoughts\": I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTIN] <food_food> <freezer>', '[CLOSE] <freezer>']\n}\n", "input": "\nScene_Objects:['pot', 'food_salt', 'crayon', 'chair', 'freezer', 'detergent', 'food_butter', 'drawing', 'knife', 'hanger', 'floor', 'character', 'piano_bench', 'toaster', 'clothes_socks', 'food_peanut_butter', 'pillow', 'food_kiwi', 'coffe_maker', 'food_donut', 'tray', 'curtain', 'shaving_cream', 'mouse', 'kitchen_counter', 'dishrack', 'hair', 'door', 'hairdryer', 'napkin']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "Turning on lights", "actions": ["[WALK] <bedroom>", "[WALK] <floor_lamp>", "[FIND] <floor_lamp>", "[SWITCHON] <floor_lamp>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'microwave', 'blow_dryer', 'detergent', 'cat', 'drawing', 'desk', 'thread', 'computer', 'button', 'table_cloth', 'ceilinglamp', 'tvstand', 'mousepad', 'broom', 'nightstand', 'oven', 'powersocket', 'box', 'newspaper', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'conditioner', 'bag', 'napkin', 'table', 'light', 'soap']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": I walk to my cat, and I pet him,\n    \"actions\": ['[WALK] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['water_glass', 'pot', 'food_ice_cream', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'mousepad', 'food_peanut_butter', 'food_orange', 'wall', 'oven', 'powersocket', 'cutting_board', 'water', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'spoon', 'light']\nTask:Drink\nresponse:\n", "output": {"thoughts": "I enter the kitchen and grab a waterglass from the cupboard. I open the fridge and grap some water. I pour the water into the cup and drink it.", "actions": ["[WALK] <dining_room>", "[WALK] <cupboard>", "[FIND] <cupboard>", "[OPEN] <cupboard>", "[FIND] <water_glass>", "[GRAB] <water_glass>", "[WALK] <freezer>", "[OPEN] <freezer>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[POUR] <water> <water_glass>", "[DRINK] <water_glass>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_ice_cream', 'chair', 'detergent', 'milk', 'knife', 'drawing', 'cpuscreen', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'faucet', 'couch', 'wall', 'photoframe', 'bed', 'water', 'after_shave', 'mouse', 'controller', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": Walk to bathroom. Walk to sink and turn on the water. Grab the soap and wash the hands.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <water>', '[TURNTO] <water>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>']\n}\n", "input": "\nScene_Objects:['spectacles', 'food_salt', 'chair', 'jelly', 'walllamp', 'milk', 'floor', 'bedroom', 'keyboard', 'button', 'plate', 'tvstand', 'shower', 'window', 'dustpan', 'dining_room', 'nightstand', 'oven', 'basket_for_clothes', 'check', 'coffe_maker', 'tray', 'controller', 'clothes_dress', 'food_steak', 'napkin', 'soap', 'clothes_shirt', 'scrabble', 'washing_machine']\nTask:Wash clothes\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['measuring_cup', 'chair', 'walllamp', 'food_butter', 'drawing', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'tvstand', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'photoframe', 'bed', 'coffe_maker', 'television', 'food_donut', 'tray', 'curtain', 'doorjamb', 'pencil', 'dresser', 'napkin', 'dirt']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": move to living room, locate sofa, move to sofa, sit on sofa, lie on sofa,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']\n}\n", "input": "\nScene_Objects:['food_ice_cream', 'chair', 'walllamp', 'bathroom', 'orchid', 'knifeblock', 'cpuscreen', 'needle', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'mousepad', 'couch', 'dining_room', 'wall', 'basket_for_clothes', 'light_bulb', 'food_food', 'check', 'toothbrush_holder', 'mouse', 'comb', 'door', 'clothes_scarf', 'table']\nTask:Work\nresponse:\n", "output": {"thoughts": "I walk to the home office. I open the door of the office room and sit on the chair and in front of me is my desktop computer,  and I switch on the computer.", "actions": ["[WALK] <home_office>", "[WALK] <chair>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <computer>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'toilet', 'orchid', 'drawing', 'ceiling', 'bedroom', 'computer', 'mat', 'shoe-shine_kit', 'stereo', 'ceilinglamp', 'window', 'tvstand', 'food_orange', 'nightstand', 'bench', 'bed', 'coffe_maker', 'food_food', 'television', 'doorjamb', 'mouse', 'pencil', 'dresser', 'pajamas', 'cupboard', 'bathtub', 'table', 'clothes_shirt', 'coffee']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[SWITCHON] <stereo>']\n}\n", "input": "\nScene_Objects:['microwave', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'food_bacon', 'toaster', 'tvstand', 'window', 'oil', 'couch', 'wall', 'nightstand', 'newspaper', 'coffe_maker', 'television', 'coffee_filter', 'water', 'food_donut', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'dirt']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Walk to Kitchen and find coffee maker, find coffee filter and place it in coffee maker. Find ground coffee and water. put both in coffee maker. Close the coffee maker and switch it on.", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[OPEN] <coffe_maker>", "[FIND] <coffee_filter>", "[GRAB] <coffee_filter>", "[PUTBACK] <coffee_filter> <coffe_maker>", "[FIND] <ground_coffee>", "[GRAB] <ground_coffee>", "[PUTBACK] <ground_coffee> <coffe_maker>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[POUR] <water> <coffe_maker>", "[CLOSE] <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'bookmark', 'toaster', 'mat', 'tvstand', 'faucet', 'shower', 'laptop', 'mousepad', 'wall', 'oven', 'powersocket', 'towel_rack', 'kitchen_counter', 'headset', 'door', 'sink', 'bathtub', 'home_office', 'bathroom_cabinet', 'light']\nTask:Go to toilet\nresponse:\n{\n    \"thoughts\": I go to the bathroom. I locate the toilet. I walk to the toilet.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[WALK] <toilet>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'scissors', 'toilet', 'chair', 'trashcan', 'drawing', 'food_egg', 'floor', 'ceiling', 'bookshelf', 'mat', 'ceilinglamp', 'shower', 'food_jam', 'dining_room', 'broom', 'wall', 'bench', 'photoframe', 'curtain', 'food_onion', 'doorjamb', 'dresser', 'hairbrush', 'cupboard', 'door', 'food_steak', 'light', 'table', 'teeth']\nTask:Take shower\nresponse:\n", "output": {"thoughts": "Walk to the bathroom and wash with the shower.", "actions": ["[WALK] <bathroom>", "[WALK] <shower>", "[FIND] <shower>", "[WASH] <shower>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'freezer', 'ground_coffee', 'walllamp', 'food_egg', 'floor', 'ceiling', 'character', 'bedroom', 'bookshelf', 'stovefan', 'plate', 'mousepad', 'wall', 'nightstand', 'powersocket', 'novel', 'coffe_maker', 'check', 'coffee_filter', 'water', 'wooden_spoon', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'soap', 'teeth', 'shoe_rack']\nTask:Make coffee\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['spectacles', 'pot', 'scissors', 'microwave', 'jelly', 'trashcan', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'shampoo', 'ceiling', 'keyboard', 'mail', 'brush', 'toaster', 'stovefan', 'plate', 'picture', 'oil', 'form', 'bowl', 'photoframe', 'newspaper', 'bed', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'home_office']\nTask:Read book\nresponse:\n", "output": {"thoughts": "Walk to living room. Find book. Grab book. Open book. Read book.", "actions": ["[WALK] <home_office>", "[WALK] <novel>", "[FIND] <novel>", "[GRAB] <novel>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_salt', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'tea_bag', 'bookshelf', 'food_bacon', 'toaster', 'plate', 'tvstand', 'dish_soap', 'mousepad', 'couch', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'toothbrush_holder', 'ice', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'clothes_dress', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['glue', 'mop', 'microwave', 'trashcan', 'bills', 'orchid', 'knifeblock', 'drawing', 'hanger', 'floor', 'phone', 'tvstand', 'form', 'pillow', 'bench', 'powersocket', 'light_bulb', 'video_game_controller', 'water', 'centerpiece', 'doorjamb', 'mouse', 'pencil', 'cd', 'door', 'napkin', 'dishwasher', 'soap', 'hands_both', 'creditcard']\nTask:Wash hands\nresponse:\n", "output": {"thoughts": "walk to bathroom, look at the water, wash hands", "actions": ["[WALK] <bathroom>", "[WALK] <water>", "[FIND] <water>", "[TURNTO] <water>", "[LOOKAT] <water>", "[FIND] <hands_both>", "[WASH] <hands_both>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'glue', 'filing_cabinet', 'microwave', 'jelly', 'freezer', 'ceilingfan', 'orchid', 'food_egg', 'floor', 'phone', 'ceiling', 'desk', 'thread', 'mat', 'laptop', 'deck_of_cards', 'faucet', 'foundation', 'pillow', 'nightstand', 'powersocket', 'basket_for_clothes', 'food_food', 'lighter', 'sink', 'home_office', 'vase', 'soap', 'washing_machine']\nTask:Wash clothes\nresponse:\n{\n    \"thoughts\": I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <bathroom>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[FIND] <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'food_bread', 'bathroom', 'hanger', 'floor', 'bookshelf', 'table_cloth', 'stereo', 'window', 'electric_shaver', 'mousepad', 'couch', 'food_orange', 'oven', 'photoframe', 'newspaper', 'bed', 'doorjamb', 'kettle', 'cards', 'hairbrush', 'dresser', 'food_steak', 'clothes_scarf', 'napkin', 'home_office', 'table', 'clothes_skirt', 'scrabble', 'teeth']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.", "actions": ["[WALK] <home_office>", "[WALK] <remote_control>", "[GRAB] <remote_control>", "[TURNTO] <remote_control>", "[POINTAT] <remote_control>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'microwave', 'ground_coffee', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'toaster', 'plate', 'faucet', 'foundation', 'mousepad', 'food_jam', 'food_kiwi', 'wall', 'pasta', 'powersocket', 'food_food', 'coffe_maker', 'rag', 'shaving_cream', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Take a dish and put it in the dishwasher to be washed,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'microwave', 'walllamp', 'food_carrot', 'character', 'desk', 'keyboard', 'shower', 'washing_machine', 'window', 'mousepad', 'clothes_pants', 'towel', 'wall', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'food_rice', 'headset', 'chessboard', 'hair', 'napkin', 'table', 'soap', 'scrabble', 'dirt', 'coffee', 'creditcard']\nTask:Wash clothes\nresponse:\n", "output": {"thoughts": "walk to the bathroom, grab the basket for clothes, find soap, put in washing machine, turn on", "actions": ["[WALK] <bathroom>", "[WALK] <basket_for_clothes>", "[FIND] <basket_for_clothes>", "[GRAB] <basket_for_clothes>", "[WALK] <washing_machine>", "[OPEN] <washing_machine>", "[PUTBACK] <basket_for_clothes> <washing_machine>", "[FIND] <soap>", "[GRAB] <soap>", "[WALK] <washing_machine>", "[PUTBACK] <soap> <washing_machine>", "[CLOSE] <washing_machine>", "[SWITCHON] <washing_machine>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'trashcan', 'toothbrush', 'bathroom_counter', 'shampoo', 'floor', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'toaster', 'ceilinglamp', 'iron', 'shower', 'stereo', 'pillow', 'wall', 'wall_clock', 'photoframe', 'food_food', 'water', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'home_office', 'bathroom_cabinet', 'tooth_paste', 'teeth']\nTask:Wash teeth\nresponse:\n{\n    \"thoughts\": Walk to bathroom. Find tooth paste, tooth brush and water. Squeeze tooth paste on tooth brush. Wash teeth.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[FIND] <toothbrush>', '[FIND] <water>', '[SQUEEZE] <tooth_paste>', '[FIND] <teeth>', '[WASH] <teeth>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'food_salt', 'microwave', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'food_butter', 'drawing', 'knifeblock', 'floor', 'ceiling', 'toaster', 'mat', 'food_jam', 'pillow', 'wall', 'oven', 'bench', 'cup', 'newspaper', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'food_onion', 'kitchen_counter', 'cupboard', 'home_office', 'dishwasher']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "I walk into the kitchen. I find the coffee maker and open it. I find the coffee filter, grab it and put it into the coffee maker. I find ground coffee, grab it and put it into the coffee maker. I find some water, then I pour it into the coffee maker. I close the coffee maker, I plug it in and I switch it on.", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[OPEN] <coffe_maker>", "[FIND] <coffee_filter>", "[GRAB] <coffee_filter>", "[PUTBACK] <coffee_filter> <coffe_maker>", "[FIND] <ground_coffee>", "[GRAB] <ground_coffee>", "[PUTBACK] <ground_coffee> <coffe_maker>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[POUR] <water> <coffe_maker>", "[CLOSE] <coffe_maker>", "[PLUGIN] <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'oil', 'wall', 'nightstand', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'clothes_dress', 'door', 'light']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": I want to surf the internet and look around at funny pictures.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'tablelamp', 'microwave', 'chair', 'bathroom', 'orchid', 'drawing', 'food_egg', 'knife', 'floor', 'computer', 'tvstand', 'window', 'couch', 'candle', 'microphone', 'pillow', 'towel', 'wall', 'food_food', 'check', 'television', 'wooden_spoon', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'napkin', 'table', 'coffee']\nTask:Set up table\nresponse:\n", "output": {"thoughts": "walk to entrance hall. find a table. pull table. walk to living rook. push table.", "actions": ["[WALK] <home_office>", "[WALK] <table>", "[FIND] <table>", "[PULL] <table>", "[WALK] <home_office>", "[WALK] <table>", "[PUSH] <table>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['juice', 'crayon', 'walllamp', 'trashcan', 'dough', 'floor', 'phone', 'bedroom', 'tea_bag', 'toaster', 'mat', 'plate', 'ceilinglamp', 'dish_soap', 'wall', 'pasta', 'oven', 'cutting_board', 'food_cheese', 'newspaper', 'coffe_maker', 'check', 'food_food', 'tray', 'towel_rack', 'pencil', 'dresser', 'conditioner', 'home_office', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": I walk to the kitchen. I search and find dishwasher. I search dishes. I put dishes inside the dishwasher. I put dish soap in dishwasher. I switch on dishwasher and wait for dishes to be washed.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'milk', 'floor', 'ceiling', 'desk', 'keyboard', 'button', 'mop_bucket', 'toaster', 'stereo', 'window', 'wall', 'powersocket', 'bench', 'newspaper', 'coffe_maker', 'tray', 'curtain', 'food_sugar', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'coffee_cup', 'dishwasher', 'light', 'clothes_shirt']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[TURNTO] <coffe_maker>", "[LOOKAT] <coffe_maker>", "[OPEN] <coffe_maker>", "[FIND] <milk>", "[GRAB] <milk>", "[PUTBACK] <milk> <coffe_maker>", "[FIND] <food_sugar>", "[FIND] <coffee_cup>", "[GRAB] <coffee_cup>", "[PUTBACK] <coffee_cup> <coffe_maker>", "[SWITCHON] <coffe_maker>", "[FIND] <button>", "[PUSH] <button>", "[GRAB] <coffee_cup>", "[DRINK] <coffee_cup>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_salt', 'microwave', 'detergent', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'shoe-shine_kit', 'faucet', 'clothes_socks', 'closetdrawer', 'mousepad', 'dining_room', 'broom', 'wall', 'nightstand', 'photoframe', 'television', 'water', 'tray', 'cards', 'paper_towel', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my hands.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <water>', '[TURNTO] <water>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <water>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>']\n}\n", "input": "\nScene_Objects:['pot', 'food_ice_cream', 'mop', 'tea', 'freezer', 'walllamp', 'floor', 'character', 'stovefan', 'toaster', 'mat', 'tvstand', 'stereo', 'window', 'electric_shaver', 'food_noodles', 'couch', 'soap', 'pillow', 'wall', 'bench', 'toilet_paper', 'food_food', 'doorjamb', 'diary', 'dresser', 'hairbrush', 'napkin', 'bathroom_cabinet', 'colander']\nTask:Go to toilet\nresponse:\n", "output": {"thoughts": "I walk to bathroom. find closet. Uset It. Clean it. Use Toilet paper", "actions": ["[WALK] <bathroom>", "[WALK] <dresser>", "[FIND] <dresser>", "[OPEN] <dresser>", "[CLOSE] <dresser>", "[FIND] <toilet_paper>", "[WASH] <dresser>", "[FIND] <toilet_paper>", "[TOUCH] <toilet_paper>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'bathroom', 'food_carrot', 'wallshelf', 'ceiling', 'dvd_player', 'character', 'bedroom', 'desk', 'keyboard', 'thread', 'stovefan', 'shower', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'cup', 'bed', 'food_food', 'razor', 'toothbrush_holder', 'curtain', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'napkin', 'table', 'clothes_skirt']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": Go to the living room.  Find the telephone.  Lift up the receiver.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['sponge', 'spectacles', 'microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'character', 'desk', 'alcohol', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'photoframe', 'light_bulb', 'television', 'curtain', 'kettle', 'napkin', 'bathroom_cabinet', 'table', 'creditcard']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "walk to living room, walk to sofa, sit on sofa.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'dvd_player', 'desk', 'keyboard', 'purse', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'food_noodles', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'table']\nTask:Write an email\nresponse:\n{\n    \"thoughts\": FIRST YOU NEED TO SWITVH ON YOU COMPUTER AND CHECK THE INTERNET CONNECTION.FOR SENDING EMAIL EMAIL ID FOR REQUIRED FOR BOTH SEND AND RECEIVE .SO CLEALY MENTION THE ID ON THE TO PLACE THEN ONLY IT WILL GO CORRECTLY,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <table>', '[FIND] <table>', '[FIND] <computer>', '[SWITCHON] <computer>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'microwave', 'walllamp', 'detergent', 'trashcan', 'floor', 'ceiling', 'bedroom', 'toaster', 'mat', 'stereo', 'pillow', 'wall', 'cup', 'bed', 'coffe_maker', 'food_food', 'coffee_filter', 'water', 'food_donut', 'wooden_spoon', 'food_onion', 'doorjamb', 'pencil', 'kitchen_counter', 'cupboard', 'napkin', 'spoon', 'dishwasher', 'coffee']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "I find the coffee machine, fill it with water and coffee then press the button to make the coffee", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[OPEN] <coffe_maker>", "[FIND] <coffee_filter>", "[GRAB] <coffee_filter>", "[PUTBACK] <coffee_filter> <coffe_maker>", "[WALK] <coffee>", "[FIND] <coffee>", "[GRAB] <coffee>", "[POUR] <coffee> <coffe_maker>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[POUR] <water> <coffe_maker>", "[CLOSE] <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'tablelamp', 'juice', 'nail_polish', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'mat', 'shower', 'window', 'closetdrawer', 'wall', 'nightstand', 'cutting_board', 'bed', 'photoframe', 'coffe_maker', 'television', 'curtain', 'mouse', 'pencil', 'vacuum_cleaner', 'hair', 'maindoor', 'table', 'vase']\nTask:Read book\nresponse:\n{\n    \"thoughts\": I lie on my bed and read a book.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <bed>', '[LIE] <bed>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'microwave', 'walllamp', 'drawing', 'orchid', 'floor', 'folder', 'mop_bucket', 'ceilinglamp', 'stereo', 'picture', 'window', 'mousepad', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'bench', 'powersocket', 'novel', 'coffe_maker', 'toilet_paper', 'toothbrush_holder', 'tray', 'curtain', 'lighter', 'headset', 'cupboard', 'table']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "I walk to the living room and find the sofa. I sit on the sofa and get comfortable.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'hanger', 'floor', 'mat', 'tvstand', 'window', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'cutting_board', 'cup', 'novel', 'food_food', 'television', 'wine', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'shoes', 'bathtub', 'bathroom_cabinet', 'table', 'soap', 'board_game']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": lie in the sofa, relax,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']\n}\n", "input": "\nScene_Objects:['sponge', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'foundation', 'couch', 'microphone', 'wall', 'powersocket', 'oven', 'bed', 'television', 'wooden_spoon', 'doorjamb', 'lighter', 'dresser', 'door', 'table']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want.", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[PLUGIN] <television>", "[FIND] <remote_control>", "[TURNTO] <television>", "[POINTAT] <television>", "[SWITCHON] <television>", "[FIND] <button>", "[PUSH] <button>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'microwave', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door', 'bag', 'light', 'table']\nTask:Turn on computer\nresponse:\n{\n    \"thoughts\": Press the power button on the computer to turn it on,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>']\n}\n", "input": "\nScene_Objects:['scissors', 'food_ice_cream', 'chair', 'bathroom', 'trashcan', 'food_carrot', 'shampoo', 'phone', 'floor', 'stamp', 'bookshelf', 'ceilinglamp', 'window', 'homework', 'couch', 'clothes_pants', 'pillow', 'nightstand', 'cup', 'bed', 'check', 'food_food', 'ice', 'headset', 'cupboard', 'door', 'home_office', 'light', 'dishwasher', 'clothes_shirt']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "walk to phone, grab phone, pick up phone, put to ear", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['water_glass', 'filing_cabinet', 'food_salt', 'microwave', 'blow_dryer', 'detergent', 'knife', 'orchid', 'bathroom_counter', 'shampoo', 'keyboard', 'bookshelf', 'mail', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'faucet', 'food_peanut_butter', 'dining_room', 'nightstand', 'oven', 'cup', 'light_bulb', 'food_food', 'television', 'food_onion', 'pencil', 'napkin', 'light']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['spectacles', 'pot', 'filing_cabinet', 'scissors', 'toilet', 'freezer', 'ground_coffee', 'detergent', 'food_egg', 'cpuscreen', 'phone', 'folder', 'character', 'keyboard', 'envelope', 'piano_bench', 'ceilinglamp', 'plate', 'faucet', 'couch', 'coffe_maker', 'food_donut', 'tray', 'centerpiece', 'doorjamb', 'mouse', 'dishrack', 'dresser', 'bathroom_cabinet', 'light']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "I walk to the home office, find where the phone is and lift the reciever.", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['blender', 'chair', 'walllamp', 'dough', 'orchid', 'cpuscreen', 'hanger', 'floor', 'keyboard', 'remote_control', 'food_cake', 'envelope', 'computer', 'button', 'food_bacon', 'ceilinglamp', 'stereo', 'homework', 'oven', 'tape', 'photoframe', 'coffee_table', 'keys', 'check', 'novel', 'light_bulb', 'wooden_spoon', 'curtain', 'cd', 'home_office']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": walk next to the coffee table. pick up the remote control from the top of the coffee table. Point the remote to the TV. Press the blue arrow on the remote.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'food_bread', 'microwave', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'box', 'oven_mitts', 'food_onion', 'doorjamb', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'door', 'light', 'soap']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "Turning on lights", "actions": ["[WALK] <bedroom>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>", "[WALK] <bathroom>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'food_pizza', 'food_salt', 'jelly', 'band-aids', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'broom', 'wall', 'powersocket', 'doorjamb', 'lighter', 'door', 'sink', 'light', 'table', 'laser_pointer', 'clothes_shirt', 'creditcard']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": I go into my room, find the light,  then turn on the lights.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[WALK] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['pot', 'walllamp', 'trashcan', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bedroom', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'foundation', 'dustpan', 'pillow', 'broom', 'wall', 'powersocket', 'cup', 'video_game_controller', 'television', 'doorjamb', 'hairbrush', 'door', 'sink', 'bag', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "Walk to living room.  Find remote control.  Find television.  Point remote at television.  Press \"on\" button.  Watch.", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[FIND] <remote_control>", "[TURNTO] <television>", "[POINTAT] <television>", "[FIND] <button>", "[PUSH] <button>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'food_pizza', 'filing_cabinet', 'toilet', 'walllamp', 'detergent', 'orchid', 'food_egg', 'floor', 'phone', 'ceiling', 'character', 'keyboard', 'alcohol', 'toaster', 'tvstand', 'faucet', 'balanceball', 'picture', 'wall', 'oven', 'tape', 'food_cheese', 'photoframe', 'newspaper', 'coffe_maker', 'tray', 'towel_rack', 'table', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['tea', 'walllamp', 'drawing', 'orchid', 'food_egg', 'floor', 'ceiling', 'phone', 'character', 'remote_control', 'button', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'faucet', 'shower', 'couch', 'clothes_hat', 'wall', 'powersocket', 'basket_for_clothes', 'check', 'mouthwash', 'television', 'food_onion', 'doorjamb', 'controller', 'door', 'table']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "Walk to TV, grab remote control, press change channel button, repeat pressing change channel button util find the channel wanted, put back remote control", "actions": ["[WALK] <television>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <button>", "[TOUCH] <button>", "[TURNTO] <television>", "[WATCH] <television>", "[TOUCH] <button>", "[TURNTO] <television>", "[WATCH] <television>", "[PUTOBJBACK] <remote_control>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'filing_cabinet', 'freezer', 'blow_dryer', 'bathroom', 'detergent', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'toaster', 'faucet', 'stereo', 'couch', 'pillow', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'bed', 'photoframe', 'mouse', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": Washing Hands,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[TOUCH] <soap>', '[PUTOBJBACK] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']\n}\n", "input": "\nScene_Objects:['pot', 'microwave', 'band-aids', 'walllamp', 'drawing', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'bookmark', 'brush', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'plate', 'oil', 'mousepad', 'wall', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'doorjamb', 'door', 'napkin', 'table', 'teeth']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "Watch TV in the living room.", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[SWITCHON] <television>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Drink\nresponse:\n{\n    \"thoughts\": I walk to the kitchen. open the cupboard. Find the water glass, grab it. Fill the glass with water and drink water.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['food_salt', 'microwave', 'cat', 'drawing', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bedroom', 'table_cloth', 'mat', 'plate', 'stereo', 'ceilinglamp', 'tvstand', 'electric_shaver', 'microphone', 'wall', 'powersocket', 'light_bulb', 'keys', 'doorjamb', 'pencil', 'laundry_detergent', 'door', 'clothes_scarf', 'sink', 'spoon', 'light']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "I open the room door and press the light button on", "actions": ["[WALK] <home_office>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'drawing', 'orchid', 'knifeblock', 'bills', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'shower', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'television', 'food_rice', 'tray', 'curtain', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'home_office', 'table', 'light', 'bathroom_cabinet']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": Walk into the living room. Walk up to the sofa. Sit down on the sofa.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['pot', 'jelly', 'chair', 'freezer', 'bathroom', 'food_carrot', 'knifeblock', 'bathroom_counter', 'keyboard', 'alcohol', 'clothes_jacket', 'stovefan', 'mat', 'toaster', 'stereo', 'picture', 'ceilinglamp', 'dining_room', 'bowl', 'wall', 'oven', 'powersocket', 'cup', 'photoframe', 'check', 'video_game_controller', 'razor', 'food_food', 'curtain', 'shoes']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "turn radio on, listen to music", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['measuring_cup', 'microwave', 'cat', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'character', 'desk', 'mat', 'deck_of_cards', 'iron', 'stereo', 'balanceball', 'shower', 'faucet', 'mousepad', 'nightstand', 'oven', 'television', 'tray', 'curtain', 'mouse', 'pencil', 'kitchen_counter', 'dresser', 'cupboard', 'clothes_dress', 'sink', 'vase']\nTask:Walk through\nresponse:\n{\n    \"thoughts\": Walk through the hallway.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <home_office>']\n}\n", "input": "\nScene_Objects:['scissors', 'chair', 'freezer', 'floor', 'phone', 'character', 'thread', 'ceilinglamp', 'stereo', 'shower', 'window', 'mousepad', 'pillow', 'broom', 'wall', 'cup', 'photoframe', 'clothes_gloves', 'food_food', 'coffe_maker', 'razor', 'lighter', 'doorjamb', 'shoes', 'hairbrush', 'napkin', 'bathroom_cabinet', 'table', 'laser_pointer', 'clothes_shirt']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "Find the radio; switch on the radio and listen to music.", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Greet guests\nresponse:\n{\n    \"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.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <man>', '[FIND] <man>', '[GREET] <man>', '[FIND] <woman>', '[GREET] <woman>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'dog', 'walllamp', 'bathroom', 'drawing', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'computer', 'bookmark', 'ceilinglamp', 'tvstand', 'shower', 'window', 'foundation', 'couch', 'pillow', 'wall', 'razor', 'toothbrush_holder', 'tray', 'curtain', 'mouse', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "allow sofa to support weight in order to decrease gravity induced entropy", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[WALK] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'blender', 'crayon', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'oven', 'cup', 'bed', 'clothes_gloves', 'newspaper', 'coffe_maker', 'curtain', 'hairbrush', 'food_steak', 'bag', 'table']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": walk to living room, find sofa, sit in sofa,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[WALK] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['jelly', 'trashcan', 'cpuscreen', 'clothes_underwear', 'ceiling', 'folder', 'desk', 'computer', 'stovefan', 'shower', 'mousepad', 'candle', 'clothes_hat', 'dining_room', 'newspaper', 'photoframe', 'food_food', 'video_game_controller', 'oven_mitts', 'curtain', 'pencil', 'kitchen_counter', 'dishrack', 'laundry_detergent', 'door', 'light', 'dishwasher', 'soap', 'tooth_paste', 'washing_machine']\nTask:Wash clothes\nresponse:\n", "output": {"thoughts": "Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on.", "actions": ["[WALK] <home_office>", "[WALK] <washing_machine>", "[FIND] <washing_machine>", "[OPEN] <washing_machine>", "[FIND] <clothes_underwear>", "[GRAB] <clothes_underwear>", "[PUTBACK] <clothes_underwear> <washing_machine>", "[FIND] <soap>", "[GRAB] <soap>", "[PUTBACK] <soap> <washing_machine>", "[CLOSE] <washing_machine>", "[SWITCHON] <washing_machine>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'mop', 'toilet', 'freezer', 'walllamp', 'bathroom', 'cat', 'food_butter', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'iron', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'toy', 'tape', 'photoframe', 'television', 'food_rice', 'doorjamb', 'cards', 'door']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['pot', 'chair', 'walllamp', 'ground_coffee', 'detergent', 'trashcan', 'orchid', 'drawing', 'bedroom', 'tea_bag', 'bookshelf', 'envelope', 'alcohol', 'computer', 'ceilinglamp', 'mat', 'shower', 'deck_of_cards', 'food_noodles', 'microphone', 'bowl', 'wall', 'bench', 'powersocket', 'photoframe', 'television', 'dresser', 'napkin', 'table', 'clothes_shirt']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[WALK] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'food_ice_cream', 'chair', 'nail_polish', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'ceilinglamp', 'balanceball', 'shower', 'mousepad', 'pillow', 'wall', 'nightstand', 'basket_for_clothes', 'toothbrush_holder', 'doorjamb', 'mouse', 'light', 'vase']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": Walk to the Home Office.  Find the computer.  Turn on the computer.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>']\n}\n", "input": "\nScene_Objects:['food_salt', 'beer', 'microwave', 'chair', 'drawing', 'hanger', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'bookmark', 'laptop', 'ceilinglamp', 'faucet', 'shower', 'mousepad', 'couch', 'food_peanut_butter', 'photoframe', 'newspaper', 'razor', 'tray', 'kitchen_counter', 'vacuum_cleaner', 'clothes_dress', 'door', 'bathroom_cabinet', 'tooth_paste']\nTask:Write an email\nresponse:\n", "output": {"thoughts": "I go to my bed room and sit on the chair and in front of me is my desktop computer and start writing an email.", "actions": ["[WALK] <bathroom>", "[WALK] <chair>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <computer>", "[SWITCHON] <computer>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'filing_cabinet', 'nail_polish', 'toothbrush', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'food_food', 'toothbrush_holder', 'tray', 'dresser', 'cupboard', 'controller', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'light', 'tooth_paste']\nTask:Wash teeth\nresponse:\n{\n    \"thoughts\": I go into the bathroom, go to the sink, get toothbrush and toothpaste. Put toothpaste on the toothbrush, brush teeth, turn on faucet, rinse brush, and return toothbrush.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[PUTBACK] <toothbrush> <toothbrush_holder>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'tablelamp', 'toilet', 'walllamp', 'trashcan', 'drawing', 'orchid', 'bills', 'floor', 'ceiling', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'plate', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'cup', 'photoframe', 'television', 'curtain', 'doorjamb', 'console', 'door', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "go to living room, sit on couch, get remote, switch on tv, watch tv", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>", "[TURNTO] <television>", "[LOOKAT] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['chair', 'walllamp', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'coffe_maker', 'television', 'doorjamb', 'mouse', 'dresser', 'food_steak', 'sink', 'bathroom_cabinet', 'table']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": I sit at my computer desk and open the browser.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>']\n}\n", "input": "\nScene_Objects:['pot', 'microwave', 'freezer', 'bathroom', 'trashcan', 'dough', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'food_cake', 'computer', 'toaster', 'ceilinglamp', 'mat', 'deck_of_cards', 'mousepad', 'clothes_socks', 'pillow', 'wall', 'powersocket', 'bench', 'oven', 'food_food', 'doorjamb', 'mouse', 'door', 'light']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['juice', 'food_salt', 'walllamp', 'detergent', 'trashcan', 'knifeblock', 'drawing', 'floor', 'stamp', 'table_cloth', 'plate', 'faucet', 'deck_of_cards', 'clothes_pants', 'wall', 'bench', 'powersocket', 'tape', 'photoframe', 'food_food', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'coffee']\nTask:Bring dirty plate to sink\nresponse:\n{\n    \"thoughts\": Stand up from the table.  Pick up dirty plate.  Walk to sink.  Put plate in sink.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[TURNTO] <table>', '[FIND] <plate>', '[GRAB] <plate>', '[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <sink>', '[PUTBACK] <plate> <sink>']\n}\n", "input": "\nScene_Objects:['sheets', 'freezer', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'mousepad', 'wall', 'powersocket', 'food_food', 'food_donut', 'tray', 'after_shave', 'doorjamb', 'cards', 'mouse', 'shoes', 'dresser', 'food_steak', 'door', 'bathroom_cabinet', 'light', 'clothes_skirt']\nTask:Cook some food\nresponse:\n", "output": {"thoughts": "Go kitchen and make something for eat", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": I go to the living room then go to the cat and touch it.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['measuring_cup', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'phone', 'character', 'stamp', 'tea_bag', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'iron', 'brush', 'window', 'couch', 'food_orange', 'pillow', 'wall', 'bench', 'tray', 'curtain', 'after_shave', 'sink', 'bathroom_cabinet', 'table', 'home_office', 'soap']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "Sitting down and relaxing on the sofa", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'drawing', 'hanger', 'floor', 'ceiling', 'computer', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'foundation', 'oil', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'novel', 'television', 'curtain', 'after_shave', 'door', 'napkin', 'home_office', 'table']\nTask:Turn off TV\nresponse:\n{\n    \"thoughts\": Walk over to tv and press power button,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[SWITCHOFF] <television>']\n}\n", "input": "\nScene_Objects:['spectacles', 'blender', 'food_salt', 'jelly', 'freezer', 'orchid', 'drawing', 'clothes_underwear', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'toaster', 'tvstand', 'shower', 'mousepad', 'clothes_pants', 'wall', 'powersocket', 'bed', 'food_food', 'tray', 'doorjamb', 'cards', 'controller', 'door', 'light', 'dishwasher']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "I enter the bedroom and find the light. Then I turn it on.", "actions": ["[WALK] <bedroom>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": The task is browse and surf on the internet regarding a particular topic,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[WATCH] <laptop>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'freezer', 'bathroom', 'detergent', 'food_butter', 'drawing', 'hanger', 'phone', 'bedroom', 'desk', 'toaster', 'brush', 'stereo', 'faucet', 'window', 'couch', 'pillow', 'dining_room', 'nightstand', 'powersocket', 'cup', 'coffe_maker', 'mouthwash', 'television', 'curtain', 'doorjamb', 'mouse', 'napkin', 'teeth']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "Listen to music", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'cat', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'ceilinglamp', 'brush', 'faucet', 'stereo', 'tvstand', 'towel', 'pillow', 'wall', 'pasta', 'powersocket', 'coffe_maker', 'oven_mitts', 'tray', 'curtain', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'food_ice_cream', 'bathroom', 'food_carrot', 'knifeblock', 'hanger', 'bookshelf', 'computer', 'button', 'stovefan', 'couch', 'candle', 'dining_room', 'wall', 'bench', 'basket_for_clothes', 'newspaper', 'light_bulb', 'check', 'coffe_maker', 'television', 'after_shave', 'curtain', 'comb', 'pajamas', 'hair', 'door', 'sink', 'dishwasher', 'colander']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Walk to living room. Find the cat. Walk over to the cat. Touch the cat.", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[WALK] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'beer', 'microwave', 'chair', 'freezer', 'ground_coffee', 'floor', 'ceiling', 'mail', 'food_bacon', 'toaster', 'deck_of_cards', 'faucet', 'window', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toy', 'light_bulb', 'coffe_maker', 'coffee_filter', 'water', 'curtain', 'after_shave', 'pencil', 'kitchen_counter', 'pajamas', 'sink', 'light']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[FIND] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'chair', 'freezer', 'dog', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'envelope', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'pasta', 'nightstand', 'bench', 'photoframe', 'tray', 'mouse', 'door', 'table', 'soap']\nTask:Work\nresponse:\n", "output": {"thoughts": "go to home office. turn the computer on. begin working", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'photoframe', 'check', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'table', 'light']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Go to the living room. Find the remote. Pick up the remote. Find the sofa. Sit on the sofa. Look at the television. Aim the remote at the television. Press the power button. Flip the channels.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[PUSH] <remote_control>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'blender', 'crayon', 'walllamp', 'cat', 'drawing', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'plate', 'window', 'couch', 'pillow', 'wall', 'oven', 'cup', 'bed', 'clothes_gloves', 'newspaper', 'coffe_maker', 'curtain', 'hairbrush', 'food_steak', 'bag', 'table']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "walk to living room, find sofa, sit in sofa", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[WALK] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'mop', 'chair', 'band-aids', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'laptop', 'toaster', 'foundation', 'pillow', 'wall', 'powersocket', 'bench', 'novel', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'napkin', 'light', 'soap', 'instrument_violin']\nTask:Turn off light\nresponse:\n{\n    \"thoughts\": Grasp light switch, flip light switch.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[SWITCHOFF] <light>']\n}\n", "input": "\nScene_Objects:['walllamp', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'food_noodles', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'television', 'tray', 'curtain', 'doorjamb', 'mouse', 'pencil', 'hair', 'door', 'table', 'instrument_violin']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "Go to the living room and sit on the couch. Turn on television using remote control. Use remote control buttons to navigate to desired channel. Watch television.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>", "[FIND] <button>", "[PUSH] <button>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'crayon', 'chair', 'cat', 'dough', 'milk', 'hanger', 'floor', 'keyboard', 'mail', 'table_cloth', 'stovefan', 'plate', 'faucet', 'tvstand', 'window', 'couch', 'form', 'dining_room', 'cutting_board', 'photoframe', 'check', 'wine', 'dresser', 'hairbrush', 'pajamas', 'conditioner', 'home_office', 'bathroom_cabinet', 'table']\nTask:Give milk to cat\nresponse:\n{\n    \"thoughts\": Grab milk and pour it into the plate so that the cat can drink,\n    \"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>']\n}\n", "input": "\nScene_Objects:['blender', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'desk', 'computer', 'table_cloth', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'bench', 'basket_for_clothes', 'cup', 'television', 'food_rice', 'curtain', 'doorjamb', 'diary', 'shoes', 'door', 'spoon', 'bathroom_cabinet', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "I walk into the living room and sit on the sofa to watch tv", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <television>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'sponge', 'scissors', 'food_salt', 'trashcan', 'drawing', 'needle', 'hanger', 'longboard', 'floor', 'character', 'stamp', 'keyboard', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'window', 'couch', 'dining_room', 'wall', 'photoframe', 'television', 'curtain', 'rag', 'pencil', 'shoes', 'clothes_dress', 'conditioner', 'sink', 'table']\nTask:Text friends while sitting on couch\nresponse:\n{\n    \"thoughts\": Text while sitting,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[TOUCH] <phone>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'deck_of_cards', 'window', 'tvstand', 'mousepad', 'pillow', 'wall', 'pasta', 'light_bulb', 'check', 'mouthwash', 'wooden_spoon', 'mouse', 'door', 'table', 'coffee']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "Turn on computer, pull up browser, browse the internet", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>", "[TURNTO] <computer>", "[LOOKAT] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Pet cat\nresponse:\n{\n    \"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,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['glue', 'pot', 'tablelamp', 'microwave', 'drawing', 'knife', 'knifeblock', 'hanger', 'bathroom_counter', 'phone', 'stovefan', 'laptop', 'faucet', 'foundation', 'couch', 'food_orange', 'pillow', 'bowl', 'bench', 'oven', 'basket_for_clothes', 'cup', 'novel', 'razor', 'centerpiece', 'doorjamb', 'shaving_cream', 'mouse', 'door', 'soap']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "Walk to the living room, walk to the lamp, switch on the lamp.", "actions": ["[WALK] <home_office>", "[WALK] <floor_lamp>", "[SWITCHON] <floor_lamp>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'alcohol', 'toaster', 'tvstand', 'shower', 'closetdrawer', 'nightstand', 'wall_clock', 'bench', 'powersocket', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'sink', 'home_office', 'table', 'light', 'coffee']\nTask:Walk through\nresponse:\n{\n    \"thoughts\": Walk through the hallway.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>']\n}\n", "input": "\nScene_Objects:['spectacles', 'sheets', 'sponge', 'chair', 'freezer', 'trashcan', 'ceiling', 'stamp', 'desk', 'keyboard', 'table_cloth', 'stovefan', 'ceilinglamp', 'shower', 'iron', 'electric_shaver', 'mousepad', 'clothes_socks', 'powersocket', 'oven', 'tray', 'kitchen_counter', 'dishrack', 'hair', 'cupboard', 'door', 'hairdryer', 'bathroom_cabinet', 'instrument_guitar', 'coffee']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "walk to living room ,find radio ,switch on radio ,listen to music 4", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['mop', 'microwave', 'freezer', 'ground_coffee', 'dough', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'bedroom', 'tea_bag', 'toaster', 'faucet', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'wall_clock', 'bench', 'cutting_board', 'toy', 'coffe_maker', 'television', 'coffee_filter', 'water', 'mouse', 'kitchen_counter', 'sink', 'table']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['glue', 'food_bread', 'mop', 'freezer', 'trashcan', 'knifeblock', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'stovefan', 'mat', 'faucet', 'pillow', 'wall', 'powersocket', 'bed', 'food_food', 'check', 'mouthwash', 'after_shave', 'doorjamb', 'chessboard', 'dresser', 'cupboard', 'hair', 'door', 'instrument_guitar', 'light', 'creditcard']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "Walk into living room. Find wall. Find light button. Switch on light button.", "actions": ["[WALK] <home_office>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'picture', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'light']\nTask:Write an email\nresponse:\n{\n    \"thoughts\": I need to write an e-mail to my boss about the meeting at work tomorrow.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[TYPE] <keyboard>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[TURNTO] <computer>', '[LOOKAT] <computer>']\n}\n", "input": "\nScene_Objects:['microwave', 'toilet', 'knifeblock', 'floor', 'ceiling', 'purse', 'computer', 'table_cloth', 'stovefan', 'mat', 'faucet', 'window', 'bowl', 'wall', 'powersocket', 'cutting_board', 'television', 'razor', 'tray', 'after_shave', 'doorjamb', 'shoes', 'comb', 'dresser', 'door', 'home_office', 'light', 'dishwasher', 'soap', 'coffee']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "I walk in to the living room. I find the light switch. I turn on the lights.", "actions": ["[WALK] <home_office>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_ice_cream', 'measuring_cup', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'keyboard', 'mail', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'couch', 'candle', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'after_shave', 'doorjamb', 'chessboard', 'door', 'food_steak', 'bathroom_cabinet', 'table', 'board_game']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'desk', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'powersocket', 'clothes_gloves', 'television', 'razor', 'curtain', 'doorjamb', 'console', 'mouse', 'door', 'bag', 'table', 'dishwasher']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "I walk in living room. I find TV remote. I grab TV remote. I sit on sofa. I switch on TV. I switch channel.", "actions": ["[WALK] <home_office>", "[WALK] <remote_control>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[WALK] <couch>", "[SIT] <couch>", "[FIND] <television>", "[SWITCHON] <television>", "[TURNTO] <remote_control>", "[LOOKAT] <remote_control>", "[PUSH] <remote_control>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'tea_bag', 'computer', 'food_bacon', 'tvstand', 'iron', 'window', 'electric_shaver', 'mousepad', 'dining_room', 'wall', 'nightstand', 'wall_clock', 'photoframe', 'towel_rack', 'mouse', 'table']\nTask:Check email\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'microwave', 'freezer', 'cpuscreen', 'hanger', 'floor', 'keyboard', 'purse', 'bookshelf', 'food_bacon', 'button', 'toaster', 'laptop', 'stereo', 'couch', 'wall', 'bench', 'basket_for_clothes', 'toothbrush_holder', 'curtain', 'rag', 'diary', 'cards', 'cupboard', 'controller', 'laundry_detergent', 'soap', 'tooth_paste', 'washing_machine', 'creditcard']\nTask:Wash clothes\nresponse:\n", "output": {"thoughts": "I go to the bedroom to find and grab basket of clothes. I then go to the bathroom and find the washing machine. I put clothes inside the washing machine and put washing powder. I switch on the washing machine.", "actions": ["[WALK] <bedroom>", "[WALK] <basket_for_clothes>", "[FIND] <basket_for_clothes>", "[GRAB] <basket_for_clothes>", "[WALK] <bathroom>", "[WALK] <washing_machine>", "[FIND] <washing_machine>", "[OPEN] <washing_machine>", "[PUTBACK] <basket_for_clothes> <washing_machine>", "[FIND] <soap>", "[GRAB] <soap>", "[PUTBACK] <soap> <washing_machine>", "[FIND] <washing_machine>", "[CLOSE] <washing_machine>", "[SWITCHON] <washing_machine>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'toilet', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'computer', 'tvstand', 'shower', 'closetdrawer', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'powersocket', 'cup', 'bed', 'coffe_maker', 'food_food', 'doorjamb', 'towel_rack', 'pencil', 'headset', 'chessboard', 'dresser', 'hairbrush', 'door', 'clothes_scarf', 'light']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": I go into my room, find the light,  then turn on the lights.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[WALK] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_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']\nTask:Browse internet\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'food_salt', 'toilet', 'detergent', 'cpuscreen', 'food_egg', 'bathroom_counter', 'floor', 'folder', 'desk', 'envelope', 'clothes_jacket', 'mat', 'plate', 'stereo', 'deck_of_cards', 'shower', 'couch', 'television', 'oven_mitts', 'curtain', 'shaving_cream', 'chessboard', 'cupboard', 'conditioner', 'light', 'table', 'soap', 'clothes_shirt']\nTask:Dust\nresponse:\n{\n    \"thoughts\": Get a broom or duster with long handle. Dust blades of ceiling fan.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <duster>', '[FIND] <duster>', '[GRAB] <duster>', '[PUTOBJBACK] <duster>']\n}\n", "input": "\nScene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'stamp', 'keyboard', 'computer', 'bookmark', 'ceilinglamp', 'mat', 'mousepad', 'clothes_pants', 'wall', 'cutting_board', 'food_cheese', 'keys', 'food_food', 'video_game_controller', 'toothbrush_holder', 'mouse', 'pencil', 'door', 'sink', 'table', 'light', 'dirt']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "Go to home office, turn on the computer, open the internet and browse around the internet.", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[SWITCHON] <computer>", "[TURNTO] <computer>", "[LOOKAT] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'pot', 'bathroom', 'knifeblock', 'bathroom_counter', 'shampoo', 'phone', 'mail', 'clothes_jacket', 'stovefan', 'ceilinglamp', 'window', 'clothes_socks', 'couch', 'clothes_pants', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'television', 'mouse', 'shoes', 'chessboard', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher', 'clothes_shirt']\nTask:Get dressed\nresponse:\n{\n    \"thoughts\": Open drawer. Pull out pants and put them on. Take a shirt out and put it on. Put on socks and shoes.,\n    \"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>']\n}\n", "input": "\nScene_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']\nTask:Wash clothes\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'food_ice_cream', 'beer', 'microwave', 'freezer', 'walllamp', 'floor', 'ceiling', 'phone', 'dvd_player', 'stovefan', 'ceilinglamp', 'toaster', 'mousepad', 'wall', 'wall_clock', 'cup', 'bed', 'food_food', 'coin', 'food_rice', 'water', 'pencil', 'shoes', 'controller', 'napkin', 'bathroom_cabinet', 'table', 'dishwasher']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['spectacles', 'sponge', 'measuring_cup', 'walllamp', 'nail_polish', 'drawing', 'orchid', 'floor', 'ceiling', 'dvd_player', 'keyboard', 'computer', 'button', 'toaster', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'broom', 'wall', 'powersocket', 'oven', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'mouse', 'bag', 'table']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "I sit on the sofa. I put my legs on the sofa and recline.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[LIE] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'freezer', 'blow_dryer', 'walllamp', 'drawing', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'ceiling', 'character', 'faucet', 'picture', 'iron', 'mousepad', 'bowl', 'wall', 'powersocket', 'bench', 'photoframe', 'toilet_paper', 'coffe_maker', 'toothbrush_holder', 'tray', 'doorjamb', 'dishrack', 'sink', 'bathroom_cabinet', 'home_office', 'light']\nTask:Get toilet paper\nresponse:\n{\n    \"thoughts\": There are extra toilet papers in the bottom cabinet.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <toilet_paper>', '[GRAB] <toilet_paper>', '[CLOSE] <bathroom_cabinet>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'toilet', 'trashcan', 'dough', 'food_carrot', 'knife', 'drawing', 'clothes_underwear', 'hanger', 'dvd_player', 'character', 'bookmark', 'toaster', 'mat', 'faucet', 'oven', 'tape', 'food_food', 'television', 'coffee_filter', 'ice', 'wooden_spoon', 'tray', 'lighter', 'chessboard', 'spoon', 'home_office', 'table', 'clothes_shirt']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "I hear the phone ringing in the living room. I walk to the living room and go to the phone. I pick it up and answer the phone.", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[TURNTO] <phone>", "[LOOKAT] <phone>", "[GRAB] <phone>", "[SWITCHON] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'bathroom', 'trashcan', 'food_butter', 'drawing', 'floor', 'ceiling', 'phone', 'mat', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'powersocket', 'nightstand', 'food_food', 'check', 'television', 'curtain', 'doorjamb', 'towel_rack', 'kitchen_counter', 'dresser', 'door', 'sink', 'spoon', 'home_office', 'light']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": walk in kitchen. switch on light. walk in living room. switch on light.walk in entrance hall. switch on light.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>', '[WALK] <home_office>']\n}\n", "input": "\nScene_Objects:['freezer', 'bathroom', 'detergent', 'cat', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'mousepad', 'form', 'wall', 'powersocket', 'photoframe', 'food_food', 'check', 'coffee_filter', 'doorjamb', 'cards', 'mouse', 'kitchen_counter', 'controller', 'door', 'light', 'coffee']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"thoughts": "I take the groceries out of the grocery bags, throw away grocery bags, categorize the food so that I know where it goes in the fridge, open the fridge, and place each item in the fridge before closing the fridge.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>", "[GRAB] <food_food>", "[PUTIN] <food_food> <freezer>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": first i will go to living room and then take the remote and swtitch on television after that il change the channel,\n    \"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>']\n}\n", "input": "\nScene_Objects:['spectacles', 'pot', 'filing_cabinet', 'crayon', 'walllamp', 'drawing', 'knifeblock', 'orchid', 'floor', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'window', 'couch', 'food_orange', 'pillow', 'dining_room', 'wall', 'powersocket', 'bench', 'cutting_board', 'curtain', 'cards', 'dresser', 'bag', 'table', 'light', 'colander', 'clothes_shirt']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "Walk to the living room, turn to the sofa. Sit on the sofa and relax.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[TURNTO] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'mousepad', 'couch', 'dining_room', 'wall', 'wall_clock', 'powersocket', 'oven', 'television', 'toothbrush_holder', 'curtain', 'doorjamb', 'console', 'dresser', 'cupboard', 'home_office', 'table', 'clothes_skirt', 'vase']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Watch the television,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[SWITCHON] <television>', '[FIND] <couch>', '[TURNTO] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'walllamp', 'food_butter', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'mousepad', 'wall', 'powersocket', 'photoframe', 'newspaper', 'ice', 'curtain', 'mouse', 'headset', 'hairbrush', 'door', 'bathroom_cabinet', 'table', 'clothes_shirt']\nTask:Write an email\nresponse:\n", "output": {"thoughts": "walk into office, sit in chair, turn on computer, write email", "actions": ["[WALK] <home_office>", "[WALK] <chair>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <computer>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'toilet', 'freezer', 'detergent', 'knifeblock', 'phone', 'bookshelf', 'computer', 'mop_bucket', 'brush', 'clothes_socks', 'mousepad', 'dining_room', 'nightstand', 'basket_for_clothes', 'food_food', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'kitchen_counter', 'dresser', 'laundry_detergent', 'bathtub', 'sink', 'home_office', 'napkin', 'dishwasher', 'bathroom_cabinet', 'washing_machine']\nTask:Wash clothes\nresponse:\n{\n    \"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\",\n    \"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>']\n}\n", "input": "\nScene_Objects:['sheets', 'mop', 'microwave', 'ground_coffee', 'walllamp', 'cat', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'toaster', 'brush', 'tvstand', 'shower', 'faucet', 'food_jam', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'mouthwash', 'coffee_filter', 'curtain', 'doorjamb', 'kitchen_counter', 'cupboard', 'dishwasher', 'scrabble']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Make coffee in the kitchen.", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[PLUGIN] <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>", "[CLOSE] <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'food_pizza', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'bathroom_counter', 'shampoo', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'faucet', 'couch', 'dining_room', 'cup', 'bed', 'tray', 'curtain', 'wooden_spoon', 'pencil', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'table']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": I walk to the home office. I find the telephone. I pick up the telephone handset.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'dog', 'bathroom', 'knifeblock', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'character', 'desk', 'bedroom', 'clothes_jacket', 'mat', 'tvstand', 'pillow', 'towel', 'wall', 'cup', 'food_donut', 'curtain', 'after_shave', 'dishrack', 'cupboard', 'controller', 'door', 'dishwasher']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "Walk to living room. Go near telephone. take the receiver and then talk to other person on that side.", "actions": ["[WALK] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'walllamp', 'bathroom', 'orchid', 'wallshelf', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'tvstand', 'faucet', 'plate', 'mousepad', 'wall', 'powersocket', 'bench', 'oven', 'cutting_board', 'tape', 'cup', 'doorjamb', 'sink', 'light', 'table']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": walk over and pick up the phone,\n    \"actions\": ['[WALK] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'toilet', 'chair', 'freezer', 'walllamp', 'bathroom', 'nail_polish', 'detergent', 'trashcan', 'drawing', 'floor', 'ceiling', 'desk', 'stamp', 'keyboard', 'computer', 'table_cloth', 'stereo', 'mousepad', 'broom', 'wall', 'nightstand', 'powersocket', 'oven', 'television', 'rag', 'mouse', 'headset', 'door', 'shoe_rack']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "I walk to my bedroom.  I locate my stereo and turn it on.  I put on my headphones and sit to listen.", "actions": ["[WALK] <bedroom>", "[WALK] <stereo>", "[FIND] <stereo>", "[WALK] <stereo>", "[SWITCHON] <stereo>", "[FIND] <headset>", "[GRAB] <headset>", "[PUTON] <headset>", "[FIND] <chair>", "[SIT] <chair>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['chair', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'bookshelf', 'keyboard', 'brush', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'stovefan', 'shoe-shine_kit', 'pillow', 'wall', 'powersocket', 'photoframe', 'novel', 'television', 'wooden_spoon', 'curtain', 'doorjamb', 'bathroom_cabinet', 'light']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Walk into the living room. Sit on the couch. Turn on TV.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>']\n}\n", "input": "\nScene_Objects:['microwave', 'toilet', 'band-aids', 'detergent', 'toothbrush', 'drawing', 'needle', 'bathroom_counter', 'floor', 'ceiling', 'purse', 'stovefan', 'mat', 'tvstand', 'faucet', 'brush', 'window', 'oil', 'couch', 'bowl', 'wall', 'powersocket', 'coffee_pot', 'pencil', 'food_steak', 'sink', 'bag', 'bathroom_cabinet', 'tooth_paste', 'teeth']\nTask:Wash teeth\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'walllamp', 'detergent', 'toothbrush', 'drawing', 'cpuscreen', 'food_egg', 'phone', 'character', 'computer', 'piano_bench', 'shoe-shine_kit', 'faucet', 'food_noodles', 'mousepad', 'clothes_hat', 'towel', 'broom', 'cutting_board', 'shelf', 'keys', 'novel', 'food_food', 'check', 'wooden_spoon', 'towel_rack', 'sink', 'table', 'light', 'coffee']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": I pull up my online classes on the computer to look at what the assigned reading is. I get my textbook, notebook, and mechanical pencil. As I'm reading, I take notes over important points. I then use those notes to complete the assignment for the week. Frequently that involves writing a post on an online discussion board that answers a question related to things from the reading.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[GRAB] <remote_control>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'filing_cabinet', 'tablelamp', 'beer', 'bathroom', 'food_butter', 'food_carrot', 'milk', 'bathroom_counter', 'bedroom', 'thread', 'table_cloth', 'bookmark', 'ceilinglamp', 'shower', 'mousepad', 'nightstand', 'powersocket', 'box', 'photoframe', 'razor', 'wine', 'dresser', 'clothes_scarf', 'sink', 'home_office', 'light', 'colander', 'laser_pointer', 'dirt']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Petting the cat", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'freezer', 'trashcan', 'drawing', 'bathroom_counter', 'ceiling', 'phone', 'thread', 'computer', 'stovefan', 'faucet', 'shower', 'food_jam', 'dining_room', 'wall', 'powersocket', 'tape', 'coffe_maker', 'food_food', 'mirror', 'doorjamb', 'mouse', 'paper_towel', 'dresser', 'cupboard', 'sink', 'clothes_scarf', 'bathroom_cabinet', 'home_office', 'dirt']\nTask:Clean  mirror\nresponse:\n{\n    \"thoughts\": Spray Windex or glass and mirror cleaner onto mirror. Use paper towel to wipe off cleaner until mirror is dry and has no streaks.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <bathroom_cabinet>', '[FIND] <bathroom_cabinet>', '[OPEN] <bathroom_cabinet>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[CLOSE] <bathroom_cabinet>', '[WALK] <mirror>', '[WIPE] <mirror>', '[FIND] <trashcan>', '[PUTBACK] <paper_towel> <trashcan>']\n}\n", "input": "\nScene_Objects:['fork', 'pot', 'measuring_cup', 'microwave', 'detergent', 'trashcan', 'orchid', 'bills', 'knife', 'bathroom_counter', 'floor', 'character', 'keyboard', 'mat', 'mousepad', 'nightstand', 'pasta', 'tape', 'novel', 'food_food', 'check', 'television', 'curtain', 'coffee_pot', 'laundry_detergent', 'clothes_scarf', 'bathroom_cabinet', 'colander', 'instrument_violin', 'washing_machine']\nTask:Wash clothes\nresponse:\n", "output": {"thoughts": "Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent.", "actions": ["[WALK] <bedroom>", "[WALK] <clothes_pants>", "[FIND] <clothes_pants>", "[GRAB] <clothes_pants>", "[WALK] <home_office>", "[WALK] <washing_machine>", "[FIND] <washing_machine>", "[OPEN] <washing_machine>", "[PUTBACK] <clothes_pants> <washing_machine>", "[FIND] <laundry_detergent>", "[GRAB] <laundry_detergent>", "[PUTBACK] <laundry_detergent> <washing_machine>", "[CLOSE] <washing_machine>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['chair', 'walllamp', 'woman', 'toothbrush', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'stamp', 'bookshelf', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'stereo', 'closetdrawer', 'couch', 'pillow', 'wall', 'child', 'box', 'photoframe', 'television', 'oven_mitts', 'doorjamb', 'cd', 'dresser', 'table']\nTask:Watch movie\nresponse:\n{\n    \"thoughts\": Sitting and watching  a movie with family,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <child>', '[FIND] <child>', '[TURNTO] <child>', '[LOOKAT] <child>', '[GREET] <child>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[WALK] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[TOUCH] <television>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <television>', '[LOOKAT] <television>', '[WATCH] <television>', '[WATCH] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'blender', 'walllamp', 'cat', 'drawing', 'orchid', 'needle', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'ceilinglamp', 'laptop', 'window', 'couch', 'pillow', 'wall', 'wall_clock', 'bench', 'oven', 'newspaper', 'check', 'tray', 'curtain', 'doorjamb', 'door', 'bathroom_cabinet', 'table', 'tooth_paste', 'coffee']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "I'm tired and want to relax on the sofa", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'walllamp', 'trashcan', 'cpuscreen', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'folder', 'bedroom', 'food_cake', 'computer', 'shower', 'iron', 'window', 'pillow', 'wall', 'nightstand', 'powersocket', 'tape', 'bed', 'television', 'wine', 'doorjamb', 'towel_rack', 'dresser', 'home_office', 'light', 'bathroom_cabinet', 'dishwasher']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": I walk to the kitchen and find the phone. I pick up the phone. I hold it to my ear.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['water_glass', 'filing_cabinet', 'food_salt', 'microwave', 'blow_dryer', 'detergent', 'knife', 'orchid', 'bathroom_counter', 'shampoo', 'keyboard', 'bookshelf', 'mail', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'faucet', 'food_peanut_butter', 'dining_room', 'nightstand', 'oven', 'cup', 'light_bulb', 'food_food', 'television', 'food_onion', 'pencil', 'napkin', 'light']\nTask:Drink\nresponse:\n", "output": {"thoughts": "Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass.", "actions": ["[WALK] <dining_room>", "[WALK] <water_glass>", "[FIND] <water_glass>", "[GRAB] <water_glass>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[POUR] <water> <water_glass>", "[DRINK] <water_glass>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'freezer', 'food_butter', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'mop_bucket', 'ceilinglamp', 'tvstand', 'iron', 'window', 'mousepad', 'microphone', 'towel', 'dining_room', 'bowl', 'wall', 'powersocket', 'bench', 'cup', 'novel', 'television', 'coin', 'rag', 'doorjamb', 'headset', 'light']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": I walk in to the living room. I find the light switch. I turn on the lights.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'juice', 'measuring_cup', 'microwave', 'walllamp', 'trashcan', 'floor', 'bedroom', 'computer', 'toaster', 'stovefan', 'ceilinglamp', 'faucet', 'window', 'mousepad', 'candle', 'pillow', 'wall', 'nightstand', 'bench', 'oven', 'cup', 'newspaper', 'coffe_maker', 'tray', 'kitchen_counter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "Walk to the sink. Take dishes out of sink. Open dishwasher and place dishes in dishwasher.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['water_glass', 'food_bread', 'chair', 'freezer', 'walllamp', 'detergent', 'trashcan', 'drawing', 'desk', 'keyboard', 'bookshelf', 'bookmark', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'pillow', 'bowl', 'wall', 'box', 'coffe_maker', 'razor', 'television', 'curtain', 'doorjamb', 'towel_rack', 'door', 'sink', 'bathroom_cabinet']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Pour water into a glass and drink from the glass.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['freezer', 'ground_coffee', 'bathroom', 'drawing', 'floor', 'ceiling', 'bookshelf', 'mat', 'ceilinglamp', 'stereo', 'mousepad', 'couch', 'clothes_pants', 'dining_room', 'wall', 'powersocket', 'box', 'bed', 'check', 'television', 'wooden_spoon', 'after_shave', 'doorjamb', 'pencil', 'kitchen_counter', 'door', 'food_steak', 'napkin', 'light', 'board_game']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "switching on the light", "actions": ["[WALK] <bedroom>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'envelope', 'computer', 'button', 'food_bacon', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'shoe-shine_kit', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'cup', 'photoframe', 'television', 'doorjamb', 'dresser', 'dirt']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": Pickup remote control for the living room TV and push the change channel button,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'cpuscreen', 'clothes_underwear', 'hanger', 'shampoo', 'bookshelf', 'alcohol', 'table_cloth', 'faucet', 'shower', 'clothes_socks', 'clothes_pants', 'wall', 'wall_clock', 'oven', 'nightstand', 'basket_for_clothes', 'newspaper', 'clothes_gloves', 'tray', 'doorjamb', 'lighter', 'cards', 'clothes_dress', 'laundry_detergent', 'napkin', 'clothes_skirt', 'clothes_shirt', 'washing_machine']\nTask:Wash clothes\nresponse:\n", "output": {"thoughts": "I go to the bathroom, take the dirt clothes and put into the washing machine, then put the soap, set the cleaning program and switch on the machine", "actions": ["[WALK] <bathroom>", "[WALK] <washing_machine>", "[FIND] <washing_machine>", "[OPEN] <washing_machine>", "[FIND] <basket_for_clothes>", "[OPEN] <basket_for_clothes>", "[FIND] <clothes_dress>", "[GRAB] <clothes_dress>", "[PUTBACK] <clothes_dress> <washing_machine>", "[FIND] <clothes_pants>", "[GRAB] <clothes_pants>", "[PUTBACK] <clothes_pants> <washing_machine>", "[FIND] <clothes_shirt>", "[GRAB] <clothes_shirt>", "[PUTBACK] <clothes_shirt> <washing_machine>", "[FIND] <clothes_skirt>", "[GRAB] <clothes_skirt>", "[PUTBACK] <clothes_skirt> <washing_machine>", "[FIND] <clothes_underwear>", "[GRAB] <clothes_underwear>", "[PUTBACK] <clothes_underwear> <washing_machine>", "[FIND] <clothes_socks>", "[GRAB] <clothes_socks>", "[PUTBACK] <clothes_socks> <washing_machine>", "[CLOSE] <basket_for_clothes>", "[WALK] <laundry_detergent>", "[FIND] <laundry_detergent>", "[GRAB] <laundry_detergent>", "[POUR] <laundry_detergent> <washing_machine>", "[CLOSE] <washing_machine>", "[SWITCHON] <washing_machine>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tea', 'cat', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'mail', 'alcohol', 'mat', 'faucet', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'bench', 'coffee_filter', 'ice', 'paper_towel', 'conditioner', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'soap', 'hands_both', 'shoe_rack']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": I walk to the bathroom and find the sink. I grab the soap and rub some on my hands. I turn the faucet on and put my hands in the water. I rinse my hands and then turn off the faucet. Then I dry my hands on a paper towel.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <hands_both>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[WIPE] <hands_both>']\n}\n", "input": "\nScene_Objects:['chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'faucet', 'picture', 'window', 'mousepad', 'oil', 'clothes_hat', 'wall', 'keys', 'food_food', 'coin', 'food_onion', 'mouse', 'cupboard', 'laundry_detergent', 'door', 'table']\nTask:Write an email\nresponse:\n", "output": {"thoughts": "I walk into the home office and walk to the desk. I pull out the chair and sit down. I turn on the computer. After the computer is turned on I click on my email program.  When the program is loaded I write an email.", "actions": ["[WALK] <home_office>", "[WALK] <desk>", "[FIND] <chair>", "[PULL] <chair>", "[SIT] <chair>", "[FIND] <computer>", "[SWITCHON] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'measuring_cup', 'dog', 'freezer', 'walllamp', 'orchid', 'bathroom_counter', 'keyboard', 'bookshelf', 'closetdrawer', 'pillow', 'dining_room', 'powersocket', 'oven', 'newspaper', 'clothes_gloves', 'bed', 'check', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'cd', 'cupboard', 'door', 'napkin', 'home_office', 'bathroom_cabinet', 'dishwasher', 'scrabble']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Read a book,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[PUTOBJBACK] <novel>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'knifeblock', 'floor', 'character', 'desk', 'bedroom', 'keyboard', 'thread', 'toaster', 'plate', 'couch', 'wall', 'light_bulb', 'novel', 'coffe_maker', 'food_rice', 'tray', 'food_onion', 'after_shave', 'curtain', 'kettle', 'kitchen_counter', 'shoes', 'cupboard', 'conditioner', 'door', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "In the kitchen, open up the dishwasher. Take plates from the sink and put them in the dishwasher one by one. Close the dishwasher. Program it. Push start.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'mop', 'chair', 'bathroom', 'food_carrot', 'woman', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'man', 'keyboard', 'mat', 'faucet', 'window', 'foundation', 'nightstand', 'powersocket', 'cup', 'coffe_maker', 'food_food', 'television', 'tray', 'towel_rack', 'cd', 'dresser', 'sink', 'clothes_scarf', 'light']\nTask:Greet guests\nresponse:\n{\n    \"thoughts\": Stand next to the door. When the door opens from the outside, greet the guests.,\n    \"actions\": ['[RUN] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[TURNTO] <woman>', '[LOOKAT] <woman>', '[GREET] <woman>', '[FIND] <man>', '[TURNTO] <man>', '[LOOKAT] <man>', '[GREET] <man>']\n}\n", "input": "\nScene_Objects:['food_ice_cream', 'measuring_cup', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'keyboard', 'mail', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'couch', 'candle', 'pillow', 'bowl', 'wall', 'powersocket', 'television', 'curtain', 'after_shave', 'doorjamb', 'chessboard', 'door', 'food_steak', 'bathroom_cabinet', 'table', 'board_game']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "I walk to the living room. I grab the remote control. I walk to the sofa. I sit down, and press the on button on the remote.", "actions": ["[WALK] <home_office>", "[WALK] <remote_control>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[WALK] <couch>", "[SIT] <couch>", "[TOUCH] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'tea', 'ground_coffee', 'walllamp', 'hanger', 'longboard', 'floor', 'ceiling', 'button', 'toaster', 'faucet', 'mousepad', 'candle', 'wall', 'nightstand', 'powersocket', 'keys', 'novel', 'coffe_maker', 'clothes_gloves', 'coffee_filter', 'water', 'ice', 'tray', 'food_onion', 'cupboard', 'door', 'light', 'dishwasher', 'soap']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['sponge', 'microwave', 'walllamp', 'bathroom', 'toothbrush', 'drawing', 'orchid', 'floor', 'desk', 'computer', 'ceilinglamp', 'mat', 'deck_of_cards', 'stereo', 'window', 'couch', 'food_jam', 'pillow', 'wall', 'light_bulb', 'food_donut', 'tray', 'curtain', 'shoes', 'dishrack', 'sink', 'spoon', 'table', 'dishwasher', 'coffee']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "I walk to the living room. I see the couch.  I sit down on the couch, then lie down and put my feet up.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[LIE] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_salt', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'tea_bag', 'bookshelf', 'food_bacon', 'toaster', 'plate', 'tvstand', 'dish_soap', 'mousepad', 'couch', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'toothbrush_holder', 'ice', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'clothes_dress', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['water_glass', 'pot', 'freezer', 'walllamp', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'oil', 'mousepad', 'food_peanut_butter', 'wall', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']\nTask:Drink\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'tablelamp', 'microwave', 'chair', 'wallshelf', 'hanger', 'floor', 'phone', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'powersocket', 'television', 'coin', 'food_donut', 'ice', 'rag', 'pencil', 'shoes', 'dresser', 'clothes_dress', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'light', 'home_office']\nTask:Hang up jacket\nresponse:\n{\n    \"thoughts\": I put clothes on hangers and hang them in the closet,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <clothes_dress>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[FIND] <hanger>', '[OPEN] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[FIND] <clothes_dress>', '[GRAB] <clothes_dress>', '[WALK] <dresser>', '[PUTIN] <clothes_dress> <dresser>', '[CLOSE] <dresser>']\n}\n", "input": "\nScene_Objects:['glue', 'microwave', 'walllamp', 'ground_coffee', 'trashcan', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'iron', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'television', 'curtain', 'doorjamb', 'coffee_pot', 'kitchen_counter', 'door', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "Go to the sofa and watch TV", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'pot', 'scissors', 'walllamp', 'detergent', 'drawing', 'clothes_underwear', 'floor', 'phone', 'character', 'button', 'toaster', 'plate', 'tvstand', 'dish_soap', 'oil', 'candle', 'wall', 'oven', 'tape', 'box', 'coffe_maker', 'food_food', 'check', 'tray', 'centerpiece', 'controller', 'light', 'dishwasher', 'soap']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": walk into kitchen, find dishwasher, put plates in dishwasher, put soap in dishwasher, turn on dishwasher,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['pot', 'freezer', 'walllamp', 'bathroom', 'drawing', 'floor', 'ceiling', 'bookshelf', 'envelope', 'toaster', 'mat', 'food_orange', 'pillow', 'wall', 'wall_clock', 'powersocket', 'cutting_board', 'bed', 'oven_mitts', 'coin', 'doorjamb', 'lighter', 'pencil', 'kitchen_counter', 'dresser', 'pajamas', 'door', 'home_office', 'light', 'colander']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door.", "actions": ["[WALK] <bedroom>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'juice', 'blow_dryer', 'walllamp', 'detergent', 'floor', 'ceiling', 'bedroom', 'keyboard', 'purse', 'tvstand', 'deck_of_cards', 'clothes_pants', 'dining_room', 'wall', 'nightstand', 'powersocket', 'oven', 'keys', 'tray', 'kettle', 'shoes', 'hair', 'sink', 'home_office', 'table', 'dishwasher', 'soap', 'board_game', 'dirt']\nTask:Hang up car keys\nresponse:\n{\n    \"thoughts\": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']\n}\n", "input": "\nScene_Objects:['sponge', 'dry_pasta', 'beer', 'microwave', 'walllamp', 'bathroom', 'detergent', 'trashcan', 'drawing', 'knifeblock', 'floor', 'phone', 'bedroom', 'food_bacon', 'toaster', 'ceilinglamp', 'window', 'dish_soap', 'candle', 'pillow', 'bowl', 'wall', 'bench', 'newspaper', 'coffe_maker', 'kettle', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "I go to the dishwasher and put dish soap. I close the dishwasher and turn it on.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[PUTBACK] <dish_soap> <dishwasher>", "[GRAB] <dish_soap>", "[PUTBACK] <dish_soap> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'crayon', 'drawing', 'hanger', 'floor', 'character', 'bedroom', 'mat', 'window', 'towel', 'pillow', 'wall', 'nightstand', 'cutting_board', 'cup', 'bed', 'toilet_paper', 'food_donut', 'curtain', 'doorjamb', 'mouse', 'shoes', 'chessboard', 'controller', 'laundry_detergent', 'door', 'table', 'vase']\nTask:Go to sleep\nresponse:\n{\n    \"thoughts\": go t the bedroom and go to sleep,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>']\n}\n", "input": "\nScene_Objects:['glue', 'filing_cabinet', 'food_salt', 'microwave', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'stovefan', 'mat', 'dustpan', 'food_orange', 'wall', 'powersocket', 'oven', 'photoframe', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'pajamas', 'cupboard', 'clothes_dress', 'door', 'light', 'dishwasher', 'table']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "Walk to the Living Room. Switch on 1 light. Walk to dining room. Switch on 1 light. Walk to Entrance hall. Switch on 1 light.", "actions": ["[WALK] <home_office>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>", "[WALK] <dining_room>", "[WALK] <home_office>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['juice', 'toilet', 'chair', 'detergent', 'bathroom_counter', 'ceiling', 'character', 'desk', 'laptop', 'tvstand', 'faucet', 'electric_shaver', 'mousepad', 'couch', 'food_orange', 'bench', 'powersocket', 'cup', 'bed', 'novel', 'razor', 'oven_mitts', 'curtain', 'after_shave', 'cd', 'headset', 'dresser', 'pajamas', 'bathroom_cabinet', 'tooth_paste']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[WALK] <phone>', '[TURNTO] <phone>', '[LOOKAT] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mail', 'stovefan', 'ceilinglamp', 'mat', 'mousepad', 'dustpan', 'wall', 'bed', 'coffe_maker', 'lighter', 'coffee_pot', 'mouse', 'hair', 'door', 'napkin', 'home_office', 'table']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "Go find a computer, turn it on, click google, and browse the internet.", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>", "[TURNTO] <computer>", "[LOOKAT] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'tablelamp', 'walllamp', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'faucet', 'shower', 'towel', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'dresser', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'board_game', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mop_bucket', 'ceilinglamp', 'mat', 'electric_shaver', 'mousepad', 'wall', 'powersocket', 'photoframe', 'food_food', 'coffe_maker', 'mouse', 'pencil', 'controller', 'door', 'table', 'teeth']\nTask:Work\nresponse:\n", "output": {"thoughts": "walk to home office ,find computer ,switch on computer and work", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mail', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'home_office']\nTask:Check email\nresponse:\n{\n    \"thoughts\": Turn on the computer.  Wait for it to load.  Get online.  Go to the email service.  Open the email.  Read the email.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mail>', '[GRAB] <mail>', '[READ] <mail>']\n}\n", "input": "\nScene_Objects:['blender', 'food_ice_cream', 'walllamp', 'bathroom', 'knifeblock', 'cpuscreen', 'character', 'envelope', 'stovefan', 'stereo', 'shower', 'window', 'towel', 'dining_room', 'broom', 'nightstand', 'cup', 'basket_for_clothes', 'check', 'food_rice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'chessboard', 'hairbrush', 'hair', 'dresser', 'light', 'shoe_rack']\nTask:Read book\nresponse:\n", "output": {"thoughts": "Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.", "actions": ["[WALK] <home_office>", "[WALK] <address_book>", "[FIND] <address_book>", "[GRAB] <address_book>", "[READ] <address_book>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'microwave', 'walllamp', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'folder', 'character', 'desk', 'faucet', 'stereo', 'mousepad', 'food_orange', 'wall', 'oven', 'photoframe', 'oven_mitts', 'water', 'drinking_glass', 'wooden_spoon', 'towel_rack', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'spoon', 'board_game']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Go to kitchen, open cabinet, get glass, close cabinet, put glass under faucet, turn on water, turn off water when glass has 85% water, lift glass to mouth, open mouth and put on glass, tilt glass up and swallow water.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[TURNTO] <kitchen_cabinet>', '[LOOKAT] <kitchen_cabinet>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[SWITCHOFF] <faucet>', '[DRINK] <drinking_glass>']\n}\n", "input": "\nScene_Objects:['pot', 'food_ice_cream', 'tea', 'walllamp', 'ground_coffee', 'detergent', 'trashcan', 'milk', 'drawing', 'knifeblock', 'orchid', 'floor', 'phone', 'bookshelf', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'shower', 'window', 'couch', 'dustpan', 'pillow', 'dining_room', 'wall', 'nightstand', 'toy', 'photoframe', 'food_food', 'curtain', 'table']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "I walk into the living room. I bend down. I sit on the sofa.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'shampoo', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'food_food', 'television', 'doorjamb', 'mouse', 'dresser', 'door']\nTask:Work\nresponse:\n{\n    \"thoughts\": I go to my office. I switch the computer on and sit on the office chair. I look at the computer screen to see what needs to be done. I use my mouse to navigate to the relevant directory, then release it. I type code with my keyboard. When I'm done, I look at the computer again to evaluate what I've done. Then I switch off the computer using the mouse and put back the mouse.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[PUTOBJBACK] <mouse>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[GRAB] <mouse>', '[SWITCHOFF] <computer>', '[PUTOBJBACK] <mouse>']\n}\n", "input": "\nScene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'detergent', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'cutting_board', 'bed', 'television', 'curtain', 'doorjamb', 'hairbrush', 'controller', 'door', 'table', 'dishwasher', 'instrument_violin']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "go to the living room. find the remote. sit on the couch. turn on the tv.", "actions": ["[WALK] <home_office>", "[WALK] <remote_control>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[WALK] <couch>", "[SIT] <couch>", "[FIND] <television>", "[SWITCHON] <television>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'mop', 'bathroom', 'knife', 'hanger', 'bathroom_counter', 'ceiling', 'bedroom', 'desk', 'food_cake', 'window', 'electric_shaver', 'microphone', 'food_jam', 'dining_room', 'wall', 'photoframe', 'food_food', 'television', 'curtain', 'mouse', 'kitchen_counter', 'cd', 'chessboard', 'dresser', 'hairbrush', 'clothes_scarf', 'bathroom_cabinet', 'dishwasher', 'instrument_violin']\nTask:Put on coat\nresponse:\n{\n    \"thoughts\": I remove my scarf from a coat peg in the entrance hall.  I wrap the scarf around my neck,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <hanger>', '[TURNTO] <hanger>', '[LOOKAT] <hanger>', '[FIND] <clothes_scarf>', '[GRAB] <clothes_scarf>', '[PUTON] <clothes_scarf>']\n}\n", "input": "\nScene_Objects:['pot', 'measuring_cup', 'microwave', 'chair', 'food_butter', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'desk', 'food_bacon', 'mat', 'tvstand', 'form', 'pillow', 'dining_room', 'wall', 'bench', 'cup', 'light_bulb', 'television', 'kettle', 'kitchen_counter', 'cd', 'cupboard', 'clothes_dress', 'door', 'bathroom_cabinet']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "I walk over to the phone. .I reach my arm out. I open my hand. I place my hand on the phone. I close my fingers around the phone. I pick up the phone.", "actions": ["[WALK] <phone>", "[TOUCH] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'shampoo', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'closetdrawer', 'couch', 'pillow', 'food_kiwi', 'wall', 'nightstand', 'oven', 'photoframe', 'television', 'doorjamb', 'headset', 'dresser', 'bathroom_cabinet', 'soap']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": I find the remote then I push the button to switch it to the tv channel i want to watch,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[POINTAT] <television>', '[PUSH] <remote_control>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'sheets', 'filing_cabinet', 'tablelamp', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'kitchen_cabinet', 'ceiling', 'bookshelf', 'piano_bench', 'plate', 'shower', 'window', 'couch', 'dining_room', 'pasta', 'oven', 'bench', 'television', 'water', 'drinking_glass', 'curtain', 'doorjamb', 'clothes_scarf', 'napkin', 'light', 'dishwasher', 'colander']\nTask:Drink\nresponse:\n", "output": {"thoughts": "You walk to the kitchen and open the kitchen cabinet and grab a drinking glass. You find the water and pour the water into the drinking glass. You drink the water from the glass.", "actions": ["[WALK] <dining_room>", "[WALK] <kitchen_cabinet>", "[FIND] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[FIND] <drinking_glass>", "[GRAB] <drinking_glass>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[POUR] <water> <drinking_glass>", "[DRINK] <drinking_glass>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'freezer', 'bathroom', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bookshelf', 'keyboard', 'computer', 'clothes_jacket', 'table_cloth', 'mat', 'food_kiwi', 'wall', 'powersocket', 'clothes_gloves', 'food_food', 'coffe_maker', 'doorjamb', 'coffee_pot', 'headset', 'door', 'hairdryer', 'light', 'tooth_paste']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": I walk towards to the bedroom, and I open the door of the bedroom, and I switch on the lights inside the bedroom, the switch is beside the door.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'filing_cabinet', 'food_pizza', 'food_salt', 'microwave', 'floor', 'phone', 'ceiling', 'bedroom', 'computer', 'table_cloth', 'stovefan', 'shower', 'stereo', 'couch', 'clothes_pants', 'nightstand', 'oven', 'cup', 'photoframe', 'novel', 'television', 'food_donut', 'ice', 'doorjamb', 'mouse', 'light', 'colander', 'board_game']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "Walk into living room. Turn on radio.", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'chair', 'freezer', 'drawing', 'needle', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'couch', 'dustpan', 'dining_room', 'wall', 'nightstand', 'powersocket', 'food_food', 'toilet_paper', 'doorjamb', 'coffee_pot', 'mouse', 'kettle', 'dresser', 'light']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": walk into living room, walk to light, turn on light switch.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'phone', 'piano_bench', 'toaster', 'mat', 'faucet', 'shower', 'window', 'dining_room', 'wall', 'bench', 'hands_both', 'bed', 'television', 'oven_mitts', 'water', 'curtain', 'paper_towel', 'hairdryer', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'teeth']\nTask:Wash hands\nresponse:\n", "output": {"thoughts": "I walk into the bathroom. I turn on the water. I put soap on my hands. I rinse my hands. I turn off the water. I dry my hands.", "actions": ["[WALK] <bathroom>", "[WALK] <sink>", "[FIND] <water>", "[TURNTO] <water>", "[FIND] <soap>", "[GRAB] <soap>", "[FIND] <hands_both>", "[SCRUB] <hands_both>", "[RINSE] <hands_both>", "[TURNTO] <water>", "[FIND] <paper_towel>", "[GRAB] <paper_towel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'tablelamp', 'tea', 'drawing', 'wallshelf', 'hanger', 'ceiling', 'tea_bag', 'bookshelf', 'stovefan', 'toaster', 'mat', 'faucet', 'floor_lamp', 'mousepad', 'nightstand', 'box', 'bed', 'photoframe', 'novel', 'food_food', 'coffee_filter', 'food_donut', 'wine', 'after_shave', 'curtain', 'doorjamb', 'clothes_dress', 'conditioner', 'sink']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Turn a light on and read a book in the bedroom.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_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']\nTask:Wash hands\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'crayon', 'chair', 'bathroom', 'food_butter', 'phone', 'ceiling', 'bedroom', 'tea_bag', 'laptop', 'ceilinglamp', 'shower', 'iron', 'clothes_socks', 'closetdrawer', 'clothes_pants', 'pillow', 'wall', 'powersocket', 'standingmirror', 'photoframe', 'toothbrush_holder', 'food_donut', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'controller', 'door', 'table']\nTask:Switch on lamp\nresponse:\n{\n    \"thoughts\": Press the button so the light comes on.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']\n}\n", "input": "\nScene_Objects:['tea', 'toilet', 'freezer', 'band-aids', 'knifeblock', 'food_egg', 'shampoo', 'phone', 'bookshelf', 'purse', 'thread', 'deck_of_cards', 'shower', 'picture', 'clothes_socks', 'oven', 'food_cheese', 'novel', 'food_food', 'check', 'coffe_maker', 'tray', 'after_shave', 'curtain', 'doorjamb', 'cupboard', 'controller', 'bag', 'table', 'scrabble']\nTask:Drink\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'pot', 'microwave', 'toilet', 'cat', 'wallshelf', 'bathroom_counter', 'floor', 'dvd_player', 'bookshelf', 'stovefan', 'ceilinglamp', 'toaster', 'mat', 'shower', 'faucet', 'tvstand', 'couch', 'towel', 'wall', 'bench', 'cutting_board', 'bed', 'razor', 'television', 'curtain', 'kitchen_counter', 'dresser', 'home_office', 'light']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Pet Cat,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['sheets', 'filing_cabinet', 'blender', 'beer', 'freezer', 'band-aids', 'walllamp', 'orchid', 'food_egg', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'button', 'ceilinglamp', 'mousepad', 'food_peanut_butter', 'wall', 'powersocket', 'food_food', 'doorjamb', 'mouse', 'door', 'sink', 'napkin', 'light']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"thoughts": "I walk in to the kitchen. I open the fridge. I place the groceries in the fridge. I close the fridge.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>", "[GRAB] <food_food>", "[PUTIN] <food_food> <freezer>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'measuring_cup', 'microwave', 'freezer', 'ceilingfan', 'milk', 'floor', 'ceiling', 'character', 'bedroom', 'computer', 'button', 'toaster', 'faucet', 'picture', 'wall', 'nightstand', 'oven', 'photoframe', 'clothes_gloves', 'coffe_maker', 'food_food', 'curtain', 'centerpiece', 'food_sugar', 'vacuum_cleaner', 'chessboard', 'coffee_cup', 'dishwasher', 'light']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": walk to kitchen, look at the coffee maker, open the coffee maker, find milk, suger and water, mix that all, put into coffee maker, switch on the coffee maker, wait for few mins, push the coffee button in coffee maker, we get coffee in coffee cup, drink coffee,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[TURNTO] <coffe_maker>', '[LOOKAT] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <milk>', '[GRAB] <milk>', '[PUTBACK] <milk> <coffe_maker>', '[FIND] <food_sugar>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <button>', '[PUSH] <button>', '[GRAB] <coffee_cup>', '[DRINK] <coffee_cup>']\n}\n", "input": "\nScene_Objects:['sheets', 'food_bread', 'tablelamp', 'crayon', 'walllamp', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'dvd_player', 'bedroom', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'door', 'bathroom_cabinet', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "You walk to the living room and sit on the sofa. You grab the remote control, look at it and point at the television, you watch television.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[TURNTO] <remote_control>", "[LOOKAT] <remote_control>", "[FIND] <television>", "[TURNTO] <television>", "[POINTAT] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'food_bread', 'food_ice_cream', 'tea', 'walllamp', 'drawing', 'bills', 'knifeblock', 'orchid', 'bathroom_counter', 'floor', 'keyboard', 'bookshelf', 'envelope', 'computer', 'ceilinglamp', 'iron', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'toy', 'television', 'tray', 'curtain', 'sink', 'bathroom_cabinet', 'table']\nTask:Read magazine\nresponse:\n{\n    \"thoughts\": Please sit on the couch and read a magazine,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <newspaper>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[WALK] <couch>', '[SIT] <couch>', '[TURNTO] <newspaper>', '[LOOKAT] <newspaper>', '[READ] <newspaper>', '[READ] <newspaper>', '[READ] <newspaper>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'juice', 'toilet', 'walllamp', 'nail_polish', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'phone', 'desk', 'stovefan', 'plate', 'faucet', 'window', 'mousepad', 'form', 'pillow', 'wall', 'wall_clock', 'oven', 'clothes_gloves', 'tray', 'diary', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'sink']\nTask:Wash dishes by hand\nresponse:\n", "output": {"thoughts": "Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry.", "actions": ["[WALK] <dining_room>", "[WALK] <kitchen_counter>", "[FIND] <plate>", "[TURNTO] <plate>", "[LOOKAT] <plate>", "[GRAB] <plate>", "[SCRUB] <plate>", "[RINSE] <plate>", "[WASH] <plate>", "[PUTBACK] <plate> <kitchen_counter>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['blender', 'band-aids', 'freezer', 'walllamp', 'nail_polish', 'trashcan', 'dough', 'drawing', 'bills', 'cpuscreen', 'bathroom_counter', 'ceiling', 'phone', 'character', 'desk', 'purse', 'alcohol', 'clothes_jacket', 'toaster', 'mat', 'faucet', 'oil', 'couch', 'broom', 'oven', 'photoframe', 'tray', 'kitchen_counter', 'dresser', 'laser_pointer']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Find a cat in the kitchen and touch it,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['microwave', 'chair', 'walllamp', 'food_carrot', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'food_bacon', 'ceilinglamp', 'mat', 'tvstand', 'stereo', 'mousepad', 'couch', 'wall', 'powersocket', 'toy', 'photoframe', 'mouse', 'controller', 'door', 'table', 'light']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "turn on the computer and browse the internet", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Go to toilet\nresponse:\n{\n    \"thoughts\": Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']\n}\n", "input": "\nScene_Objects:['sponge', 'pot', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'beer', 'toilet', 'drawing', 'hanger', 'floor', 'bookshelf', 'envelope', 'tvstand', 'shower', 'faucet', 'candle', 'dining_room', 'broom', 'wall', 'toy', 'cup', 'photoframe', 'clothes_gloves', 'light_bulb', 'wooden_spoon', 'curtain', 'doorjamb', 'chessboard', 'dishrack', 'door']\nTask:Go to toilet\nresponse:\n", "output": {"thoughts": "I walk to the entrance of the bathroom. I turn to the door. I open the door to the bathroom. I walk inside of the bathroom. I find the toilet inside of the bathroom and walk over to it. I turn and look at the toilet.", "actions": ["[WALK] <bathroom>", "[WALK] <toilet>", "[FIND] <toilet>", "[TURNTO] <toilet>", "[LOOKAT] <toilet>", "[WALK] <toilet>", "[TURNTO] <toilet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'tablelamp', 'dog', 'freezer', 'orchid', 'drawing', 'wallshelf', 'ceiling', 'character', 'mail', 'clothes_jacket', 'computer', 'mat', 'faucet', 'window', 'closetdrawer', 'nightstand', 'wall_clock', 'oven', 'basket_for_clothes', 'coffe_maker', 'mouse', 'dresser', 'cupboard', 'laundry_detergent', 'sink', 'bathroom_cabinet', 'light', 'scrabble', 'washing_machine']\nTask:Wash clothes\nresponse:\n{\n    \"thoughts\": Pick up my dirty clothes, load the washer, add detergent, turn on washer,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[RUN] <washing_machine>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'food_bread', 'beer', 'freezer', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_cake', 'alcohol', 'computer', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'mousepad', 'microphone', 'towel', 'wall', 'powersocket', 'food_food', 'television', 'wine', 'doorjamb', 'mouse', 'pencil', 'door', 'light', 'dishwasher']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"thoughts": "Go to kitchen and put groceries in fridge", "actions": ["[WALK] <dining_room>", "[WALK] <food_food>", "[FIND] <food_food>", "[GRAB] <food_food>", "[WALK] <freezer>", "[OPEN] <freezer>", "[PUTIN] <food_food> <freezer>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'walllamp', 'knifeblock', 'drawing', 'cpuscreen', 'clothes_underwear', 'knife', 'floor', 'ceiling', 'cleaning_solution', 'piano_bench', 'toaster', 'ceilinglamp', 'faucet', 'stereo', 'iron', 'wall', 'oven', 'cutting_board', 'tape', 'check', 'coin', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bag', 'home_office', 'instrument_violin', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": Washing hands,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <cleaning_solution>', '[SQUEEZE] <cleaning_solution>', '[SCRUB] <hands_both>', '[SWITCHON] <faucet>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>']\n}\n", "input": "\nScene_Objects:['chair', 'walllamp', 'orchid', 'cpuscreen', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'stereo', 'tvstand', 'mousepad', 'couch', 'broom', 'wall', 'bed', 'check', 'toilet_paper', 'television', 'ice', 'kettle', 'mouse', 'door', 'sink', 'home_office', 'table']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "I go in my office, sit at my desk turn on the computer, then type on my keyboard and open my web browser.", "actions": ["[WALK] <home_office>", "[WALK] <desk>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <computer>", "[SWITCHON] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'juice', 'microwave', 'cat', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'computer', 'clothes_jacket', 'button', 'ceilinglamp', 'mat', 'window', 'couch', 'food_jam', 'wall', 'nightstand', 'cutting_board', 'cup', 'television', 'mouse', 'pencil', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'table', 'vase', 'coffee']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Walk into bedrrom and to the sofa. Sit on the sofa and touch cat.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['toilet', 'chair', 'walllamp', 'food_butter', 'trashcan', 'orchid', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'towel', 'wall', 'pasta', 'bench', 'cup', 'curtain', 'mouse', 'dresser', 'clothes_dress', 'door', 'table', 'tooth_paste']\nTask:Write an email\nresponse:\n", "output": {"thoughts": "enter office, find computer, turn it on,", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>", "[FIND] <keyboard>", "[TOUCH] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['chair', 'orchid', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'computer', 'clothes_jacket', 'table_cloth', 'ceilinglamp', 'shower', 'window', 'homework', 'mousepad', 'pillow', 'powersocket', 'photoframe', 'coffe_maker', 'doorjamb', 'kettle', 'shoes', 'dresser', 'cupboard', 'laundry_detergent', 'clothes_dress', 'door', 'bag', 'light', 'washing_machine']\nTask:Wash clothes\nresponse:\n{\n    \"thoughts\": Go to bedroom and grab dirty pants and take to the washing machine in entrance hall. Put clothes in washing machine and then put in laundry detergent.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <clothes_pants>', '[FIND] <clothes_pants>', '[GRAB] <clothes_pants>', '[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[PUTBACK] <clothes_pants> <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[PUTBACK] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'microwave', 'blow_dryer', 'detergent', 'cat', 'drawing', 'desk', 'thread', 'computer', 'button', 'table_cloth', 'ceilinglamp', 'tvstand', 'mousepad', 'broom', 'nightstand', 'oven', 'powersocket', 'box', 'newspaper', 'coffe_maker', 'tray', 'doorjamb', 'mouse', 'conditioner', 'bag', 'napkin', 'table', 'light', 'soap']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "I walk to my cat, and I pet him", "actions": ["[WALK] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'microwave', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'computer', 'piano_bench', 'mat', 'tvstand', 'ceilinglamp', 'clothes_socks', 'closetdrawer', 'couch', 'pillow', 'towel', 'wall', 'powersocket', 'photoframe', 'television', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Sit on the couch and use the remote control to turn on the TV,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['food_bread', 'toilet', 'jelly', 'walllamp', 'trashcan', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'stereo', 'electric_shaver', 'microphone', 'wall', 'pasta', 'powersocket', 'oven', 'bed', 'television', 'doorjamb', 'mouse', 'hair', 'door', 'table', 'colander', 'instrument_violin']\nTask:Change TV channel\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'bookmark', 'mat', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'photoframe', 'novel', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'comb', 'door', 'light']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Find book, grab book, fin bookmark, sit down somewhere comfortable, open book, read book, close book after reading.,\n    \"actions\": ['[WALK] <desk>', '[FIND] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[FIND] <couch>', '[SIT] <couch>', '[GRAB] <novel>', '[READ] <novel>', '[PUTBACK] <bookmark> <novel>']\n}\n", "input": "\nScene_Objects:['freezer', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'bedroom', 'keyboard', 'food_cake', 'computer', 'button', 'ceilinglamp', 'mousepad', 'wall', 'nightstand', 'powersocket', 'cup', 'food_food', 'check', 'doorjamb', 'lighter', 'mouse', 'shoes', 'dishrack', 'controller', 'door', 'light', 'scrabble']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"thoughts": "put away groceries in fridge. open the door, put on shelf, close the door.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>", "[GRAB] <food_food>", "[PUTIN] <food_food> <freezer>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'food_salt', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'bedroom', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'shower', 'mousepad', 'microphone', 'dining_room', 'nightstand', 'basket_for_clothes', 'bed', 'newspaper', 'coffe_maker', 'check', 'tray', 'curtain', 'doorjamb', 'mouse', 'headset', 'laundry_detergent', 'maindoor', 'bathroom_cabinet', 'washing_machine']\nTask:Wash clothes\nresponse:\n{\n    \"thoughts\": Walk to laundry room. Find laundry basket. Grab laundry basket. Find washing machine. Walk to washing machine. Open washing machine. Find detergent. Grab detergent. Put in detergent. Put in clothes. Close washing machine. Turn on machine.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <basket_for_clothes>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[FIND] <washing_machine>', '[WALK] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[PUTOBJBACK] <laundry_detergent>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'knifeblock', 'bills', 'bathroom_counter', 'ceiling', 'character', 'desk', 'bedroom', 'computer', 'bookmark', 'shoe-shine_kit', 'pillow', 'towel', 'pasta', 'oven', 'powersocket', 'toy', 'cup', 'photoframe', 'light_bulb', 'television', 'kitchen_counter', 'chessboard', 'comb', 'pajamas', 'food_steak', 'sink', 'instrument_violin', 'bag', 'tooth_paste']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "Walk into the home office. Pick up the phone.", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'microwave', 'walllamp', 'knifeblock', 'orchid', 'floor', 'phone', 'ceiling', 'bedroom', 'keyboard', 'food_bacon', 'stovefan', 'toaster', 'plate', 'faucet', 'window', 'homework', 'closetdrawer', 'wall', 'oven', 'ice', 'tray', 'rag', 'doorjamb', 'kitchen_counter', 'cupboard', 'hairdryer', 'sink', 'bathroom_cabinet', 'coffee']\nTask:Wash dishes by hand\nresponse:\n{\n    \"thoughts\": Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[TURNTO] <plate>', '[LOOKAT] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WASH] <plate>', '[PUTBACK] <plate> <kitchen_counter>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[OPEN] <dishwasher>", "[WALK] <kitchen_counter>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[PUTBACK] <dish_soap> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'freezer', 'walllamp', 'blow_dryer', 'milk', 'bills', 'orchid', 'floor', 'ceiling', 'character', 'food_cake', 'alcohol', 'stovefan', 'homework', 'closetdrawer', 'pillow', 'broom', 'wall', 'oven', 'cutting_board', 'cup', 'coffe_maker', 'food_food', 'water', 'tray', 'kitchen_counter', 'shoes', 'sink', 'light', 'table']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['food_ice_cream', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'dvd_player', 'desk', 'keyboard', 'bookshelf', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'iron', 'mousepad', 'oil', 'couch', 'pillow', 'wall', 'powersocket', 'oven', 'video_game_controller', 'television', 'doorjamb', 'kettle', 'mouse', 'door', 'table']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "Walk to home office. Walk to computer. Switch on Computer.", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'pot', 'toilet', 'blow_dryer', 'bathroom', 'trashcan', 'orchid', 'dvd_player', 'keyboard', 'mail', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'picture', 'window', 'couch', 'clothes_pants', 'oven', 'photoframe', 'coffe_maker', 'food_food', 'television', 'food_onion', 'coffee_pot', 'sink', 'bathroom_cabinet', 'light', 'dishwasher', 'vase']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": grab the vesseles and wash,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <bowl>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dining_room>', '[WASH] <bowl>', '[WALK] <detergent>', '[FIND] <detergent>', '[RINSE] <detergent>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'tablelamp', 'microwave', 'walllamp', 'trashcan', 'floor', 'tea_bag', 'thread', 'toaster', 'ceilinglamp', 'plate', 'dish_soap', 'wall', 'bed', 'coffe_maker', 'food_food', 'check', 'oven_mitts', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'hairbrush', 'cupboard', 'hair', 'controller', 'bathroom_cabinet', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['bathroom_counter', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'faucet', 'shower', 'tooth_paste', 'towel', 'wall', 'wall_clock', 'oven', 'tape', 'photoframe', 'clothes_gloves', 'light_bulb', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'sink', 'bathtub', 'bathroom_cabinet', 'table', 'light', 'vase', 'soap', 'home_office', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[TURNTO] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'chair', 'dough', 'bills', 'drawing', 'clothes_underwear', 'floor', 'ceiling', 'shampoo', 'bookshelf', 'computer', 'mat', 'window', 'food_noodles', 'bowl', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'cup', 'bed', 'toilet_paper', 'mouthwash', 'ice', 'doorjamb', 'vacuum_cleaner', 'dishrack', 'door', 'napkin', 'home_office']\nTask:Go to sleep\nresponse:\n", "output": {"thoughts": "Walk to bedroom. Walk to bed, lie in bed.", "actions": ["[WALK] <bedroom>", "[WALK] <bed>", "[LIE] <bed>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'band-aids', 'freezer', 'nail_polish', 'bathroom', 'cat', 'orchid', 'cpuscreen', 'phone', 'character', 'keyboard', 'mat', 'faucet', 'wall', 'oven', 'bed', 'keys', 'coffe_maker', 'mouthwash', 'food_onion', 'curtain', 'centerpiece', 'console', 'towel_rack', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'home_office']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'tea', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'phone', 'keyboard', 'food_cake', 'toaster', 'stovefan', 'plate', 'mat', 'dish_soap', 'oil', 'pillow', 'wall', 'cup', 'photoframe', 'coffe_maker', 'curtain', 'centerpiece', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'bathroom_cabinet', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <cup>", "[GRAB] <cup>", "[PUTBACK] <cup> <dishwasher>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[PUTBACK] <dish_soap> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": go to the bathroom and wash your hands,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[SQUEEZE] <soap>', '[FIND] <hands_both>', '[WASH] <hands_both>']\n}\n", "input": "\nScene_Objects:['sheets', 'sponge', 'tablelamp', 'food_ice_cream', 'crayon', 'measuring_cup', 'toilet', 'knifeblock', 'orchid', 'bathroom_counter', 'dvd_player', 'keyboard', 'computer', 'stovefan', 'mat', 'toaster', 'picture', 'window', 'microphone', 'pillow', 'bench', 'toy', 'novel', 'tray', 'curtain', 'chessboard', 'controller', 'conditioner', 'sink', 'dishwasher']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Walk to living room. Find cat. Walk to cat. Pull cat.", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[WALK] <cat>", "[PULL] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'powersocket', 'photoframe', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'door', 'light', 'table']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Watching TV,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['pot', 'band-aids', 'detergent', 'cat', 'knife', 'bathroom_counter', 'shampoo', 'floor', 'character', 'computer', 'bookmark', 'stovefan', 'mousepad', 'form', 'pillow', 'wall', 'pasta', 'oven', 'cup', 'keys', 'coffe_maker', 'television', 'food_onion', 'curtain', 'centerpiece', 'dishrack', 'sink', 'light', 'clothes_skirt', 'scrabble']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "walk into living room, look at the phone when it ringing, grab the phone or pickup the phone", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[TURNTO] <phone>", "[LOOKAT] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'measuring_cup', 'walllamp', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'face', 'computer', 'bookmark', 'mat', 'faucet', 'mousepad', 'clothes_hat', 'towel', 'dining_room', 'wall', 'wall_clock', 'nightstand', 'face_soap', 'basket_for_clothes', 'newspaper', 'tray', 'rag', 'mouse', 'dishrack', 'sink', 'bathroom_cabinet']\nTask:Wash face\nresponse:\n{\n    \"thoughts\": Turn on water faucet. Get rag wet. Get face soap out. Squirt face soap in hands and put it on face. Rub soap into face. Wash soap off of face. Dry face off on the hand towel. Hang out rag and hand towel.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <rag>', '[GRAB] <rag>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[WASH] <rag>', '[FIND] <face_soap>', '[GRAB] <face_soap>', '[POUR] <face_soap> <rag>', '[PUTOBJBACK] <face_soap>', '[FIND] <face>', '[SCRUB] <face>', '[PUTBACK] <rag> <sink>', '[RINSE] <face>', '[RINSE] <rag>', '[SWITCHOFF] <faucet>', '[GRAB] <rag>', '[PUTOBJBACK] <rag>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <face>', '[PUTOBJBACK] <towel>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'chair', 'walllamp', 'ground_coffee', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'stovefan', 'mousepad', 'oil', 'wall', 'bed', 'mouse', 'cupboard', 'door', 'hairdryer', 'table']\nTask:Work\nresponse:\n", "output": {"thoughts": "Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>", "[FIND] <mouse>", "[PUSH] <mouse>", "[SWITCHOFF] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'food_pizza', 'filing_cabinet', 'beer', 'measuring_cup', 'chair', 'ground_coffee', 'knifeblock', 'longboard', 'floor', 'ceiling', 'bedroom', 'keyboard', 'computer', 'mail', 'toaster', 'picture', 'dustpan', 'wall', 'bench', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'coffee_filter', 'water', 'after_shave', 'dresser', 'maindoor', 'dishwasher']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[GRAB] <ground_coffee>', '[PUTOBJBACK] <ground_coffee>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']\n}\n", "input": "\nScene_Objects:['toilet', 'freezer', 'walllamp', 'cat', 'drawing', 'orchid', 'knifeblock', 'knife', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'ceilinglamp', 'tvstand', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'oven', 'photoframe', 'coffe_maker', 'check', 'curtain', 'lighter', 'dresser', 'napkin', 'home_office', 'table', 'coffee']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Walk into bedrrom and to the sofa. Sit on the sofa and touch cat.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[SIT] <couch>", "[FIND] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'crayon', 'walllamp', 'woman', 'knifeblock', 'hanger', 'ceiling', 'folder', 'character', 'man', 'mop_bucket', 'bookmark', 'shower', 'window', 'electric_shaver', 'pillow', 'dining_room', 'wall_clock', 'cutting_board', 'bed', 'television', 'wine', 'curtain', 'mouse', 'pencil', 'sink', 'home_office', 'light', 'dirt', 'shoe_rack']\nTask:Greet people\nresponse:\n{\n    \"thoughts\": Say HI to those that come in.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <woman>', '[FIND] <woman>', '[GREET] <woman>', '[FIND] <woman>', '[GREET] <woman>', '[FIND] <man>', '[GREET] <man>', '[FIND] <man>', '[GREET] <man>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'beer', 'chair', 'freezer', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mousepad', 'food_jam', 'wall', 'nightstand', 'powersocket', 'bed', 'novel', 'food_onion', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'dresser', 'door', 'table', 'light', 'dishwasher']\nTask:Work\nresponse:\n", "output": {"thoughts": "I walk to the bedroom, then find the computer and sit in the chair ,next switch on the computer and finally type in the keyboard to start to work on it", "actions": ["[WALK] <bedroom>", "[WALK] <computer>", "[FIND] <computer>", "[FIND] <chair>", "[SIT] <chair>", "[SWITCHON] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'chair', 'nail_polish', 'knife', 'cpuscreen', 'floor', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'mat', 'mousepad', 'closetdrawer', 'couch', 'dining_room', 'wall', 'basket_for_clothes', 'cup', 'check', 'television', 'curtain', 'mouse', 'chessboard', 'shoes', 'comb', 'cupboard', 'hairdryer', 'door', 'home_office']\nTask:Read book\nresponse:\n{\n    \"thoughts\": find a book to read. sit down. read the book.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['microwave', 'toilet', 'ground_coffee', 'walllamp', 'trashcan', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'dvd_player', 'toaster', 'shoe-shine_kit', 'faucet', 'clothes_pants', 'dining_room', 'wall', 'photoframe', 'clothes_gloves', 'coffe_maker', 'coffee_filter', 'centerpiece', 'kitchen_counter', 'cd', 'cupboard', 'controller', 'clothes_scarf', 'home_office', 'table', 'dishwasher']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Open the coffee maker and put a filer, grab ground coffee and put it in the coffee maker, then close the coffee maker and switch it on", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[OPEN] <coffe_maker>", "[FIND] <coffee_filter>", "[GRAB] <coffee_filter>", "[PUTBACK] <coffee_filter> <coffe_maker>", "[FIND] <ground_coffee>", "[GRAB] <ground_coffee>", "[FIND] <ground_coffee>", "[PUTBACK] <ground_coffee> <coffe_maker>", "[CLOSE] <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'pot', 'fork', 'beer', 'walllamp', 'bathroom', 'orchid', 'kitchen_cabinet', 'floor', 'phone', 'toaster', 'mat', 'plate', 'tvstand', 'window', 'dish_soap', 'couch', 'bowl', 'wall', 'oven', 'bench', 'coffe_maker', 'tray', 'rag', 'console', 'kitchen_counter', 'dishrack', 'hair', 'maindoor', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": I went to the kitchen and collected the dishes and put them into the dish washer and wiped them with towel and put back into cabinet..,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>', '[GRAB] <plate>', '[WIPE] <plate>', '[FIND] <dishrack>', '[GRAB] <dishrack>', '[PUTOBJBACK] <dishrack>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'measuring_cup', 'dog', 'freezer', 'walllamp', 'trashcan', 'drawing', 'bills', 'floor', 'ceiling', 'bookshelf', 'computer', 'button', 'tvstand', 'stereo', 'wall', 'nightstand', 'bench', 'bed', 'photoframe', 'television', 'razor', 'food_rice', 'wine', 'tray', 'comb', 'sink', 'bathroom_cabinet', 'light', 'dirt']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "I go into my bedroom and see my stereo. I decide to play music. I walk over to the stereo and turn it on. I sit down on the bed to listen to the music.", "actions": ["[WALK] <bedroom>", "[WALK] <stereo>", "[FIND] <stereo>", "[TURNTO] <stereo>", "[LOOKAT] <stereo>", "[SWITCHON] <stereo>", "[FIND] <bed>", "[SIT] <bed>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": Walk into living room, look for radio, grab on button,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <stereo>', '[FIND] <stereo>', '[TURNTO] <stereo>', '[LOOKAT] <stereo>', '[FIND] <button>', '[GRAB] <button>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'juice', 'microwave', 'chair', 'ground_coffee', 'walllamp', 'detergent', 'trashcan', 'drawing', 'knife', 'floor', 'ceiling', 'thread', 'toaster', 'dustpan', 'wall', 'powersocket', 'box', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'kitchen_counter', 'chessboard', 'cupboard', 'spoon', 'light', 'dishwasher']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Walk to kitchen. Find coffee maker. Find coffee filter. Put it in the coffee maker. Find ground coffee. Put it in the coffee maker. Find Water. Put it in the coffe maker. Switch on the coffee maker.", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[FIND] <coffee_filter>", "[GRAB] <coffee_filter>", "[OPEN] <coffe_maker>", "[PUTBACK] <coffee_filter> <coffe_maker>", "[FIND] <ground_coffee>", "[GRAB] <ground_coffee>", "[PUTBACK] <ground_coffee> <coffe_maker>", "[FIND] <water>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'food_ice_cream', 'bathroom', 'detergent', 'cat', 'food_butter', 'toothbrush', 'orchid', 'cpuscreen', 'desk', 'bedroom', 'purse', 'envelope', 'mail', 'mop_bucket', 'toaster', 'shower', 'faucet', 'oil', 'food_orange', 'powersocket', 'cutting_board', 'shelf', 'curtain', 'after_shave', 'diary', 'kitchen_counter', 'door', 'napkin', 'tooth_paste']\nTask:Wash teeth\nresponse:\n{\n    \"thoughts\": before going to bed or when wake up earily morning brush teeth,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <tooth_paste>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>']\n}\n", "input": "\nScene_Objects:['pot', 'scissors', 'toilet', 'chair', 'freezer', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'drawing', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'button', 'ceilinglamp', 'mat', 'foundation', 'mousepad', 'clothes_pants', 'wall', 'photoframe', 'television', 'mouse', 'kitchen_counter', 'headset', 'door', 'home_office', 'table']\nTask:Work\nresponse:\n", "output": {"thoughts": "Go to home office and work on computer.", "actions": ["[RUN] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <mouse>", "[GRAB] <mouse>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[FIND] <keyboard>", "[GRAB] <keyboard>", "[TYPE] <keyboard>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[TOUCH] <mouse>", "[TYPE] <keyboard>", "[TURNTO] <computer>", "[LOOKAT] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['scissors', 'microwave', 'toilet', 'walllamp', 'drawing', 'bills', 'wallshelf', 'floor', 'ceiling', 'character', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'bench', 'television', 'tray', 'curtain', 'towel_rack', 'pencil', 'kitchen_counter', 'bathtub', 'spoon', 'table']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Walk to the room, in which the TV is located. Turn on TV pressing the power button for the TV. Watch TV.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'microwave', 'toilet', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'shower', 'window', 'homework', 'couch', 'candle', 'pillow', 'wall', 'nightstand', 'powersocket', 'check', 'television', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'table', 'light']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "Walk into the living room. Sit down on the sofa. Pick up the remote control. Turn on the television with the remote control. Put down the remote control. Watch the television.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[SIT] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>", "[PUTOBJBACK] <remote_control>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['juice', 'walllamp', 'nail_polish', 'detergent', 'dough', 'drawing', 'food_egg', 'tea_bag', 'bookshelf', 'remote_control', 'alcohol', 'button', 'mop_bucket', 'table_cloth', 'stovefan', 'tvstand', 'shoe-shine_kit', 'shower', 'stereo', 'deck_of_cards', 'mousepad', 'powersocket', 'check', 'rag', 'towel_rack', 'pencil', 'conditioner', 'door', 'bathroom_cabinet', 'soap']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": Take the Tv Remote Control  in the Living Room table And Press the Channel Change Button to change the channel,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>', '[PUTOBJBACK] <remote_control>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'beer', 'walllamp', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'purse', 'food_bacon', 'piano_bench', 'toaster', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'window', 'foundation', 'couch', 'pillow', 'wall', 'bench', 'check', 'wine', 'curtain', 'hairbrush', 'controller', 'door', 'bathroom_cabinet', 'table', 'creditcard']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'toilet', 'chair', 'walllamp', 'ground_coffee', 'dough', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'mousepad', 'closetdrawer', 'oil', 'wall', 'powersocket', 'shelf', 'toilet_paper', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'light', 'table', 'vase']\nTask:Vacuum\nresponse:\n{\n    \"thoughts\": Keep my keyboard vacuumed and free of debris.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <vacuum_cleaner>', '[SWITCHON] <vacuum_cleaner>', '[SWITCHOFF] <vacuum_cleaner>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'scissors', 'chair', 'hanger', 'phone', 'keyboard', 'bookshelf', 'plate', 'faucet', 'window', 'mousepad', 'food_noodles', 'oil', 'food_peanut_butter', 'clothes_pants', 'dining_room', 'bench', 'oven', 'cutting_board', 'toy', 'basket_for_clothes', 'cup', 'photoframe', 'keys', 'food_food', 'laundry_detergent', 'bathroom_cabinet', 'instrument_violin', 'clothes_shirt', 'washing_machine']\nTask:Wash clothes\nresponse:\n", "output": {"thoughts": "Walk to bathroom, open wash-machine, lift laundry basket, grab cloth and put into wash-machine one by one, put down laundry basket, pour detergent, close wash-machine, turn on wash-machine.", "actions": ["[WALK] <bathroom>", "[WALK] <washing_machine>", "[FIND] <washing_machine>", "[OPEN] <washing_machine>", "[FIND] <basket_for_clothes>", "[GRAB] <basket_for_clothes>", "[FIND] <clothes_pants>", "[GRAB] <clothes_pants>", "[PUTBACK] <clothes_pants> <washing_machine>", "[FIND] <clothes_shirt>", "[GRAB] <clothes_shirt>", "[PUTBACK] <clothes_shirt> <washing_machine>", "[PUTOBJBACK] <basket_for_clothes>", "[WALK] <laundry_detergent>", "[FIND] <laundry_detergent>", "[GRAB] <laundry_detergent>", "[POUR] <laundry_detergent> <washing_machine>", "[CLOSE] <washing_machine>", "[SWITCHON] <washing_machine>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'walllamp', 'nail_polish', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'computer', 'mat', 'tvstand', 'couch', 'microphone', 'pillow', 'wall', 'pasta', 'cup', 'photoframe', 'bed', 'novel', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'towel_rack', 'pencil', 'kitchen_counter', 'home_office']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['fork', 'tablelamp', 'crayon', 'drawing', 'needle', 'bills', 'knifeblock', 'floor', 'phone', 'ceiling', 'character', 'mat', 'plate', 'homework', 'pillow', 'bowl', 'bench', 'newspaper', 'novel', 'food_food', 'video_game_controller', 'television', 'oven_mitts', 'food_rice', 'coffee_pot', 'shoes', 'cd', 'home_office', 'table', 'teeth']\nTask:Set up table\nresponse:\n", "output": {"thoughts": "I walk to the table. I put down the dish. I put down the silverware. I put down the napkin.", "actions": ["[WALK] <table>", "[FIND] <fork>", "[GRAB] <fork>", "[PUTBACK] <fork> <table>", "[FIND] <fork>", "[GRAB] <fork>", "[PUTBACK] <fork> <table>", "[FIND] <fork>", "[GRAB] <fork>", "[PUTBACK] <fork> <table>", "[FIND] <fork>", "[GRAB] <fork>", "[PUTBACK] <fork> <table>", "[FIND] <fork>", "[GRAB] <fork>", "[PUTBACK] <fork> <table>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <table>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <table>", "[GRAB] <plate>", "[PUTBACK] <plate> <table>", "[GRAB] <plate>", "[PUTBACK] <plate> <table>", "[GRAB] <plate>", "[PUTBACK] <plate> <table>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'toaster', 'stovefan', 'plate', 'faucet', 'iron', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'food_food', 'wooden_spoon', 'tray', 'kitchen_counter', 'dishrack', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": I walk into the kitchen and go to the dishwasher. I open the dishwasher and grab the dishes. Iplace the dishes into the dishwasher then close it. I add soap then turn the dishwasher on.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'measuring_cup', 'microwave', 'walllamp', 'food_carrot', 'orchid', 'knifeblock', 'cpuscreen', 'drawing', 'floor', 'bedroom', 'cleaning_solution', 'computer', 'mop_bucket', 'table_cloth', 'stovefan', 'shower', 'iron', 'couch', 'bowl', 'dining_room', 'nightstand', 'cup', 'keys', 'curtain', 'doorjamb', 'comb', 'dresser', 'sink', 'hands_both']\nTask:Wash hands\nresponse:\n", "output": {"thoughts": "walk to bathroom , find cleaning solution , squeeze cleaning solution , wash hands", "actions": ["[WALK] <bathroom>", "[WALK] <cleaning_solution>", "[FIND] <cleaning_solution>", "[SQUEEZE] <cleaning_solution>", "[FIND] <hands_both>", "[WASH] <hands_both>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'juice', 'chair', 'jelly', 'nail_polish', 'cat', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'faucet', 'shower', 'iron', 'clothes_pants', 'food_kiwi', 'wall', 'photoframe', 'food_food', 'water', 'wooden_spoon', 'curtain', 'doorjamb', 'sink', 'bathroom_cabinet', 'teeth']\nTask:Wash teeth\nresponse:\n{\n    \"thoughts\": Wash the teeth,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[TURNTO] <water>', '[POINTAT] <water>', '[FIND] <teeth>', '[WASH] <teeth>', '[SWITCHOFF] <faucet>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'walllamp', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'towel', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'pencil', 'door', 'home_office', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "Walk to living room. Sit on the sofa. Grab the remote control and plug in TV.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[PLUGIN] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'freezer', 'ground_coffee', 'bathroom', 'ceilingfan', 'drawing', 'clothes_underwear', 'floor', 'food_cake', 'toaster', 'mousepad', 'dining_room', 'oven', 'tape', 'box', 'photoframe', 'coin', 'curtain', 'shaving_cream', 'coffee_pot', 'headset', 'dishrack', 'cupboard', 'sink', 'clothes_scarf', 'home_office', 'dishwasher', 'soap', 'board_game', 'washing_machine']\nTask:Wash clothes\nresponse:\n{\n    \"thoughts\": Walk to bathroom. Open washer. Put clothes in washer. Put soap in washer. Close washer. Turn washer on.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[OPEN] <washing_machine>', '[FIND] <clothes_underwear>', '[GRAB] <clothes_underwear>', '[PUTBACK] <clothes_underwear> <washing_machine>', '[FIND] <soap>', '[GRAB] <soap>', '[PUTBACK] <soap> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']\n}\n", "input": "\nScene_Objects:['pot', 'scissors', 'food_salt', 'freezer', 'walllamp', 'bathroom', 'detergent', 'knifeblock', 'desk', 'bedroom', 'bookshelf', 'keyboard', 'clothes_jacket', 'toaster', 'stereo', 'electric_shaver', 'food_noodles', 'dining_room', 'broom', 'wall', 'oven', 'box', 'cup', 'curtain', 'shoes', 'vacuum_cleaner', 'sink', 'bag', 'dishwasher', 'creditcard']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "Walk to home office 1. Walk over to phone 1 on table 1.  Grab phone 1.  lift phone 1.", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['chair', 'drawing', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'tvstand', 'shower', 'closetdrawer', 'wall', 'wall_clock', 'oven', 'cup', 'standingmirror', 'check', 'television', 'centerpiece', 'console', 'mouse', 'vacuum_cleaner', 'shoes', 'comb', 'dresser', 'hairbrush', 'sink', 'bag', 'napkin', 'bathroom_cabinet', 'vase']\nTask:vacuum carpet\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'scissors', 'tea', 'freezer', 'blow_dryer', 'drawing', 'knifeblock', 'cpuscreen', 'clothes_underwear', 'character', 'desk', 'toaster', 'shower', 'picture', 'mousepad', 'candle', 'dining_room', 'bench', 'oven', 'basket_for_clothes', 'bed', 'check', 'television', 'toothbrush_holder', 'curtain', 'mouse', 'sink', 'light', 'tooth_paste', 'laser_pointer']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "I walk into the living room and then I walk to the light switch in there and turn the lights on", "actions": ["[WALK] <home_office>", "[WALK] <floor_lamp>", "[SWITCHON] <floor_lamp>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Watch TV\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['band-aids', 'walllamp', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'mail', 'bookmark', 'plate', 'faucet', 'picture', 'dish_soap', 'dustpan', 'wall', 'oven', 'bench', 'bed', 'food_food', 'curtain', 'doorjamb', 'kettle', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'cupboard', 'door', 'sink', 'dirt']\nTask:Wash dishes by hand\nresponse:\n", "output": {"thoughts": "i go to the kitchen, i find the faucet. I turn the faucet on, i grab the plate to wash , i then get the soap. I wash the dishes by hand", "actions": ["[WALK] <dining_room>", "[WALK] <faucet>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[FIND] <plate>", "[GRAB] <plate>", "[WASH] <plate>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'envelope', 'computer', 'bookmark', 'ceilinglamp', 'balanceball', 'mousepad', 'wall', 'nightstand', 'photoframe', 'check', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light']\nTask:Work\nresponse:\n{\n    \"thoughts\": I go to the home office to work on my project. I turn on the light and walk to my desk. I turn on the computer. Then I look through the documents. After I'm done, I turn off the computer.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <check>', '[TURNTO] <check>', '[LOOKAT] <check>', '[SWITCHOFF] <computer>']\n}\n", "input": "\nScene_Objects:['toilet', 'blow_dryer', 'bathroom', 'walllamp', 'orchid', 'cpuscreen', 'dvd_player', 'character', 'desk', 'stamp', 'envelope', 'stovefan', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'homework', 'food_orange', 'dining_room', 'oven', 'bench', 'box', 'video_game_controller', 'television', 'food_donut', 'curtain', 'doorjamb', 'pajamas', 'napkin', 'light', 'clothes_shirt']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "I enter the room where the cat is. I look for the cat. I find the cat. I walk over to the cat. I use my hand to pet the cat.", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[TURNTO] <cat>", "[LOOKAT] <cat>", "[FIND] <cat>", "[WALK] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'chair', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'character', 'bedroom', 'toaster', 'ceilinglamp', 'mat', 'mousepad', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'food_food', 'coffe_maker', 'doorjamb', 'pencil', 'kitchen_counter', 'cd', 'shoes', 'hair', 'clothes_dress', 'table']\nTask:Set up table\nresponse:\n{\n    \"thoughts\": Get dishes. Place dishes neatly around table. Get food. Place food on middle of table.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['sponge', 'microwave', 'toilet', 'walllamp', 'trashcan', 'bathroom_counter', 'floor', 'phone', 'character', 'piano_bench', 'bookmark', 'toaster', 'mat', 'shower', 'dish_soap', 'couch', 'wall', 'photoframe', 'novel', 'coffe_maker', 'check', 'cards', 'kitchen_counter', 'dresser', 'cupboard', 'controller', 'sink', 'home_office', 'bathroom_cabinet', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "walk to kitchen, find the dishwasher, apply dish soap into vessels or dishwasher, wash the dishes with a dishwasher", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[OPEN] <dishwasher>", "[PUTBACK] <dish_soap> <dishwasher>", "[WASH] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'microwave', 'freezer', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'keyboard', 'computer', 'toaster', 'tvstand', 'floor_lamp', 'window', 'closetdrawer', 'couch', 'towel', 'wall', 'wall_clock', 'food_food', 'doorjamb', 'mouse', 'headset', 'shoes', 'dresser', 'controller', 'bathtub', 'sink', 'home_office', 'light']\nTask:Turn night light on\nresponse:\n{\n    \"thoughts\": I walk to the dresser and in the middle Io to small battery operated lamp and switch it on,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <floor_lamp>', '[TURNTO] <floor_lamp>', '[SWITCHON] <floor_lamp>']\n}\n", "input": "\nScene_Objects:['sheets', 'tablelamp', 'microwave', 'chair', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'bookshelf', 'mat', 'laptop', 'faucet', 'wall', 'box', 'photoframe', 'coffe_maker', 'colander', 'curtain', 'pencil', 'headset', 'dishrack', 'pajamas', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'clothes_shirt', 'hands_both']\nTask:Wash hands\nresponse:\n", "output": {"thoughts": "I walk in to the bathroom. I find the soap. I find the faucet. I turn on the faucet. I wash my hands. I put the soap back. I rinse my hands. I turn the faucet off.", "actions": ["[WALK] <bathroom>", "[WALK] <faucet>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <soap>", "[GRAB] <soap>", "[FIND] <hands_both>", "[WASH] <hands_both>", "[PUTOBJBACK] <soap>", "[RINSE] <hands_both>", "[SWITCHOFF] <faucet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'filing_cabinet', 'crayon', 'walllamp', 'bathroom', 'toothbrush', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'faucet', 'electric_shaver', 'dish_soap', 'broom', 'wall', 'oven', 'bench', 'photoframe', 'light_bulb', 'novel', 'coffe_maker', 'television', 'tray', 'towel_rack', 'kettle', 'dishrack', 'table', 'dishwasher', 'tooth_paste']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['blender', 'walllamp', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'thread', 'bookshelf', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'clothes_socks', 'wall', 'pasta', 'powersocket', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'television', 'rag', 'doorjamb', 'shoes', 'door', 'table', 'dishwasher']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "turn on the tv", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[SWITCHON] <television>", "[FIND] <remote_control>", "[TOUCH] <remote_control>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'chair', 'walllamp', 'ground_coffee', 'nail_polish', 'orchid', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'toaster', 'ceilinglamp', 'mat', 'faucet', 'stovefan', 'mousepad', 'oil', 'wall', 'bed', 'mouse', 'cupboard', 'door', 'hairdryer', 'table']\nTask:Work\nresponse:\n{\n    \"thoughts\": Go to office, find computer, switch on computer, type on keyboard, use mouse, switch off computer,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[PUSH] <mouse>', '[SWITCHOFF] <computer>']\n}\n", "input": "\nScene_Objects:['crayon', 'toilet', 'chair', 'bathroom', 'detergent', 'dough', 'knife', 'drawing', 'floor', 'ceiling', 'tea_bag', 'ceilinglamp', 'tvstand', 'shower', 'plate', 'mousepad', 'clothes_socks', 'pillow', 'wall', 'cup', 'doorjamb', 'console', 'shoes', 'dresser', 'door', 'hairdryer', 'napkin', 'light', 'soap', 'laser_pointer']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "Walk over to light switch. Turn on lights.", "actions": ["[WALK] <light>", "[SWITCHON] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['water_glass', 'food_bread', 'bathroom', 'trashcan', 'food_carrot', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'phone', 'folder', 'bedroom', 'desk', 'keyboard', 'toaster', 'bench', 'tray', 'doorjamb', 'diary', 'console', 'mouse', 'towel_rack', 'cd', 'dresser', 'cupboard', 'controller', 'conditioner', 'table', 'vase']\nTask:Drink\nresponse:\n{\n    \"thoughts\": walk to kitchen, walk to table, grab water glass and drink water,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <table>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>', '[PUTBACK] <water_glass> <table>']\n}\n", "input": "\nScene_Objects:['spectacles', 'blender', 'freezer', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'bedroom', 'keyboard', 'computer', 'ceilinglamp', 'homework', 'mousepad', 'dining_room', 'food_kiwi', 'wall', 'powersocket', 'bench', 'oven', 'bed', 'food_food', 'doorjamb', 'mouse', 'controller', 'door', 'bathroom_cabinet', 'light', 'soap', 'clothes_shirt']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"thoughts": "Go to kitchen, open fridge, get groceries, put groceries in fridge, close fridge", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>", "[GRAB] <food_food>", "[PUTIN] <food_food> <freezer>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_salt', 'microwave', 'trashcan', 'drawing', 'floor', 'dvd_player', 'desk', 'envelope', 'ceilinglamp', 'tvstand', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'nightstand', 'cup', 'check', 'television', 'coin', 'colander', 'after_shave', 'cd', 'cupboard', 'table', 'vase', 'soap']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": Go to the living room. Find the sofa. Sit on the sofa. Close your eyes. Breath calmly. Relax,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['pot', 'crayon', 'chair', 'walllamp', 'detergent', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'pillow', 'wall', 'powersocket', 'newspaper', 'television', 'tray', 'doorjamb', 'mouse', 'pencil', 'door', 'light', 'table']\nTask:Write an email\nresponse:\n", "output": {"thoughts": "I walk into my office and go to the computer desk. I sit at my desk and turn the computer on. Then I write an email.", "actions": ["[WALK] <home_office>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>", "[WALK] <desk>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <computer>", "[SWITCHON] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'walllamp', 'detergent', 'cat', 'milk', 'phone', 'ceiling', 'desk', 'mop_bucket', 'brush', 'ceilinglamp', 'tvstand', 'faucet', 'toaster', 'mat', 'closetdrawer', 'microphone', 'nightstand', 'wall_clock', 'toy', 'cup', 'food_food', 'after_shave', 'lighter', 'towel_rack', 'mouse', 'pajamas', 'controller', 'laundry_detergent', 'soap']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Go to the living room where the cat sleeps. Find cat. Proceed to petting cat.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['fork', 'water_glass', 'pot', 'measuring_cup', 'microwave', 'walllamp', 'blow_dryer', 'trashcan', 'knife', 'knifeblock', 'floor', 'ceiling', 'toaster', 'stovefan', 'plate', 'ceilinglamp', 'dish_soap', 'wall', 'oven', 'cup', 'bed', 'coffe_maker', 'tray', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'spoon', 'coffee_cup', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "I go to the kitchen and put plates, cutlery and glasses into the dishwasher, put the soap, close the machine and switch it on.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[FIND] <coffee_cup>", "[GRAB] <coffee_cup>", "[PUTBACK] <coffee_cup> <dishwasher>", "[FIND] <coffee_cup>", "[GRAB] <coffee_cup>", "[PUTBACK] <coffee_cup> <dishwasher>", "[FIND] <pot>", "[GRAB] <pot>", "[PUTBACK] <pot> <dishwasher>", "[FIND] <pot>", "[GRAB] <pot>", "[PUTBACK] <pot> <dishwasher>", "[FIND] <fork>", "[GRAB] <fork>", "[PUTBACK] <fork> <dishwasher>", "[FIND] <fork>", "[GRAB] <fork>", "[PUTBACK] <fork> <dishwasher>", "[FIND] <knife>", "[GRAB] <knife>", "[PUTBACK] <knife> <dishwasher>", "[FIND] <knife>", "[GRAB] <knife>", "[PUTBACK] <knife> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <spoon>", "[GRAB] <spoon>", "[PUTBACK] <spoon> <dishwasher>", "[FIND] <spoon>", "[GRAB] <spoon>", "[PUTBACK] <spoon> <dishwasher>", "[FIND] <water_glass>", "[GRAB] <water_glass>", "[PUTBACK] <water_glass> <dishwasher>", "[FIND] <water_glass>", "[GRAB] <water_glass>", "[PUTBACK] <water_glass> <dishwasher>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[PUTBACK] <dish_soap> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'filing_cabinet', 'tablelamp', 'juice', 'food_salt', 'microwave', 'chair', 'freezer', 'detergent', 'trashcan', 'toothbrush', 'floor', 'ceiling', 'bookshelf', 'toaster', 'shower', 'stereo', 'mousepad', 'clothes_pants', 'clothes_hat', 'pillow', 'dining_room', 'wall', 'food_food', 'check', 'food_donut', 'kitchen_counter', 'cupboard', 'door', 'home_office']\nTask:Cook some food\nresponse:\n{\n    \"thoughts\": Go kitchen and make something for eat,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <food_food>']\n}\n", "input": "\nScene_Objects:['water_glass', 'filing_cabinet', 'juice', 'milk', 'hanger', 'kitchen_cabinet', 'bathroom_counter', 'button', 'food_bacon', 'stovefan', 'mat', 'shoe-shine_kit', 'tvstand', 'electric_shaver', 'food_peanut_butter', 'form', 'dining_room', 'cutting_board', 'cup', 'photoframe', 'coffe_maker', 'television', 'water', 'wooden_spoon', 'kettle', 'kitchen_counter', 'chessboard', 'dresser', 'sink', 'spoon']\nTask:Drink\nresponse:\n", "output": {"thoughts": "Go to kitchen. Open the the cabinet. Locate the water glass. Pour water into glass. Drag the bottle close to mouth. Drink water.", "actions": ["[WALK] <dining_room>", "[WALK] <kitchen_cabinet>", "[FIND] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[FIND] <water>", "[GRAB] <water>", "[FIND] <water_glass>", "[POUR] <water> <water_glass>", "[CLOSE] <kitchen_cabinet>", "[GRAB] <water_glass>", "[DRINK] <water_glass>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'computer', 'button', 'clothes_jacket', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'powersocket', 'bed', 'check', 'food_food', 'food_onion', 'dresser', 'light']\nTask:Put on glasses\nresponse:\n{\n    \"thoughts\": Put on glasses.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <dresser>', '[FIND] <dresser>', '[FIND] <spectacles>', '[GRAB] <spectacles>', '[PUTON] <spectacles>']\n}\n", "input": "\nScene_Objects:['fork', 'filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'ground_coffee', 'drawing', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'wall', 'powersocket', 'bed', 'television', 'curtain', 'doorjamb', 'hair', 'clothes_dress', 'door', 'table', 'clothes_skirt', 'scrabble']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "Walk into the living room/den. Turn on the television. Switch channels to find a program with remote. I find a program and look at the screen.", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[SWITCHON] <television>", "[FIND] <remote_control>", "[TURNTO] <remote_control>", "[TURNTO] <television>", "[LOOKAT] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'chair', 'freezer', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'wall', 'nightstand', 'photoframe', 'novel', 'television', 'mouse', 'kitchen_counter', 'door', 'sink', 'clothes_skirt', 'clothes_shirt']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Go to home office, find the book. Sit in the chair and read the book.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['food_bread', 'walllamp', 'toothbrush', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'tea_bag', 'toaster', 'ceilinglamp', 'window', 'homework', 'food_noodles', 'couch', 'candle', 'pillow', 'dining_room', 'wall', 'powersocket', 'toy', 'food_food', 'toilet_paper', 'tray', 'curtain', 'food_onion', 'shoes', 'door', 'table']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[WALK] <couch>", "[LIE] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'television', 'doorjamb', 'mouse', 'headset', 'dresser', 'door']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": Browse the internet,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <chair>', '[LOOKAT] <chair>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'food_salt', 'chair', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'mousepad', 'pillow', 'wall', 'nightstand', 'photoframe', 'razor', 'television', 'food_rice', 'mouse', 'kitchen_counter', 'dresser', 'door', 'bathroom_cabinet', 'table', 'dirt']\nTask:Work\nresponse:\n", "output": {"thoughts": "I go to my office. I switch the computer on and sit on the office chair. I look at the computer screen to see what needs to be done. I use my mouse to navigate to the relevant directory, then release it. I type code with my keyboard. When I'm done, I look at the computer again to evaluate what I've done. Then I switch off the computer using the mouse and put back the mouse.", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>", "[FIND] <chair>", "[SIT] <chair>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[FIND] <mouse>", "[GRAB] <mouse>", "[PUTOBJBACK] <mouse>", "[FIND] <keyboard>", "[TYPE] <keyboard>", "[TURNTO] <computer>", "[LOOKAT] <computer>", "[GRAB] <mouse>", "[SWITCHOFF] <computer>", "[PUTOBJBACK] <mouse>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'food_salt', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'computer', 'mat', 'faucet', 'closetdrawer', 'pillow', 'dining_room', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'toothbrush_holder', 'wine', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'door', 'sink', 'clothes_scarf', 'light']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": Walk into living room. Find wall. Find light button. Switch on light button.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['sheets', 'tablelamp', 'chair', 'freezer', 'cat', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'stereo', 'faucet', 'picture', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'home_office', 'light']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "I go to the bedroom and sit at my desk. I turn my radio on and listen to music.", "actions": ["[WALK] <bedroom>", "[WALK] <light>", "[FIND] <light>", "[SWITCHON] <light>", "[WALK] <desk>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['measuring_cup', 'microwave', 'chair', 'walllamp', 'cat', 'wallshelf', 'floor', 'character', 'desk', 'tea_bag', 'toaster', 'plate', 'couch', 'dining_room', 'box', 'newspaper', 'bed', 'toilet_paper', 'curtain', 'coffee_pot', 'mouse', 'kettle', 'cupboard', 'controller', 'clothes_dress', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Find Cat in living room.  Walk to cat.  Pet cat.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['sponge', 'tablelamp', 'microwave', 'chair', 'walllamp', 'trashcan', 'food_butter', 'orchid', 'floor', 'dvd_player', 'desk', 'toaster', 'tvstand', 'oil', 'wall', 'bench', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'razor', 'wooden_spoon', 'curtain', 'coffee_pot', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'spoon', 'dishwasher']\nTask:Wash dishes by hand\nresponse:\n", "output": {"thoughts": "walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[FIND] <dishrack>", "[FIND] <dishrack>", "[GRAB] <dishrack>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[PUTBACK] <dishrack> <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'beer', 'chair', 'detergent', 'trashcan', 'drawing', 'cpuscreen', 'hanger', 'bathroom_counter', 'dvd_player', 'stamp', 'bookshelf', 'toaster', 'ceilinglamp', 'faucet', 'homework', 'floor_lamp', 'window', 'food_orange', 'dining_room', 'nightstand', 'bench', 'food_cheese', 'television', 'doorjamb', 'lighter', 'cupboard', 'home_office', 'dishwasher', 'laser_pointer']\nTask:Turn off light\nresponse:\n{\n    \"thoughts\": Walk to the lamp.  Find the switch.  Click the switch off.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[SWITCHOFF] <floor_lamp>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'toilet', 'trashcan', 'food_carrot', 'food_egg', 'ceiling', 'folder', 'stamp', 'bookshelf', 'toaster', 'laptop', 'shower', 'food_noodles', 'couch', 'form', 'nightstand', 'powersocket', 'bench', 'toy', 'bed', 'keys', 'novel', 'doorjamb', 'hairbrush', 'cupboard', 'conditioner', 'spoon', 'bathroom_cabinet', 'table', 'board_game']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "Walk into the living room, walk over to phone, grab the phone, put it to your ear .", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'microwave', 'toilet', 'jelly', 'drawing', 'floor', 'ceiling', 'character', 'desk', 'bookshelf', 'ceilinglamp', 'deck_of_cards', 'stereo', 'shower', 'window', 'couch', 'candle', 'microphone', 'wall', 'powersocket', 'box', 'photoframe', 'television', 'tray', 'towel_rack', 'sink', 'napkin', 'bathroom_cabinet', 'table', 'home_office']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": walk to living room, walk to sofa, sit on sofa.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'trashcan', 'food_carrot', 'knifeblock', 'drawing', 'cpuscreen', 'clothes_underwear', 'floor', 'bedroom', 'alcohol', 'laptop', 'tvstand', 'stereo', 'faucet', 'mat', 'couch', 'clothes_hat', 'nightstand', 'bench', 'oven', 'toy', 'coffe_maker', 'television', 'coin', 'kitchen_counter', 'cupboard', 'home_office', 'bathroom_cabinet', 'dishwasher', 'board_game']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "go to radio. run on radio.", "actions": ["[WALK] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'tablelamp', 'measuring_cup', 'walllamp', 'ceilingfan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'clothes_socks', 'food_noodles', 'couch', 'broom', 'wall', 'newspaper', 'light_bulb', 'novel', 'television', 'curtain', 'doorjamb', 'lighter', 'cupboard', 'table', 'light']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": Walk to the living room. Find remote control. Grab remote control. Walk to television. Look at television. Switch on remote control.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[WALK] <television>', '[TURNTO] <television>', '[LOOKAT] <television>', '[SWITCHON] <television>']\n}\n", "input": "\nScene_Objects:['beer', 'bathroom', 'trashcan', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'button', 'brush', 'mat', 'toaster', 'faucet', 'picture', 'iron', 'pillow', 'broom', 'wall', 'oven', 'keys', 'novel', 'coin', 'tray', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'soap', 'clothes_shirt', 'scrabble', 'hands_both']\nTask:Wash hands\nresponse:\n", "output": {"thoughts": "Go to the bathroom and to the sink, turn the faucet on, push the bottle of soap onto your hands and scrub them. Then rinse your hands out and turn the faucet off.", "actions": ["[WALK] <bathroom>", "[WALK] <sink>", "[FIND] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <soap>", "[PUSH] <soap>", "[FIND] <hands_both>", "[SCRUB] <hands_both>", "[RINSE] <hands_both>", "[SWITCHOFF] <faucet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'face', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'wall_clock', 'face_soap', 'food_food', 'coffe_maker', 'tray', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'shoe_rack']\nTask:Wash face\nresponse:\n{\n    \"thoughts\": Run warm water. Cleanse my face with soap. Rinse my face with water.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <face_soap>', '[GRAB] <face_soap>', '[FIND] <face>', '[SCRUB] <face>', '[PUTOBJBACK] <face_soap>', '[WASH] <face>', '[RINSE] <face>', '[SWITCHOFF] <faucet>']\n}\n", "input": "\nScene_Objects:['chair', 'freezer', 'ground_coffee', 'walllamp', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'bedroom', 'ceilinglamp', 'tvstand', 'stereo', 'food_orange', 'cup', 'bed', 'keys', 'novel', 'food_food', 'coffe_maker', 'mouthwash', 'coin', 'check', 'diary', 'coffee_pot', 'mouse', 'dresser', 'hair', 'table', 'light']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "I go to my bedroom, and then I switch on the radio", "actions": ["[WALK] <bedroom>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'toilet', 'nail_polish', 'detergent', 'cat', 'trashcan', 'milk', 'knifeblock', 'phone', 'ceiling', 'desk', 'keyboard', 'mousepad', 'couch', 'pillow', 'bench', 'oven', 'cup', 'bed', 'light_bulb', 'food_food', 'lighter', 'kitchen_counter', 'hairbrush', 'dresser', 'laundry_detergent', 'table', 'clothes_skirt', 'tooth_paste', 'dirt']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Petting a cat may sound simple.Letting the Cat Come to You.Extend a hand or finger and allow the cat a chance to touch her nose to you. When a cat bumps her head into your hand, it's a signal she wants attention.Focusing on Areas with Scent Glands. Feed with food.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <milk>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[TURNTO] <cat>', '[POINTAT] <cat>']\n}\n", "input": "\nScene_Objects:['spectacles', 'sponge', 'food_bread', 'blender', 'chair', 'walllamp', 'orchid', 'knife', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'tvstand', 'window', 'mousepad', 'clothes_socks', 'wall', 'oven', 'cup', 'television', 'mouse', 'cupboard', 'door', 'home_office', 'table']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "go to the office, turn computer on, open an browser or any application to open any website.", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>", "[FIND] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'band-aids', 'freezer', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'bookshelf', 'computer', 'tvstand', 'shower', 'homework', 'clothes_pants', 'bowl', 'nightstand', 'wall', 'oven', 'cup', 'photoframe', 'food_food', 'toilet_paper', 'coffe_maker', 'wine', 'tray', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Find the cat.  Pet the cat.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'freezer', 'cpuscreen', 'ceiling', 'desk', 'computer', 'button', 'piano_bench', 'mop_bucket', 'mat', 'stereo', 'food_noodles', 'mousepad', 'wall', 'bench', 'bed', 'novel', 'oven_mitts', 'curtain', 'doorjamb', 'centerpiece', 'kettle', 'cupboard', 'table', 'dishwasher', 'instrument_violin', 'laser_pointer']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "grab the vesseles and wash", "actions": ["[WALK] <dining_room>", "[WALK] <bowl>", "[FIND] <bowl>", "[GRAB] <bowl>", "[WALK] <dining_room>", "[WASH] <bowl>", "[WALK] <detergent>", "[FIND] <detergent>", "[RINSE] <detergent>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'mop', 'microwave', 'walllamp', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'iron', 'window', 'laptop', 'dish_soap', 'wall', 'oven', 'coffe_maker', 'check', 'tray', 'rag', 'towel_rack', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet']\nTask:Wash dishes\nresponse:\n{\n    \"thoughts\": Run hot water into tub of dirty dishes in the sink.  Add liquid soap.  Scrub dishes with wash rag. Rinse and place on drying rack.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[POUR] <dish_soap> <sink>', '[PUTOBJBACK] <dish_soap>', '[FIND] <rag>', '[GRAB] <rag>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>', '[PUTOBJBACK] <rag>']\n}\n", "input": "\nScene_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']\nTask:Text friends while sitting on couch\nresponse:\n", "output": {"thoughts": "Text while sitting", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[GRAB] <phone>", "[WALK] <couch>", "[SIT] <couch>", "[TURNTO] <phone>", "[LOOKAT] <phone>", "[TOUCH] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Hang up car keys\nresponse:\n{\n    \"thoughts\": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']\n}\n", "input": "\nScene_Objects:['pot', 'food_salt', 'microwave', 'toilet', 'dog', 'detergent', 'orchid', 'wallshelf', 'food_egg', 'cpuscreen', 'phone', 'stamp', 'bedroom', 'bookshelf', 'bookmark', 'shower', 'mousepad', 'food_jam', 'towel', 'pasta', 'bed', 'novel', 'food_food', 'curtain', 'centerpiece', 'shaving_cream', 'dresser', 'cupboard', 'table', 'creditcard']\nTask:Walk through\nresponse:\n", "output": {"thoughts": "Walk through the entrance hall", "actions": ["[WALK] <home_office>", "[WALK] <home_office>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'fork', 'crayon', 'tea', 'toilet', 'bathroom', 'orchid', 'hanger', 'floor', 'character', 'bedroom', 'tea_bag', 'keyboard', 'purse', 'toaster', 'mat', 'deck_of_cards', 'window', 'food_orange', 'pillow', 'photoframe', 'food_food', 'coffe_maker', 'food_donut', 'towel_rack', 'mouse', 'pencil', 'dresser', 'door', 'sink']\nTask:Open door\nresponse:\n{\n    \"thoughts\": Open the door when leaving or coming in.,\n    \"actions\": ['[WALK] <home_office>']\n}\n", "input": "\nScene_Objects:['sponge', 'microwave', 'knifeblock', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'plate', 'faucet', 'window', 'dish_soap', 'food_noodles', 'closetdrawer', 'couch', 'towel', 'dining_room', 'wall', 'wine', 'rag', 'shaving_cream', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'conditioner', 'sink', 'table', 'dishwasher', 'soap']\nTask:Wash dishes\nresponse:\n", "output": {"thoughts": "Run warm water in the sink. Pour dish washing liquid on the dishes. Pick up dishes and wash them individually with a sponge. Rinse suds off under running water. Dry dishes with towel.", "actions": ["[WALK] <dining_room>", "[WALK] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[FIND] <sponge>", "[GRAB] <sponge>", "[POUR] <dish_soap> <sponge>", "[PUTOBJBACK] <dish_soap>", "[FIND] <plate>", "[GRAB] <plate>", "[SCRUB] <plate>", "[WASH] <plate>", "[RINSE] <plate>", "[RINSE] <sponge>", "[SWITCHOFF] <faucet>", "[PUTOBJBACK] <sponge>", "[FIND] <towel>", "[GRAB] <towel>", "[WIPE] <plate>", "[PUTOBJBACK] <towel>", "[WALK] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[PUTIN] <plate> <kitchen_cabinet>", "[CLOSE] <kitchen_cabinet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'freezer', 'ground_coffee', 'walllamp', 'bathroom', 'trashcan', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'stovefan', 'homework', 'wall', 'novel', 'coffe_maker', 'television', 'coffee_filter', 'water', 'tray', 'after_shave', 'diary', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'food_steak', 'dishwasher']\nTask:Make coffee\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'microwave', 'freezer', 'walllamp', 'detergent', 'dough', 'floor', 'phone', 'ceiling', 'tea_bag', 'bookshelf', 'keyboard', 'toaster', 'laptop', 'tvstand', 'faucet', 'mousepad', 'dining_room', 'wall', 'box', 'cup', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'dishwasher']\nTask:Make popcorn\nresponse:\n", "output": {"thoughts": "Lay popcorn bag flat inside microwave and press popcorn button to start.", "actions": ["[WALK] <dining_room>", "[WALK] <food_food>", "[FIND] <food_food>", "[GRAB] <food_food>", "[WALK] <microwave>", "[TURNTO] <microwave>", "[OPEN] <microwave>", "[PUTIN] <food_food> <microwave>", "[CLOSE] <microwave>", "[SWITCHON] <microwave>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'chair', 'walllamp', 'bathroom', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'envelope', 'computer', 'mop_bucket', 'stovefan', 'mat', 'tvstand', 'toaster', 'foundation', 'mousepad', 'pillow', 'wall', 'standingmirror', 'photoframe', 'toilet_paper', 'oven_mitts', 'tray', 'mouse', 'sink']\nTask:Read book\nresponse:\n{\n    \"thoughts\": go to living room,find the text book on the self ,sat on the chair ,open and read the book,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['sheets', 'beer', 'toilet', 'chair', 'band-aids', 'walllamp', 'bathroom', 'detergent', 'bills', 'knife', 'knifeblock', 'hanger', 'bedroom', 'button', 'plate', 'tvstand', 'iron', 'window', 'food_noodles', 'candle', 'nightstand', 'child', 'check', 'food_food', 'toothbrush_holder', 'razor', 'food_donut', 'cupboard', 'home_office', 'bathroom_cabinet']\nTask:Greet guests\nresponse:\n", "output": {"thoughts": "Say hi", "actions": ["[WALK] <home_office>", "[WALK] <child>", "[FIND] <child>", "[GREET] <child>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'chair', 'freezer', 'detergent', 'trashcan', 'drawing', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'mat', 'tvstand', 'shower', 'closetdrawer', 'wall', 'oven', 'cup', 'novel', 'water', 'drinking_glass', 'doorjamb', 'mouse', 'kitchen_counter', 'comb', 'cupboard', 'door']\nTask:Drink\nresponse:\n{\n    \"thoughts\": go to the kitchen,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[FIND] <water>', '[DRINK] <drinking_glass>']\n}\n", "input": "\nScene_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']\nTask:Read book\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'crayon', 'microwave', 'food_butter', 'drawing', 'knifeblock', 'floor', 'bedroom', 'envelope', 'stovefan', 'ceilinglamp', 'mat', 'balanceball', 'window', 'couch', 'clothes_hat', 'wall', 'nightstand', 'oven', 'basket_for_clothes', 'television', 'after_shave', 'cards', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'hairdryer', 'spoon', 'table', 'light']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": Walk to the living room. Walk to the sofa and sit on the sofa.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'chair', 'knifeblock', 'knife', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'mail', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'stereo', 'pillow', 'dining_room', 'wall', 'cup', 'bed', 'novel', 'coffe_maker', 'doorjamb', 'kitchen_counter', 'cupboard', 'controller', 'laundry_detergent', 'hairdryer', 'sink', 'home_office', 'dishwasher']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Making coffee", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'food_orange', 'pillow', 'food_kiwi', 'wall', 'photoframe', 'newspaper', 'television', 'food_donut', 'food_rice', 'doorjamb', 'mouse', 'cd', 'dresser']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": turn on the tv,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'pot', 'fork', 'scissors', 'food_ice_cream', 'microwave', 'walllamp', 'knifeblock', 'knife', 'wallshelf', 'floor', 'ceiling', 'phone', 'alcohol', 'clothes_jacket', 'toaster', 'stovefan', 'faucet', 'couch', 'wall', 'nightstand', 'oven', 'food_food', 'tray', 'rag', 'pencil', 'kitchen_counter', 'cupboard', 'sink', 'colander']\nTask:Clean\nresponse:\n", "output": {"thoughts": "Take out a rag. Turn on faucet and get water on the rag. Clean counter off.", "actions": ["[WALK] <dining_room>", "[WALK] <rag>", "[FIND] <rag>", "[GRAB] <rag>", "[WALK] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[PUTBACK] <rag> <sink>", "[SWITCHOFF] <faucet>", "[GRAB] <rag>", "[SQUEEZE] <rag>", "[WALK] <kitchen_counter>", "[WIPE] <kitchen_counter>", "[PUTOBJBACK] <rag>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_salt', 'toilet', 'chair', 'bathroom', 'trashcan', 'drawing', 'floor', 'character', 'desk', 'purse', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'shower', 'foundation', 'couch', 'pillow', 'nightstand', 'powersocket', 'novel', 'tray', 'mouse', 'bathroom_cabinet', 'soap', 'teeth']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": First I need to find the cat in the living room. Then I walk over to the cat and pet it gently.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'tvstand', 'dish_soap', 'wall', 'pasta', 'coffee_filter', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'scrabble']\nTask:Wash dishes\nresponse:\n", "output": {"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>", "[FIND] <plate>", "[GRAB] <plate>", "[RINSE] <plate>", "[PUTBACK] <plate> <sink>", "[FIND] <plate>", "[GRAB] <plate>", "[RINSE] <plate>", "[PUTBACK] <plate> <sink>", "[SWITCHOFF] <faucet>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[FIND] <sponge>", "[GRAB] <sponge>", "[POUR] <dish_soap> <sponge>", "[PUTOBJBACK] <dish_soap>", "[GRAB] <plate>", "[SCRUB] <plate>", "[PUTOBJBACK] <plate>", "[GRAB] <plate>", "[SCRUB] <plate>", "[PUTOBJBACK] <plate>", "[SWITCHON] <faucet>", "[RINSE] <sponge>", "[PUTOBJBACK] <sponge>", "[GRAB] <plate>", "[RINSE] <plate>", "[FIND] <dishrack>", "[PUTBACK] <plate> <dishrack>", "[GRAB] <plate>", "[RINSE] <plate>", "[PUTBACK] <plate> <dishrack>", "[SWITCHOFF] <faucet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'trashcan', 'knifeblock', 'cpuscreen', 'floor', 'desk', 'tea_bag', 'keyboard', 'bookshelf', 'computer', 'alcohol', 'laptop', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'tape', 'cup', 'photoframe', 'food_food', 'mouse', 'vacuum_cleaner', 'chessboard', 'napkin', 'table', 'soap']\nTask:Work\nresponse:\n{\n    \"thoughts\": first ill go to my home office adn ill switch on my laptop and with the use of mouse and keyboard il run my computer,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <mouse>', '[TOUCH] <mouse>', '[RUN] <laptop>']\n}\n", "input": "\nScene_Objects:['sheets', 'spectacles', 'walllamp', 'cat', 'drawing', 'needle', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'mat', 'ceilinglamp', 'faucet', 'stereo', 'towel', 'pillow', 'wall', 'tape', 'bed', 'toilet_paper', 'video_game_controller', 'television', 'food_food', 'tray', 'diary', 'console', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n", "output": {"thoughts": "Cleaning hands", "actions": ["[WALK] <bathroom>", "[WALK] <faucet>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <soap>", "[GRAB] <soap>", "[FIND] <hands_both>", "[SCRUB] <hands_both>", "[PUTOBJBACK] <soap>", "[RINSE] <hands_both>", "[SWITCHOFF] <faucet>", "[FIND] <towel>", "[GRAB] <towel>", "[WIPE] <hands_both>", "[PUTOBJBACK] <towel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'mop', 'cd_player', 'chair', 'knifeblock', 'music_stand', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'envelope', 'food_bacon', 'mop_bucket', 'stovefan', 'ceilinglamp', 'shower', 'nightstand', 'bed', 'photoframe', 'coffe_maker', 'tray', 'curtain', 'lighter', 'kitchen_counter', 'comb', 'dresser', 'cupboard', 'bathroom_cabinet', 'light']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": Walk to the living and turn to the music stand. Switch on the CD player to listen to music.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <music_stand>', '[FIND] <music_stand>', '[TURNTO] <music_stand>', '[FIND] <cd_player>', '[SWITCHON] <cd_player>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'crayon', 'walllamp', 'dough', 'knife', 'needle', 'food_egg', 'knifeblock', 'phone', 'ceiling', 'desk', 'bookshelf', 'stovefan', 'stereo', 'oil', 'food_orange', 'dining_room', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'wooden_spoon', 'curtain', 'doorjamb', 'kitchen_counter', 'sink', 'napkin', 'bag', 'light', 'dishwasher']\nTask:Walk through\nresponse:\n", "output": {"thoughts": "Walk through the hallway.", "actions": ["[WALK] <home_office>", "[WALK] <home_office>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'microwave', 'dog', 'chair', 'bathroom', 'drawing', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'mat', 'ceilinglamp', 'shower', 'candle', 'wall', 'bed', 'clothes_gloves', 'food_food', 'water', 'food_rice', 'wooden_spoon', 'curtain', 'console', 'dishrack', 'pajamas', 'light', 'clothes_skirt', 'soap', 'dirt']\nTask:Take shower\nresponse:\n{\n    \"thoughts\": go to a bathroom, open the shower, let water wash your body,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <soap>', '[SCRUB] <soap>', '[FIND] <water>', '[RINSE] <water>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'pot', 'microwave', 'toilet', 'jelly', 'freezer', 'walllamp', 'detergent', 'knifeblock', 'drawing', 'kitchen_cabinet', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'toaster', 'mat', 'faucet', 'shower', 'oil', 'wall', 'nightstand', 'oven', 'powersocket', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light', 'dishwasher']\nTask:Cook some food\nresponse:\n", "output": {"thoughts": "Cooking a meal", "actions": ["[WALK] <dining_room>", "[WALK] <kitchen_cabinet>", "[FIND] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[FIND] <pot>", "[GRAB] <pot>", "[CLOSE] <kitchen_cabinet>", "[WALK] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[PUTBACK] <pot> <sink>", "[GRAB] <pot>", "[SWITCHOFF] <faucet>", "[WALK] <oven>", "[PUTBACK] <pot> <oven>", "[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>", "[GRAB] <food_food>", "[CLOSE] <freezer>", "[WALK] <oven>", "[PUTBACK] <food_food> <pot>", "[SWITCHON] <oven>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'tablelamp', 'food_salt', 'bathroom', 'drawing', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'stereo', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'coffe_maker', 'toothbrush_holder', 'wooden_spoon', 'doorjamb', 'shoes', 'dresser', 'door', 'light', 'coffee']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": switching on the light,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'mop', 'walllamp', 'detergent', 'food_carrot', 'toothbrush', 'knifeblock', 'orchid', 'clothes_underwear', 'hanger', 'phone', 'stovefan', 'shower', 'homework', 'couch', 'food_jam', 'microphone', 'bowl', 'photoframe', 'check', 'curtain', 'console', 'mouse', 'pencil', 'dresser', 'sink', 'soap', 'creditcard']\nTask:Pet dog\nresponse:\n", "output": {"thoughts": "Pet my dog in hall", "actions": ["[WALK] <home_office>", "[WALK] <dog>", "[TURNTO] <dog>", "[LOOKAT] <dog>", "[TOUCH] <dog>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_ice_cream', 'microwave', 'toilet', 'freezer', 'blow_dryer', 'bathroom', 'cpuscreen', 'ceiling', 'bedroom', 'bookshelf', 'purse', 'food_bacon', 'tvstand', 'clothes_socks', 'oil', 'towel', 'nightstand', 'oven', 'bed', 'check', 'coffee_filter', 'curtain', 'clothes_dress', 'door', 'sink', 'home_office', 'table', 'light', 'colander', 'laser_pointer']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Pour water into a glass and drink from the glass.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'freezer', 'knife', 'floor', 'ceiling', 'folder', 'stamp', 'brush', 'mat', 'ceilinglamp', 'shower', 'faucet', 'toaster', 'pillow', 'bowl', 'food_kiwi', 'wall', 'powersocket', 'toilet_paper', 'mouthwash', 'doorjamb', 'door', 'home_office', 'light', 'table']\nTask:Turn light off\nresponse:\n", "output": {"thoughts": "Put the light switch into the down, or off, position.", "actions": ["[WALK] <dining_room>", "[WALK] <light>", "[FIND] <light>", "[SWITCHOFF] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'toilet', 'chair', 'freezer', 'detergent', 'orchid', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'purse', 'toaster', 'mat', 'faucet', 'iron', 'mousepad', 'wall', 'powersocket', 'cup', 'coffe_maker', 'water', 'shaving_cream', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'clothes_scarf', 'colander']\nTask:Drink\nresponse:\n{\n    \"thoughts\": I go in the kitchen and get the glass near the sink. I open the faucet, then I pour water in it, turn off the faucet and drink it.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <cup>', '[GRAB] <cup>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[PUTBACK] <cup> <sink>', '[GRAB] <cup>', '[SWITCHOFF] <faucet>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['sponge', 'tablelamp', 'measuring_cup', 'microwave', 'blow_dryer', 'bathroom', 'woman', 'knifeblock', 'clothes_underwear', 'phone', 'dvd_player', 'man', 'mail', 'toaster', 'iron', 'faucet', 'food_orange', 'child', 'powersocket', 'cup', 'food_cheese', 'check', 'tray', 'curtain', 'door', 'sink', 'home_office', 'dishwasher', 'clothes_skirt', 'tooth_paste']\nTask:Say goodbye to guests leaving\nresponse:\n", "output": {"thoughts": "Tell them bye", "actions": ["[WALK] <home_office>", "[WALK] <child>", "[FIND] <child>", "[TOUCH] <child>", "[FIND] <man>", "[TOUCH] <man>", "[FIND] <woman>", "[TOUCH] <woman>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['walllamp', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'mat', 'tvstand', 'shower', 'plate', 'faucet', 'couch', 'pillow', 'dining_room', 'broom', 'wall', 'powersocket', 'box', 'photoframe', 'novel', 'food_food', 'television', 'food_donut', 'curtain', 'doorjamb', 'bathroom_cabinet']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Sit on couch. Grab book. Open book. Read book.,\n    \"actions\": ['[WALK] <couch>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['fork', 'pot', 'toilet', 'chair', 'bathroom', 'drawing', 'knife', 'clothes_underwear', 'floor', 'mail', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'plate', 'deck_of_cards', 'toaster', 'oil', 'wall', 'wall_clock', 'oven', 'cup', 'novel', 'food_food', 'television', 'oven_mitts', 'cards', 'cupboard', 'conditioner', 'table']\nTask:Eat dinner\nresponse:\n", "output": {"thoughts": "Sit down at the dinning table with my family and eat dinner.", "actions": ["[WALK] <dining_room>", "[WALK] <table>", "[FIND] <chair>", "[PULL] <chair>", "[SIT] <chair>", "[FIND] <food_food>", "[TURNTO] <food_food>", "[LOOKAT] <food_food>", "[GRAB] <food_food>", "[FIND] <plate>", "[PUTBACK] <food_food> <plate>", "[GRAB] <food_food>", "[PUTOBJBACK] <food_food>", "[FIND] <fork>", "[GRAB] <fork>", "[EAT] <plate>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'character', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'faucet', 'shower', 'window', 'towel', 'wall', 'newspaper', 'curtain', 'towel_rack', 'pencil', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']\n}\n", "input": "\nScene_Objects:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'floor', 'ceiling', 'character', 'bookshelf', 'envelope', 'mop_bucket', 'toaster', 'mat', 'faucet', 'dish_soap', 'couch', 'wall', 'cup', 'photoframe', 'toilet_paper', 'video_game_controller', 'wooden_spoon', 'tray', 'console', 'mouse', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'light']\nTask:Wash dishes\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'toilet', 'freezer', 'trashcan', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'character', 'purse', 'mail', 'toaster', 'tvstand', 'faucet', 'towel', 'wall', 'nightstand', 'powersocket', 'food_food', 'television', 'curtain', 'doorjamb', 'towel_rack', 'dresser', 'sink', 'bathroom_cabinet', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": Turn faucet clockwise to turn on water.  Place hands under stream of water, pick up soap, rub hands with soap.  Put soap back down.  Rub hands together with soap on them.  Rinse hands under water from faucet.  Turn faucet counterclockwise to turn water off.  Dry hands by rubbing them on a towel.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[WASH] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']\n}\n", "input": "\nScene_Objects:['microwave', 'toilet', 'chair', 'jelly', 'ground_coffee', 'knifeblock', 'drawing', 'needle', 'food_egg', 'hanger', 'clothes_underwear', 'desk', 'purse', 'alcohol', 'mat', 'stereo', 'faucet', 'food_peanut_butter', 'wall', 'powersocket', 'photoframe', 'novel', 'coffe_maker', 'curtain', 'mouse', 'vacuum_cleaner', 'shoes', 'bathroom_cabinet', 'clothes_shirt', 'electrical_outlet']\nTask:Vacuum\nresponse:\n", "output": {"thoughts": "Plug vacuum into the wall. Turn on the vacuum. Move vacuum around the floor to clean it. Unplug vacuum.", "actions": ["[WALK] <home_office>", "[WALK] <vacuum_cleaner>", "[FIND] <vacuum_cleaner>", "[GRAB] <vacuum_cleaner>", "[FIND] <electrical_outlet>", "[PLUGIN] <vacuum_cleaner>", "[SWITCHON] <vacuum_cleaner>", "[PUSH] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[SWITCHOFF] <vacuum_cleaner>", "[PLUGOUT] <vacuum_cleaner>", "[PUTOBJBACK] <vacuum_cleaner>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['water_glass', 'filing_cabinet', 'pot', 'tablelamp', 'measuring_cup', 'freezer', 'walllamp', 'ceilingfan', 'knifeblock', 'drawing', 'longboard', 'floor', 'ceiling', 'keyboard', 'button', 'clothes_jacket', 'tvstand', 'couch', 'form', 'dining_room', 'bowl', 'nightstand', 'light_bulb', 'check', 'curtain', 'mouse', 'hair', 'cupboard', 'hairdryer', 'vase']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Walk to kitchen. Find water glass. Grab water glass. Find water. Pour water in water glass. Drink water from water glass.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'orchid', 'knifeblock', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'television', 'curtain', 'shaving_cream', 'dresser', 'home_office', 'table', 'bathroom_cabinet', 'shoe_rack']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "Watch favorite shows, netflix, hulu", "actions": ["[WALK] <home_office>", "[WALK] <remote_control>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[WALK] <couch>", "[SIT] <couch>", "[FIND] <television>", "[SWITCHON] <television>", "[PUTBACK] <remote_control> <couch>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'toilet', 'chair', 'drawing', 'cpuscreen', 'floor', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'mop_bucket', 'mat', 'laptop', 'window', 'homework', 'mousepad', 'food_orange', 'dining_room', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'bed', 'tray', 'curtain', 'mouse', 'pencil', 'light']\nTask:Watch movie\nresponse:\n{\n    \"thoughts\": Bring laptop to bed and watch a movie,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[WALK] <bed>', '[SIT] <bed>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'toilet', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'character', 'video_game_console', 'bedroom', 'computer', 'button', 'table_cloth', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'box', 'video_game_controller', 'television', 'curtain', 'pencil', 'dresser', 'door', 'table']\nTask:Play games\nresponse:\n", "output": {"thoughts": "Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video  game remote controller.", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[SWITCHON] <television>", "[FIND] <video_game_console>", "[SWITCHON] <video_game_console>", "[FIND] <video_game_controller>", "[GRAB] <video_game_controller>", "[FIND] <button>", "[PUSH] <button>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['freezer', 'band-aids', 'dough', 'cpuscreen', 'food_egg', 'floor', 'ceiling', 'dvd_player', 'desk', 'bedroom', 'keyboard', 'computer', 'clothes_jacket', 'ceilinglamp', 'mat', 'mousepad', 'wall', 'powersocket', 'cup', 'bed', 'photoframe', 'newspaper', 'water', 'food_donut', 'doorjamb', 'mouse', 'door', 'light', 'table', 'shoe_rack']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Feeling tired after hard work I opened the fridge and grabbed cool water and drank from the glass.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <cup>', '[GRAB] <cup>', '[CLOSE] <freezer>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <cup>', '[POUR] <water> <cup>', '[FIND] <cup>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['sheets', 'filing_cabinet', 'food_salt', 'toilet', 'detergent', 'cpuscreen', 'food_egg', 'bathroom_counter', 'floor', 'folder', 'desk', 'envelope', 'clothes_jacket', 'mat', 'plate', 'stereo', 'deck_of_cards', 'shower', 'couch', 'television', 'oven_mitts', 'curtain', 'shaving_cream', 'chessboard', 'cupboard', 'conditioner', 'light', 'table', 'soap', 'clothes_shirt']\nTask:Dust\nresponse:\n", "output": {"thoughts": "Get a broom or duster with long handle. Dust blades of ceiling fan.", "actions": ["[WALK] <bedroom>", "[WALK] <duster>", "[FIND] <duster>", "[GRAB] <duster>", "[PUTOBJBACK] <duster>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'microwave', 'toilet', 'walllamp', 'detergent', 'food_carrot', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'bedroom', 'keyboard', 'bookshelf', 'mat', 'mousepad', 'dining_room', 'wall', 'nightstand', 'bench', 'basket_for_clothes', 'bed', 'photoframe', 'coffe_maker', 'food_food', 'wooden_spoon', 'mouse', 'dresser', 'sink', 'dishwasher']\nTask:Go to sleep\nresponse:\n{\n    \"thoughts\": go t the bedroom and go to sleep,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'blender', 'tea', 'toilet', 'chair', 'freezer', 'drawing', 'knife', 'kitchen_cabinet', 'floor', 'ceiling', 'dvd_player', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'food_jam', 'wall', 'nightstand', 'powersocket', 'cutting_board', 'cup', 'food_vegetable', 'photoframe', 'basket_for_clothes', 'doorjamb', 'mouse', 'door', 'table', 'light']\nTask:Chop vegetables\nresponse:\n", "output": {"thoughts": "Cut up veggies with knife", "actions": ["[WALK] <dining_room>", "[WALK] <kitchen_cabinet>", "[FIND] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[FIND] <knife>", "[GRAB] <knife>", "[FIND] <cutting_board>", "[GRAB] <cutting_board>", "[CLOSE] <kitchen_cabinet>", "[WALK] <table>", "[PUTBACK] <knife> <table>", "[PUTBACK] <cutting_board> <table>", "[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <food_vegetable>", "[GRAB] <food_vegetable>", "[CLOSE] <freezer>", "[WALK] <table>", "[PUTBACK] <food_vegetable> <cutting_board>", "[GRAB] <knife>", "[CUT] <food_vegetable>", "[PUTOBJBACK] <knife>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['scissors', 'cat', 'drawing', 'hanger', 'longboard', 'floor', 'phone', 'character', 'desk', 'purse', 'stovefan', 'ceilinglamp', 'iron', 'stereo', 'window', 'oil', 'couch', 'wall', 'bench', 'toy', 'food_food', 'television', 'food_rice', 'towel_rack', 'console', 'hairbrush', 'napkin', 'table', 'vase', 'dirt']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": I would walk into the living room. Then sit on the couch and pet the cat.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['sponge', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'toaster', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'love_seat', 'clothes_gloves', 'television', 'tray', 'curtain', 'food_onion', 'dresser', 'cupboard', 'instrument_guitar', 'table', 'light']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "I'll watch TV", "actions": ["[WALK] <home_office>", "[WALK] <remote_control>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <television>", "[SWITCHON] <television>", "[PUTOBJBACK] <remote_control>", "[FIND] <love_seat>", "[SIT] <love_seat>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['walllamp', 'detergent', 'milk', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'stamp', 'food_cake', 'computer', 'piano_bench', 'mat', 'tvstand', 'faucet', 'shower', 'couch', 'clothes_hat', 'pillow', 'wall', 'powersocket', 'toy', 'photoframe', 'bed', 'television', 'curtain', 'doorjamb', 'mouse', 'light']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": I walk into the living room and I lie down on the sofa.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'table_cloth', 'stovefan', 'laptop', 'tvstand', 'picture', 'window', 'homework', 'closetdrawer', 'couch', 'food_jam', 'wall', 'television', 'curtain', 'mouse', 'dresser', 'sink', 'instrument_guitar', 'dishwasher', 'laser_pointer']\nTask:Open window\nresponse:\n", "output": {"thoughts": "Unlock the latch at the top. Push the bottom half of the window upwards.", "actions": ["[WALK] <home_office>", "[WALK] <window>", "[OPEN] <window>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'pot', 'food_pizza', 'tablelamp', 'microwave', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'food_bacon', 'stovefan', 'mat', 'shower', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'food_food', 'television', 'tray', 'doorjamb', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'light']\nTask:Cook some food\nresponse:\n{\n    \"thoughts\": go to the kitchen and cook some thing to eat,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <oven>', '[OPEN] <oven>', '[FIND] <food_pizza>', '[GRAB] <food_pizza>', '[PUTIN] <food_pizza> <oven>', '[SWITCHON] <oven>']\n}\n", "input": "\nScene_Objects:['pot', 'chair', 'drawing', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'mail', 'clothes_jacket', 'computer', 'ceilinglamp', 'plate', 'mat', 'picture', 'form', 'wall', 'bed', 'food_food', 'check', 'television', 'oven_mitts', 'diary', 'pencil', 'kitchen_counter', 'shoes', 'vacuum_cleaner', 'hairdryer', 'door', 'table', 'laser_pointer']\nTask:Eat dinner\nresponse:\n", "output": {"thoughts": "Put food on the table, sit down, and eat the food.", "actions": ["[WALK] <dining_room>", "[WALK] <plate>", "[FIND] <plate>", "[GRAB] <plate>", "[FIND] <food_food>", "[GRAB] <food_food>", "[PUTBACK] <food_food> <plate>", "[WALK] <dining_room>", "[WALK] <table>", "[FIND] <table>", "[PUTBACK] <plate> <table>", "[FIND] <chair>", "[SIT] <chair>", "[EAT] <plate>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'powersocket', 'novel', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'mouse', 'dresser', 'door', 'light']\nTask:Work\nresponse:\n{\n    \"thoughts\": I sit at my desk and work on the computer.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <check>', '[GRAB] <check>', '[READ] <check>', '[FIND] <keyboard>', '[TYPE] <keyboard>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'chair', 'freezer', 'walllamp', 'bathroom', 'cpuscreen', 'floor', 'character', 'desk', 'folder', 'keyboard', 'computer', 'mail', 'bookmark', 'laptop', 'ceilinglamp', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'food_orange', 'pillow', 'wall', 'love_seat', 'bed', 'photoframe', 'mouse', 'electrical_outlet']\nTask:Write book\nresponse:\n", "output": {"thoughts": "Writing a book", "actions": ["[WALK] <home_office>", "[WALK] <laptop>", "[FIND] <laptop>", "[GRAB] <laptop>", "[FIND] <electrical_outlet>", "[PLUGIN] <laptop>", "[WALK] <love_seat>", "[SIT] <love_seat>", "[SWITCHON] <laptop>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'sponge', 'scissors', 'microwave', 'ground_coffee', 'dough', 'orchid', 'needle', 'cpuscreen', 'floor', 'ceiling', 'tea_bag', 'food_cake', 'toaster', 'stovefan', 'tvstand', 'food_orange', 'pillow', 'dining_room', 'wall', 'nightstand', 'bench', 'coffe_maker', 'coffee_filter', 'hairbrush', 'napkin', 'bathroom_cabinet', 'home_office', 'dishwasher', 'vase']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Open the coffee maker and put a filer, grab ground coffee and put it in the coffee maker, then close the coffee maker and switch it on,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[FIND] <ground_coffee>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']\n}\n", "input": "\nScene_Objects:['glue', 'pot', 'filing_cabinet', 'tablelamp', 'mop', 'microwave', 'chair', 'dog', 'toothbrush', 'knifeblock', 'hanger', 'ceiling', 'bedroom', 'man', 'keyboard', 'ceilinglamp', 'stereo', 'shower', 'couch', 'food_jam', 'pillow', 'pasta', 'powersocket', 'coffe_maker', 'kettle', 'pencil', 'napkin', 'table', 'scrabble', 'creditcard']\nTask:Greet guests\nresponse:\n", "output": {"thoughts": "When someone knocks I n the door walk through the hallway and greet them.", "actions": ["[RUN] <home_office>", "[WALK] <man>", "[FIND] <man>", "[GREET] <man>", "[FIND] <man>", "[GREET] <man>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'toilet', 'freezer', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'envelope', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'shower', 'stereo', 'mousepad', 'towel', 'wall', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'tray', 'curtain', 'doorjamb', 'dresser', 'controller', 'door', 'food_steak', 'light', 'tooth_paste']\nTask:Take shower\nresponse:\n{\n    \"thoughts\": walk to bathroom , find shower , take a shower,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <shower>', '[FIND] <shower>']\n}\n", "input": "\nScene_Objects:['pot', 'food_bread', 'juice', 'toilet', 'chair', 'freezer', 'ground_coffee', 'walllamp', 'food_butter', 'food_carrot', 'drawing', 'floor', 'ceiling', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'food_peanut_butter', 'food_jam', 'bowl', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'food_cheese', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'food_steak', 'light', 'dishwasher', 'table']\nTask:Grab some juice\nresponse:\n", "output": {"thoughts": "I go to the fridge, and grab some juice out of it. I then get a glass, and pour the juice into the glass.", "actions": ["[WALK] <dining_room>", "[WALK] <cupboard>", "[FIND] <cupboard>", "[OPEN] <cupboard>", "[FIND] <cup>", "[GRAB] <cup>", "[CLOSE] <cupboard>", "[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <juice>", "[GRAB] <juice>", "[POUR] <juice> <cup>", "[PUTOBJBACK] <juice>", "[CLOSE] <freezer>", "[FIND] <table>", "[PUTBACK] <cup> <table>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'tablelamp', 'food_ice_cream', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'longboard', 'floor', 'bookshelf', 'computer', 'faucet', 'balanceball', 'window', 'iron', 'food_peanut_butter', 'food_jam', 'wall', 'nightstand', 'bench', 'powersocket', 'basket_for_clothes', 'novel', 'check', 'coffee_filter', 'shaving_cream', 'pencil', 'maindoor', 'sink', 'hairdryer']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": Enter the Home office, then walk to the phone, pickup the phone.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['sponge', 'scissors', 'juice', 'food_salt', 'walllamp', 'toothbrush', 'bathroom_counter', 'shampoo', 'character', 'stamp', 'bookshelf', 'computer', 'toaster', 'stovefan', 'window', 'clothes_pants', 'pillow', 'bowl', 'food_kiwi', 'dining_room', 'oven', 'check', 'food_food', 'razor', 'ice', 'curtain', 'pencil', 'cupboard', 'sink', 'dishwasher']\nTask:Shut off alarm\nresponse:\n", "output": {"thoughts": "Shutting of the alarm clock", "actions": ["[WALK] <bedroom>", "[WALK] <alarm_clock>", "[FIND] <alarm_clock>", "[GRAB] <alarm_clock>", "[SWITCHOFF] <alarm_clock>", "[PUTOBJBACK] <alarm_clock>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": walk over and pick up the phone,\n    \"actions\": ['[WALK] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['spectacles', 'microwave', 'chair', 'freezer', 'walllamp', 'detergent', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'stereo', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'curtain', 'doorjamb', 'mouse', 'dresser', 'door', 'bag', 'light', 'table']\nTask:Turn on computer\nresponse:\n", "output": {"thoughts": "Press the power button on the computer to turn it on", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[SWITCHON] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'walllamp', 'drawing', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'check', 'television', 'doorjamb', 'mouse', 'address_book', 'dresser', 'door']\nTask:Write an email\nresponse:\n{\n    \"thoughts\": Walk to Home office. Sit on the chair. Switch on the computer. Find address in addressbook. Type in the keyboard. Write mail.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <address_book>', '[FIND] <keyboard>', '[TYPE] <keyboard>']\n}\n", "input": "\nScene_Objects:['sheets', 'food_salt', 'chair', 'wallshelf', 'character', 'keyboard', 'food_cake', 'mop_bucket', 'stovefan', 'toaster', 'iron', 'shower', 'window', 'clothes_socks', 'closetdrawer', 'dining_room', 'broom', 'box', 'coffe_maker', 'television', 'tray', 'centerpiece', 'doorjamb', 'kettle', 'mouse', 'headset', 'cupboard', 'bag', 'table', 'light']\nTask:Shut front door\nresponse:\n", "output": {"thoughts": "Close the storm door. Lock the storm door.", "actions": ["[WALK] <home_office>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'scissors', 'tea', 'freezer', 'blow_dryer', 'drawing', 'knifeblock', 'cpuscreen', 'clothes_underwear', 'character', 'desk', 'toaster', 'shower', 'picture', 'mousepad', 'candle', 'dining_room', 'bench', 'oven', 'basket_for_clothes', 'bed', 'check', 'television', 'toothbrush_holder', 'curtain', 'mouse', 'sink', 'light', 'tooth_paste', 'laser_pointer']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": I walk into the living room and then I walk to the light switch in there and turn the lights on,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>']\n}\n", "input": "\nScene_Objects:['pot', 'food_pizza', 'tablelamp', 'crayon', 'mop', 'toilet', 'chair', 'bathroom', 'detergent', 'dough', 'ceiling', 'keyboard', 'stereo', 'couch', 'pillow', 'cup', 'newspaper', 'keys', 'check', 'toothbrush_holder', 'food_donut', 'after_shave', 'rag', 'mouse', 'pajamas', 'cupboard', 'bag', 'light', 'table', 'tooth_paste']\nTask:Put away keys\nresponse:\n", "output": {"thoughts": "Return keys into a bag", "actions": ["[WALK] <home_office>", "[WALK] <keys>", "[FIND] <keys>", "[GRAB] <keys>", "[FIND] <bag>", "[OPEN] <bag>", "[PUTBACK] <keys> <bag>", "[CLOSE] <bag>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'dough', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'ceilinglamp', 'tvstand', 'shower', 'stovefan', 'mousepad', 'wall', 'nightstand', 'television', 'curtain', 'after_shave', 'mouse', 'kitchen_counter', 'clothes_dress', 'door', 'sink', 'home_office', 'soap']\nTask:Read book\nresponse:\n{\n    \"thoughts\": find a book to read. sit down. read the book.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[WALK] <chair>', '[SIT] <chair>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['sponge', 'sheets', 'pot', 'blender', 'microwave', 'chair', 'nail_polish', 'detergent', 'milk', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'clothes_socks', 'broom', 'wall', 'food_kiwi', 'powersocket', 'cup', 'photoframe', 'keys', 'newspaper', 'curtain', 'lighter', 'pencil', 'pajamas', 'clothes_dress', 'sink', 'table', 'light']\nTask:Sit in chair\nresponse:\n", "output": {"thoughts": "I sit in a chair to rest and eat.", "actions": ["[WALK] <dining_room>", "[WALK] <chair>", "[FIND] <chair>", "[PULL] <chair>", "[SIT] <chair>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'freezer', 'walllamp', 'drawing', 'needle', 'orchid', 'floor', 'stamp', 'keyboard', 'plate', 'faucet', 'shower', 'dish_soap', 'oil', 'wall', 'keys', 'coffe_maker', 'coffee_filter', 'pencil', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'controller', 'pajamas', 'food_steak', 'spoon', 'light', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['measuring_cup', 'mop', 'walllamp', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'tvstand', 'window', 'clothes_socks', 'closetdrawer', 'oil', 'dining_room', 'wall', 'toy', 'photoframe', 'television', 'curtain', 'rag', 'doorjamb', 'console', 'kitchen_counter', 'shoes', 'dresser', 'pajamas', 'bathroom_cabinet', 'table', 'tooth_paste']\nTask:Put away shoes\nresponse:\n", "output": {"thoughts": "Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door.", "actions": ["[WALK] <home_office>", "[WALK] <shoes>", "[FIND] <shoes>", "[GRAB] <shoes>", "[FIND] <dresser>", "[OPEN] <dresser>", "[PUTIN] <shoes> <dresser>", "[CLOSE] <dresser>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'juice', 'band-aids', 'freezer', 'bathroom', 'orchid', 'needle', 'wallshelf', 'knife', 'hanger', 'floor', 'ceiling', 'bedroom', 'keyboard', 'ceilinglamp', 'tvstand', 'shoe-shine_kit', 'wall', 'oven', 'food_food', 'oven_mitts', 'doorjamb', 'pencil', 'cd', 'dresser', 'door', 'maindoor', 'bathroom_cabinet', 'light', 'clothes_skirt']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": Walk to the bedroom and use the button on the wall, next to the door to turn on the lights.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <home_office>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'walllamp', 'cat', 'milk', 'orchid', 'drawing', 'bills', 'hanger', 'floor', 'ceiling', 'phone', 'character', 'bookshelf', 'toaster', 'ceilinglamp', 'mat', 'stereo', 'picture', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'powersocket', 'basket_for_clothes', 'photoframe', 'doorjamb', 'door', 'light', 'table']\nTask:Look at painting\nresponse:\n", "output": {"thoughts": "Walk to the painting.  Look up at the painting.  Admire it on the wall.", "actions": ["[WALK] <home_office>", "[WALK] <drawing>", "[FIND] <drawing>", "[TURNTO] <drawing>", "[LOOKAT] <drawing>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_salt', 'toilet', 'walllamp', 'bathroom', 'trashcan', 'knifeblock', 'floor', 'tea_bag', 'bookshelf', 'food_bacon', 'toaster', 'plate', 'tvstand', 'dish_soap', 'mousepad', 'couch', 'wall', 'oven', 'powersocket', 'photoframe', 'coffe_maker', 'food_food', 'toothbrush_holder', 'ice', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'cupboard', 'clothes_dress', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['pot', 'food_pizza', 'juice', 'tea', 'chair', 'freezer', 'bathroom', 'detergent', 'wallshelf', 'cpuscreen', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'window', 'dustpan', 'bed', 'light_bulb', 'check', 'food_food', 'curtain', 'dresser', 'door', 'napkin', 'light', 'colander', 'clothes_shirt', 'scrabble', 'dirt']\nTask:Answer door\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'filing_cabinet', 'blender', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'floor', 'bedroom', 'bookshelf', 'stovefan', 'food_peanut_butter', 'clothes_hat', 'clothes_pants', 'dining_room', 'nightstand', 'wall_clock', 'video_game_controller', 'food_donut', 'curtain', 'kettle', 'shoes', 'dresser', 'cupboard', 'hairbrush', 'controller', 'home_office', 'light', 'clothes_skirt', 'soap']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <stereo>', '[SWITCHON] <stereo>']\n}\n", "input": "\nScene_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']\nTask:Bring dirty plate to sink\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'food_bread', 'juice', 'food_ice_cream', 'food_oatmeal', 'microwave', 'chair', 'freezer', 'walllamp', 'ground_coffee', 'milk', 'knifeblock', 'drawing', 'knife', 'floor', 'ceiling', 'stovefan', 'toaster', 'mat', 'faucet', 'ceilinglamp', 'bowl', 'wall', 'oven', 'bench', 'cup', 'coffe_maker', 'food_donut', 'tray', 'kitchen_counter', 'cupboard', 'sink', 'napkin', 'table', 'dishwasher']\nTask:Cook some food\nresponse:\n{\n    \"thoughts\": Put oatmeal into a bowl.  Add milk.  Heat in a microwave.  Put pod of coffee into a coffee maker.  Activate.  Pour juice into a glass.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <bowl>', '[GRAB] <bowl>', '[FIND] <food_oatmeal>', '[GRAB] <food_oatmeal>', '[PUTBACK] <food_oatmeal> <bowl>', '[GRAB] <food_oatmeal>', '[PUTOBJBACK] <food_oatmeal>', '[CLOSE] <cupboard>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <bowl>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>', '[FIND] <microwave>', '[OPEN] <microwave>', '[PUTIN] <bowl> <microwave>', '[CLOSE] <microwave>', '[SWITCHON] <microwave>', '[FIND] <ground_coffee>', '[GRAB] <ground_coffee>', '[FIND] <coffe_maker>', '[OPEN] <coffe_maker>', '[PUTBACK] <ground_coffee> <coffe_maker>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <juice>', '[GRAB] <juice>', '[POUR] <juice> <cup>', '[PUTOBJBACK] <juice>', '[CLOSE] <freezer>', '[FIND] <table>', '[PUTBACK] <cup> <table>']\n}\n", "input": "\nScene_Objects:['sponge', 'microwave', 'toilet', 'jelly', 'freezer', 'ground_coffee', 'food_carrot', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'button', 'mat', 'shower', 'picture', 'dustpan', 'food_orange', 'form', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'light_bulb', 'food_food', 'doorjamb', 'cd', 'door', 'light']\nTask:Added meat to freezer\nresponse:\n", "output": {"thoughts": "After shopping for groceries, i returned home, i walked to the dining room and placed meat items in freezer located in the dining room. I opened up the bags from the grocery store, removed all the meat items, and after opening the freezer door, i placed the meat items into the freezer, and closed the door.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>", "[GRAB] <food_food>", "[PUTBACK] <food_food> <freezer>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'walllamp', 'detergent', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'computer', 'mat', 'tvstand', 'faucet', 'stereo', 'picture', 'mousepad', 'couch', 'microphone', 'pillow', 'wall', 'photoframe', 'coffe_maker', 'television', 'doorjamb', 'lighter', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": go to living room and lie down on the sofa.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[LIE] <couch>']\n}\n", "input": "\nScene_Objects:['food_salt', 'toilet', 'dog', 'freezer', 'drawing', 'cpuscreen', 'phone', 'tea_bag', 'food_bacon', 'stovefan', 'mat', 'ceilinglamp', 'window', 'oil', 'food_orange', 'food_cheese', 'clothes_gloves', 'toilet_paper', 'food_food', 'television', 'coffee_filter', 'check', 'curtain', 'kettle', 'mouse', 'food_steak', 'spoon', 'instrument_guitar', 'light', 'dishwasher']\nTask:Walk to room\nresponse:\n", "output": {"thoughts": "Leave the living room and enter the hall", "actions": ["[WALK] <home_office>", "[WALK] <home_office>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'walllamp', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'shampoo', 'computer', 'mail', 'table_cloth', 'mat', 'tvstand', 'plate', 'couch', 'pillow', 'dining_room', 'food_kiwi', 'wall', 'nightstand', 'photoframe', 'check', 'television', 'curtain', 'after_shave', 'doorjamb', 'cards', 'mouse', 'shoes', 'sink']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": I walk to the living room. I sit in the sofa and I relax.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'beer', 'toilet', 'chair', 'freezer', 'walllamp', 'food_butter', 'drawing', 'orchid', 'floor', 'ceiling', 'mat', 'ceilinglamp', 'shower', 'mousepad', 'couch', 'pillow', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'food_food', 'television', 'food_onion', 'doorjamb', 'door', 'spoon', 'light']\nTask:Drink\nresponse:\n", "output": {"thoughts": "Get a can of beer, open it, sit on couch, relax", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <beer>", "[GRAB] <beer>", "[CLOSE] <freezer>", "[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[DRINK] <beer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'juice', 'toilet', 'walllamp', 'toothbrush', 'drawing', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'stamp', 'faucet', 'balanceball', 'clothes_pants', 'wall', 'powersocket', 'photoframe', 'novel', 'toothbrush_holder', 'television', 'food_donut', 'tray', 'towel_rack', 'cupboard', 'controller', 'sink', 'bathroom_cabinet', 'tooth_paste']\nTask:Wash teeth\nresponse:\n{\n    \"thoughts\": I go into the bathroom, go to the sink, get toothbrush and toothpaste. Put toothpaste on the toothbrush, brush teeth, turn on faucet, rinse brush, and return toothbrush.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <toothbrush_holder>', '[TURNTO] <toothbrush_holder>', '[LOOKAT] <toothbrush_holder>', '[FIND] <toothbrush>', '[GRAB] <toothbrush>', '[FIND] <tooth_paste>', '[GRAB] <tooth_paste>', '[PUTBACK] <tooth_paste> <toothbrush_holder>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <toothbrush>', '[PUTBACK] <toothbrush> <toothbrush_holder>']\n}\n", "input": "\nScene_Objects:['blender', 'toilet', 'chair', 'walllamp', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'ceiling', 'bedroom', 'bookshelf', 'food_bacon', 'table_cloth', 'toaster', 'laptop', 'ceilinglamp', 'floor_lamp', 'mousepad', 'couch', 'clothes_pants', 'towel', 'dining_room', 'basket_for_clothes', 'check', 'pencil', 'chessboard', 'food_steak', 'napkin', 'spoon', 'table']\nTask:Turn off light\nresponse:\n", "output": {"thoughts": "Walk to the lamp.  Find the switch.  Click the switch off.", "actions": ["[WALK] <bedroom>", "[WALK] <floor_lamp>", "[SWITCHOFF] <floor_lamp>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['freezer', 'bathroom', 'ceilingfan', 'food_carrot', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'food_bacon', 'toaster', 'ceilinglamp', 'tvstand', 'balanceball', 'stovefan', 'window', 'couch', 'food_orange', 'wall', 'powersocket', 'cutting_board', 'bed', 'novel', 'mouthwash', 'television', 'curtain', 'towel_rack', 'home_office', 'table', 'clothes_skirt']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": I come home and go to the sofa for turn off the tv and relax,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>']\n}\n", "input": "\nScene_Objects:['microwave', 'chair', 'walllamp', 'wallshelf', 'ceiling', 'phone', 'keyboard', 'thread', 'piano_bench', 'brush', 'mat', 'ceilinglamp', 'window', 'oil', 'closetdrawer', 'mousepad', 'food_peanut_butter', 'candle', 'nightstand', 'powersocket', 'newspaper', 'novel', 'television', 'doorjamb', 'kitchen_counter', 'comb', 'cupboard', 'home_office', 'table', 'instrument_violin']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "Twist the lamp switch until the light goes on.", "actions": ["[WALK] <home_office>", "[WALK] <floor_lamp>", "[FIND] <floor_lamp>", "[SWITCHON] <floor_lamp>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'toilet', 'bathroom', 'trashcan', 'ceilingfan', 'toothbrush', 'orchid', 'floor', 'phone', 'bookshelf', 'computer', 'toaster', 'shoe-shine_kit', 'mousepad', 'pillow', 'dining_room', 'box', 'basket_for_clothes', 'keys', 'razor', 'toothbrush_holder', 'coin', 'wine', 'doorjamb', 'cards', 'door', 'napkin', 'home_office', 'soap', 'tooth_paste']\nTask:Brush teeth\nresponse:\n{\n    \"thoughts\": today morning i went to bathroom and took my toothbrush and paste from tooth brush holder and brushed and cleaned my teeth well,\n    \"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>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'mop', 'microwave', 'detergent', 'food_butter', 'drawing', 'keyboard', 'bookshelf', 'computer', 'food_bacon', 'toaster', 'faucet', 'clothes_hat', 'oven', 'cutting_board', 'cup', 'check', 'coin', 'doorjamb', 'mouse', 'vacuum_cleaner', 'headset', 'chessboard', 'dresser', 'laundry_detergent', 'light', 'dishwasher', 'instrument_violin', 'dirt']\nTask:Vacuum\nresponse:\n", "output": {"thoughts": "Get the vacuum and use it to clean my floors", "actions": ["[WALK] <dresser>", "[OPEN] <dresser>", "[FIND] <vacuum_cleaner>", "[GRAB] <vacuum_cleaner>", "[WALK] <bedroom>", "[PLUGIN] <vacuum_cleaner>", "[SWITCHON] <vacuum_cleaner>", "[SWITCHOFF] <vacuum_cleaner>", "[PLUGOUT] <vacuum_cleaner>", "[WALK] <dresser>", "[CLOSE] <dresser>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'deck_of_cards', 'window', 'tvstand', 'mousepad', 'pillow', 'wall', 'pasta', 'light_bulb', 'check', 'mouthwash', 'wooden_spoon', 'mouse', 'door', 'table', 'coffee']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": Turn on computer, pull up browser, browse the internet,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']\n}\n", "input": "\nScene_Objects:['sponge', 'food_bread', 'toilet', 'bathroom', 'detergent', 'drawing', 'knifeblock', 'cpuscreen', 'floor', 'ceiling', 'bedroom', 'tea_bag', 'mail', 'ceilinglamp', 'shower', 'iron', 'closetdrawer', 'couch', 'towel', 'oven', 'coin', 'lighter', 'console', 'mouse', 'shoes', 'cd', 'dishrack', 'spoon', 'light', 'table']\nTask:Switch on lamp\nresponse:\n", "output": {"thoughts": "Press the button so the light comes on.", "actions": ["[WALK] <bedroom>", "[WALK] <floor_lamp>", "[FIND] <floor_lamp>", "[SWITCHON] <floor_lamp>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'microwave', 'band-aids', 'walllamp', 'blow_dryer', 'detergent', 'bathroom', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'bookshelf', 'stovefan', 'tvstand', 'faucet', 'stereo', 'pillow', 'dining_room', 'wall', 'nightstand', 'oven', 'clothes_gloves', 'water', 'kitchen_counter', 'cupboard', 'laundry_detergent', 'sink', 'napkin']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['chair', 'band-aids', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'cleaning_solution', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'mousepad', 'pillow', 'wall', 'nightstand', 'powersocket', 'bed', 'photoframe', 'novel', 'rag', 'doorjamb', 'centerpiece', 'mouse', 'kitchen_counter', 'dresser', 'door', 'food_steak', 'home_office', 'dishwasher']\nTask:Dust\nresponse:\n", "output": {"thoughts": "Gather wood cleaner and cleaning rag. Wipe baseboards and window sills with dry cloth, then spray with cleaner and buff", "actions": ["[WALK] <bedroom>", "[WALK] <cleaning_solution>", "[FIND] <cleaning_solution>", "[GRAB] <cleaning_solution>", "[FIND] <rag>", "[GRAB] <rag>", "[POUR] <cleaning_solution> <rag>", "[PUTOBJBACK] <cleaning_solution>", "[WALK] <wall>", "[WALK] <window>", "[PUTOBJBACK] <rag>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'ground_coffee', 'drawing', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'piano_bench', 'mat', 'ceilinglamp', 'tvstand', 'laptop', 'stereo', 'deck_of_cards', 'mousepad', 'dining_room', 'wall', 'nightstand', 'powersocket', 'television', 'food_rice', 'mouse', 'door', 'table', 'laser_pointer']\nTask:Work\nresponse:\n{\n    \"thoughts\": Go to the office and sit on the chair, then work on the computer,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'freezer', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'shampoo', 'ceiling', 'button', 'deck_of_cards', 'shower', 'clothes_pants', 'food_kiwi', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'doorjamb', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'spoon', 'home_office', 'light', 'clothes_skirt', 'dishwasher', 'coffee']\nTask:Grab things\nresponse:\n", "output": {"thoughts": "The robot will need some kind of hands or grabbing device to transport objects.", "actions": ["[WALK] <novel>", "[TURNTO] <novel>", "[GRAB] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['chair', 'walllamp', 'blow_dryer', 'orchid', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'brush', 'ceilinglamp', 'mat', 'laptop', 'mousepad', 'dining_room', 'wall', 'powersocket', 'food_food', 'oven_mitts', 'kettle', 'mouse', 'cd', 'door', 'hairdryer', 'napkin', 'sink', 'table', 'light']\nTask:Wash monitor\nresponse:\n{\n    \"thoughts\": Clean the grime off of my monitor screen when not in use,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHOFF] <computer>', '[FIND] <brush>', '[TURNTO] <brush>', '[LOOKAT] <brush>', '[GRAB] <brush>', '[WIPE] <computer>', '[DROP] <brush>', '[FIND] <napkin>', '[GRAB] <napkin>', '[WASH] <napkin>', '[WIPE] <computer>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'measuring_cup', 'chair', 'walllamp', 'bathroom', 'bills', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'alcohol', 'bookmark', 'toaster', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'check', 'television', 'tray', 'cupboard', 'instrument_violin', 'teeth']\nTask:Do homework\nresponse:\n", "output": {"thoughts": "Sit on the couch in the Living room and pick u some papers", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <check>", "[GRAB] <check>", "[DROP] <check>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['jelly', 'drawing', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'brush', 'stovefan', 'faucet', 'iron', 'couch', 'towel', 'wall', 'powersocket', 'cutting_board', 'photoframe', 'bed', 'television', 'lighter', 'console', 'dresser', 'pajamas', 'door', 'sink', 'bathroom_cabinet', 'table', 'clothes_skirt', 'vase', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": I go into the bathroom, get my hands wet, add soap, suds up my hands, rinse the soap off, turn the faucet off, dry my hands.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[FIND] <soap>', '[GRAB] <soap>', '[SCRUB] <soap>', '[PUTOBJBACK] <soap>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'scissors', 'crayon', 'toilet', 'jelly', 'walllamp', 'nail_polish', 'detergent', 'food_cake', 'alcohol', 'piano_bench', 'toaster', 'food_noodles', 'garbage_can', 'pillow', 'broom', 'oven', 'toy', 'food_vegetable', 'food_food', 'television', 'oven_mitts', 'doorjamb', 'pencil', 'headset', 'sink', 'bathroom_cabinet', 'table', 'dishwasher', 'pantry']\nTask:Organize pantry\nresponse:\n", "output": {"thoughts": "Remove all perishable foods from the pantry, check dates and throw away any old food. Decide on an efficient ad neat arrangement for the food and replace it in the pantry accordingly.", "actions": ["[WALK] <dining_room>", "[WALK] <pantry>", "[FIND] <food_food>", "[GRAB] <food_food>", "[TURNTO] <food_food>", "[LOOKAT] <food_food>", "[FIND] <garbage_can>", "[PUTBACK] <food_food> <garbage_can>", "[FIND] <food_vegetable>", "[GRAB] <food_vegetable>", "[TURNTO] <food_vegetable>", "[LOOKAT] <food_vegetable>", "[PUTBACK] <food_vegetable> <garbage_can>", "[FIND] <dry_pasta>", "[GRAB] <dry_pasta>", "[TURNTO] <dry_pasta>", "[LOOKAT] <dry_pasta>", "[PUTOBJBACK] <dry_pasta>", "[FIND] <food_food>", "[TURNTO] <food_food>", "[LOOKAT] <food_food>", "[PUSH] <food_food>", "[FIND] <food_noodles>", "[GRAB] <food_noodles>", "[TURNTO] <food_noodles>", "[LOOKAT] <food_noodles>", "[PUTOBJBACK] <food_noodles>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Watching tv with a remote is always fun; lay back, relax and enjoy;,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <bed>', '[LIE] <bed>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'mop', 'bathroom', 'dough', 'milk', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'cleaning_solution', 'keyboard', 'mat', 'faucet', 'window', 'food_noodles', 'closetdrawer', 'couch', 'clothes_pants', 'nightstand', 'tape', 'food_food', 'check', 'food_rice', 'wooden_spoon', 'rag', 'mouse', 'controller', 'door', 'home_office']\nTask:Clean mirror\nresponse:\n", "output": {"thoughts": "Spray the mirror with a cleaner, take a dry rag and wipe the mirror down until its clean.", "actions": ["[WALK] <bathroom>", "[WALK] <cleaning_solution>", "[FIND] <cleaning_solution>", "[GRAB] <cleaning_solution>", "[FIND] <rag>", "[GRAB] <rag>", "[POUR] <cleaning_solution> <rag>", "[PUTOBJBACK] <cleaning_solution>", "[WALK] <mirror>", "[WIPE] <mirror>", "[PUTOBJBACK] <rag>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'freezer', 'band-aids', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'stamp', 'desk', 'stovefan', 'shoe-shine_kit', 'couch', 'pillow', 'wall', 'bench', 'coffe_maker', 'toothbrush_holder', 'television', 'curtain', 'doorjamb', 'shaving_cream', 'cupboard', 'door', 'sink', 'bathtub', 'instrument_guitar', 'light', 'home_office', 'clothes_skirt']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": I walk to room. I enter room. I find where the lightswitch is. I turn on the lights with the lightswitch.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[TURNTO] <light>', '[LOOKAT] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['chair', 'walllamp', 'bathroom', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'food_bacon', 'bookmark', 'mat', 'ceilinglamp', 'tvstand', 'deck_of_cards', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'nightstand', 'cup', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'door', 'light', 'table']\nTask:Vacuum\nresponse:\n", "output": {"thoughts": "Keep my keyboard vacuumed and free of debris.", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <vacuum_cleaner>", "[SWITCHON] <vacuum_cleaner>", "[SWITCHOFF] <vacuum_cleaner>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'food_salt', 'crayon', 'chair', 'freezer', 'detergent', 'food_butter', 'drawing', 'knife', 'hanger', 'floor', 'character', 'piano_bench', 'toaster', 'clothes_socks', 'food_peanut_butter', 'pillow', 'food_kiwi', 'coffe_maker', 'food_donut', 'tray', 'curtain', 'shaving_cream', 'mouse', 'kitchen_counter', 'dishrack', 'hair', 'door', 'hairdryer', 'napkin']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": Turning on lights,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[SWITCHON] <floor_lamp>']\n}\n", "input": "\nScene_Objects:['sheets', 'orchid', 'cpuscreen', 'clothes_underwear', 'bathroom_counter', 'phone', 'cleaning_solution', 'button', 'ceilinglamp', 'mat', 'shoe-shine_kit', 'food_orange', 'pillow', 'dining_room', 'food_kiwi', 'cup', 'food_cheese', 'bed', 'clothes_gloves', 'coffe_maker', 'toilet_paper', 'oven_mitts', 'curtain', 'rag', 'console', 'pencil', 'dresser', 'clothes_scarf', 'light', 'colander']\nTask:Clean\nresponse:\n", "output": {"thoughts": "Spray counter tops with all purpose cleaner. Using towel, wipe counter, removing all dirt and grime until clean.", "actions": ["[WALK] <dining_room>", "[WALK] <cleaning_solution>", "[FIND] <cleaning_solution>", "[GRAB] <cleaning_solution>", "[PUTOBJBACK] <cleaning_solution>", "[FIND] <rag>", "[GRAB] <rag>", "[PUTOBJBACK] <rag>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'mop', 'band-aids', 'drawing', 'food_egg', 'bathroom_counter', 'floor', 'phone', 'cleaning_solution', 'bookshelf', 'computer', 'stereo', 'oil', 'mousepad', 'wall', 'wall_clock', 'nightstand', 'shelf', 'newspaper', 'food_food', 'video_game_controller', 'coin', 'rag', 'mouse', 'pencil', 'bathtub', 'bathroom_cabinet', 'light', 'coffee', 'creditcard']\nTask:Clean  mirror\nresponse:\n{\n    \"thoughts\": GET CLEANING CLOTH, SPRAY CLEANER ON CLOTH, CLEAN MIRROR,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <cleaning_solution>', '[FIND] <cleaning_solution>', '[GRAB] <cleaning_solution>', '[FIND] <rag>', '[GRAB] <rag>', '[POUR] <cleaning_solution> <rag>', '[PUTOBJBACK] <cleaning_solution>', '[WALK] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[WIPE] <mirror>', '[PUTOBJBACK] <rag>']\n}\n", "input": "\nScene_Objects:['sponge', 'pot', 'blender', 'beer', 'microwave', 'knifeblock', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'table_cloth', 'toaster', 'plate', 'faucet', 'tvstand', 'window', 'dish_soap', 'food_orange', 'wall', 'cup', 'bed', 'food_food', 'tray', 'wooden_spoon', 'mouse', 'pencil', 'kitchen_counter', 'dishrack', 'cupboard', 'sink']\nTask:Wash dirty dishes\nresponse:\n", "output": {"thoughts": "Wet the sponge, apply soap to sponge, scrub dishes, rinse dishes, place on dish rack.", "actions": ["[WALK] <dining_room>", "[WALK] <sink>", "[FIND] <sponge>", "[GRAB] <sponge>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[PUTBACK] <sponge> <sink>", "[GRAB] <sponge>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[POUR] <dish_soap> <sponge>", "[PUTOBJBACK] <dish_soap>", "[FIND] <plate>", "[GRAB] <plate>", "[SCRUB] <plate>", "[RINSE] <plate>", "[FIND] <dishrack>", "[PUTBACK] <plate> <dishrack>", "[FIND] <plate>", "[GRAB] <plate>", "[SCRUB] <plate>", "[RINSE] <plate>", "[PUTBACK] <plate> <dishrack>", "[RINSE] <sponge>", "[PUTOBJBACK] <sponge>", "[SWITCHOFF] <faucet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_salt', 'microwave', 'walllamp', 'bathroom', 'wallshelf', 'clothes_underwear', 'floor', 'ceiling', 'phone', 'computer', 'tvstand', 'shoe-shine_kit', 'faucet', 'window', 'mousepad', 'couch', 'wall', 'oven', 'newspaper', 'coffe_maker', 'food_food', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'clothes_dress', 'door', 'sink', 'bathroom_cabinet', 'light']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": Walk to living room. Go near telephone. take the receiver and then talk to other person on that side.,\n    \"actions\": ['[WALK] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'ground_coffee', 'wallshelf', 'hanger', 'floor', 'stamp', 'desk', 'bookshelf', 'tea_bag', 'envelope', 'computer', 'mop_bucket', 'mat', 'shower', 'foundation', 'form', 'wall', 'powersocket', 'cutting_board', 'photoframe', 'novel', 'check', 'television', 'wooden_spoon', 'after_shave', 'doorjamb', 'door', 'light']\nTask:Read to child\nresponse:\n", "output": {"thoughts": "Read a book out loud to a child", "actions": ["[WALK] <bedroom>", "[WALK] <child>", "[FIND] <child>", "[GREET] <child>", "[WALK] <filing_cabinet>", "[OPEN] <filing_cabinet>", "[FIND] <novel>", "[GRAB] <novel>", "[WALK] <chair>", "[PULL] <chair>", "[SIT] <chair>", "[TURNTO] <novel>", "[LOOKAT] <novel>", "[TURNTO] <novel>", "[POINTAT] <novel>", "[TURNTO] <novel>", "[POINTAT] <novel>", "[READ] <novel>", "[READ] <novel>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Check email\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'food_ice_cream', 'chair', 'nail_polish', 'bathroom', 'cat', 'dough', 'toothbrush', 'desk', 'button', 'stovefan', 'shower', 'faucet', 'window', 'pillow', 'nightstand', 'wall_clock', 'oven', 'cutting_board', 'novel', 'check', 'television', 'toothbrush_holder', 'lighter', 'kettle', 'chessboard', 'dresser', 'sink', 'home_office', 'clothes_skirt']\nTask:Keep cats out of room\nresponse:\n", "output": {"thoughts": "Stand in the doorway and create a loud noise so the cats will stay out.", "actions": ["[WALK] <bedroom>", "[WALK] <cat>", "[FIND] <cat>", "[TURNTO] <cat>", "[LOOKAT] <cat>", "[FIND] <cat>", "[TURNTO] <cat>", "[LOOKAT] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'tablelamp', 'tea', 'trashcan', 'drawing', 'orchid', 'floor', 'character', 'desk', 'bookshelf', 'computer', 'toaster', 'mat', 'stovefan', 'tvstand', 'window', 'mousepad', 'couch', 'wall', 'nightstand', 'wall_clock', 'cup', 'bed', 'food_donut', 'curtain', 'towel_rack', 'sink', 'napkin', 'bathtub']\nTask:Go to sleep\nresponse:\n{\n    \"thoughts\": Enter bedroom, turn on the light, and shut door. Change into night clothes. Turn off light. Turn down comforter, climb into bed, lay head on pillow, and cover up with comforter. Close eyes and drift off to sleep.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <bed>', '[FIND] <bed>', '[LIE] <bed>', '[FIND] <sheets>', '[PULL] <sheets>']\n}\n", "input": "\nScene_Objects:['spectacles', 'sheets', 'filing_cabinet', 'food_salt', 'toilet', 'band-aids', 'walllamp', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'phone', 'computer', 'mop_bucket', 'stovefan', 'tvstand', 'deck_of_cards', 'closetdrawer', 'newspaper', 'coffe_maker', 'doorjamb', 'dresser', 'cupboard', 'door', 'food_steak', 'bag', 'sink', 'table', 'dishwasher', 'bathroom_cabinet']\nTask:Put umbrella away\nresponse:\n", "output": {"thoughts": "Place the umbrella in the umbrella bucket point first.", "actions": ["[WALK] <home_office>", "[WALK] <mop_bucket>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'food_ice_cream', 'microwave', 'walllamp', 'bathroom', 'cat', 'trashcan', 'knifeblock', 'hanger', 'floor', 'faucet', 'shower', 'clothes_hat', 'wall', 'nightstand', 'tape', 'cup', 'food_food', 'water', 'tray', 'diary', 'pencil', 'kitchen_counter', 'headset', 'hairbrush', 'cupboard', 'hair', 'sink', 'instrument_guitar', 'soap']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Walk to kitchen, grab a glass, walk to sink, turn on tap and pour water into glass, drink from glass.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <sink>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'microwave', 'chair', 'walllamp', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'window', 'oil', 'mousepad', 'couch', 'closetdrawer', 'food_jam', 'pillow', 'towel', 'dining_room', 'bowl', 'wall', 'nightstand', 'pasta', 'clothes_gloves', 'food_food', 'television', 'tray', 'hairbrush', 'clothes_dress']\nTask:Read book\nresponse:\n", "output": {"thoughts": "Sit on a couch, grab a book, open it, and scan the pages", "actions": ["[WALK] <home_office>", "[WALK] <novel>", "[FIND] <novel>", "[GRAB] <novel>", "[WALK] <couch>", "[SIT] <couch>", "[TURNTO] <novel>", "[LOOKAT] <novel>", "[READ] <novel>", "[READ] <novel>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'detergent', 'cat', 'drawing', 'orchid', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'desk', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'wall_clock', 'television', 'tray', 'curtain', 'towel_rack', 'kitchen_counter', 'cupboard', 'table', 'light']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": I see my cat on the couch so I walk over, sit down and pet the cat.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TURNTO] <cat>', '[LOOKAT] <cat>', '[FIND] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['food_ice_cream', 'tea', 'freezer', 'walllamp', 'orchid', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'folder', 'laptop', 'tvstand', 'ceilinglamp', 'faucet', 'window', 'closetdrawer', 'towel', 'wall', 'box', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'vacuum_cleaner', 'dresser', 'door', 'clothes_scarf', 'light', 'creditcard']\nTask:Sweep hallway please\nresponse:\n", "output": {"thoughts": "Vacuum all the way up and down the hallway.  Get all the dirt and crumbs out of carpet please.", "actions": ["[WALK] <home_office>", "[WALK] <dresser>", "[OPEN] <dresser>", "[FIND] <vacuum_cleaner>", "[GRAB] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PLUGIN] <vacuum_cleaner>", "[SWITCHON] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PUSH] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PUSH] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PUSH] <vacuum_cleaner>", "[SWITCHOFF] <vacuum_cleaner>", "[PLUGOUT] <vacuum_cleaner>", "[WALK] <dresser>", "[PUTIN] <vacuum_cleaner> <dresser>", "[CLOSE] <dresser>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['beer', 'microwave', 'dog', 'chair', 'cat', 'knifeblock', 'hanger', 'bathroom_counter', 'floor', 'phone', 'character', 'keyboard', 'clothes_jacket', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'closetdrawer', 'oven', 'food_cheese', 'novel', 'toothbrush_holder', 'television', 'food_donut', 'console', 'controller', 'clothes_scarf', 'light', 'colander', 'board_game', 'creditcard']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": I walk to my cat, and I pet him,\n    \"actions\": ['[WALK] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'band-aids', 'drawing', 'floor', 'ceiling', 'desk', 'bookshelf', 'envelope', 'button', 'toaster', 'mat', 'clothes_hat', 'wall', 'powersocket', 'oven', 'toy', 'novel', 'toothbrush_holder', 'after_shave', 'doorjamb', 'pencil', 'door', 'light', 'table', 'dishwasher', 'colander']\nTask:Put toys away\nresponse:\n", "output": {"thoughts": "Pick up all the toys on the floor and put them in their correct storage bin or shelf.", "actions": ["[WALK] <bedroom>", "[WALK] <toy>", "[FIND] <toy>", "[GRAB] <toy>", "[WALK] <filing_cabinet>", "[OPEN] <filing_cabinet>", "[PUTBACK] <toy> <filing_cabinet>", "[FIND] <toy>", "[GRAB] <toy>", "[WALK] <filing_cabinet>", "[PUTBACK] <toy> <filing_cabinet>", "[FIND] <toy>", "[GRAB] <toy>", "[WALK] <filing_cabinet>", "[PUTBACK] <toy> <filing_cabinet>", "[CLOSE] <filing_cabinet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['blow_dryer', 'trashcan', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookmark', 'toaster', 'stovefan', 'tvstand', 'food_jam', 'pillow', 'dining_room', 'bowl', 'wall', 'powersocket', 'clothes_gloves', 'novel', 'coffe_maker', 'coffee_filter', 'tray', 'after_shave', 'curtain', 'cd', 'chessboard', 'cupboard', 'sink', 'dishwasher', 'scrabble', 'coffee']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Enter kitchen, find coffee maker, find coffee filter, pick up coffee filter, put it in coffee maker, find coffee, pour coffee into filter, turn on.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[FIND] <coffee_filter>', '[GRAB] <coffee_filter>', '[OPEN] <coffe_maker>', '[PUTBACK] <coffee_filter> <coffe_maker>', '[WALK] <coffee>', '[FIND] <coffee>', '[GRAB] <coffee>', '[POUR] <coffee> <coffe_maker>', '[SWITCHON] <coffe_maker>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'measuring_cup', 'microwave', 'milk', 'knifeblock', 'bills', 'wallshelf', 'bathroom_counter', 'ceiling', 'phone', 'bedroom', 'keyboard', 'stovefan', 'laptop', 'shoe-shine_kit', 'shower', 'candle', 'clothes_hat', 'towel', 'dining_room', 'wall_clock', 'powersocket', 'newspaper', 'doorjamb', 'shaving_cream', 'vacuum_cleaner', 'dishrack', 'dishwasher', 'instrument_violin', 'creditcard']\nTask:Vacuum\nresponse:\n", "output": {"thoughts": "Robot has a vacuum underneath its feat/body that will allow it to clean the surface of the floor.", "actions": ["[WALK] <home_office>", "[WALK] <filing_cabinet>", "[OPEN] <filing_cabinet>", "[FIND] <vacuum_cleaner>", "[GRAB] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PLUGIN] <vacuum_cleaner>", "[SWITCHON] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PUSH] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PUSH] <vacuum_cleaner>", "[WALK] <dining_room>", "[PULL] <vacuum_cleaner>", "[PUSH] <vacuum_cleaner>", "[PULL] <vacuum_cleaner>", "[PUSH] <vacuum_cleaner>", "[WALK] <home_office>", "[SWITCHOFF] <vacuum_cleaner>", "[PLUGOUT] <vacuum_cleaner>", "[WALK] <filing_cabinet>", "[PUTBACK] <vacuum_cleaner> <filing_cabinet>", "[CLOSE] <filing_cabinet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'spectacles', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'bedroom', 'remote_control', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'form', 'pillow', 'wall', 'oven', 'box', 'newspaper', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'pencil', 'cupboard', 'maindoor', 'table', 'dishwasher']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": Walk to living room. Walk to and sit at the sofa. Grab remote control and switch on TV.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>']\n}\n", "input": "\nScene_Objects:['food_bread', 'beer', 'toilet', 'chair', 'freezer', 'food_butter', 'food_carrot', 'milk', 'drawing', 'floor', 'ceiling', 'toaster', 'mat', 'shower', 'mousepad', 'garbage_can', 'food_dessert', 'wall', 'nightstand', 'powersocket', 'oven', 'food_vegetable', 'food_cheese', 'photoframe', 'food_food', 'food_onion', 'doorjamb', 'laundry_detergent', 'door', 'light']\nTask:Rotate stock in refrigerator\nresponse:\n", "output": {"thoughts": "Throw out expired items, put older items in front.", "actions": ["[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <food_bread>", "[GRAB] <food_bread>", "[TURNTO] <food_bread>", "[LOOKAT] <food_bread>", "[PUTOBJBACK] <food_bread>", "[FIND] <food_cheese>", "[GRAB] <food_cheese>", "[TURNTO] <food_cheese>", "[LOOKAT] <food_cheese>", "[FIND] <garbage_can>", "[PUTBACK] <food_cheese> <garbage_can>", "[FIND] <food_cheese>", "[GRAB] <food_cheese>", "[TURNTO] <food_cheese>", "[LOOKAT] <food_cheese>", "[PUTOBJBACK] <food_cheese>", "[FIND] <food_dessert>", "[TURNTO] <food_dessert>", "[LOOKAT] <food_dessert>", "[PUSH] <food_dessert>", "[FIND] <food_vegetable>", "[GRAB] <food_vegetable>", "[TURNTO] <food_vegetable>", "[LOOKAT] <food_vegetable>", "[PUTBACK] <food_vegetable> <garbage_can>", "[FIND] <milk>", "[GRAB] <milk>", "[TURNTO] <milk>", "[LOOKAT] <milk>", "[PUTOBJBACK] <milk>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'walllamp', 'trashcan', 'milk', 'knifeblock', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'toaster', 'stovefan', 'faucet', 'mousepad', 'couch', 'wall', 'pasta', 'oven', 'box', 'food_food', 'water', 'tray', 'pencil', 'kitchen_counter', 'sauce_pan', 'cupboard', 'instrument_guitar', 'bathroom_cabinet']\nTask:Cook some food\nresponse:\n{\n    \"thoughts\": Cook some pasta on the stove,\n    \"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>']\n}\n", "input": "\nScene_Objects:['chair', 'ground_coffee', 'nail_polish', 'orchid', 'hanger', 'floor', 'ceiling', 'dvd_player', 'character', 'keyboard', 'food_cake', 'bookshelf', 'mail', 'toaster', 'plate', 'homework', 'pillow', 'dining_room', 'wall', 'bed', 'coffe_maker', 'coffee_filter', 'water', 'tray', 'curtain', 'kitchen_counter', 'cupboard', 'bathroom_cabinet', 'light', 'dishwasher']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Open coffee maker. Put filter in main basket, put ground coffee in filter, fill reservoir with water, turn on coffee maker.", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[OPEN] <coffe_maker>", "[FIND] <coffee_filter>", "[GRAB] <coffee_filter>", "[PUTBACK] <coffee_filter> <coffe_maker>", "[FIND] <ground_coffee>", "[GRAB] <ground_coffee>", "[PUTBACK] <ground_coffee> <coffe_maker>", "[GRAB] <ground_coffee>", "[PUTOBJBACK] <ground_coffee>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[POUR] <water> <coffe_maker>", "[CLOSE] <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'chair', 'walllamp', 'knifeblock', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'alcohol', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'iron', 'faucet', 'mousepad', 'bowl', 'wall', 'nightstand', 'oven', 'mouse', 'cupboard', 'door', 'clothes_scarf', 'bathroom_cabinet', 'table', 'instrument_guitar']\nTask:Work\nresponse:\n{\n    \"thoughts\": For doing homework walk to home office. Walk to computer. Switch on Computer. Sit in a chair and do homework in computer.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>']\n}\n", "input": "\nScene_Objects:['pot', 'juice', 'food_ice_cream', 'beer', 'food_oatmeal', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'ground_coffee', 'blow_dryer', 'food_carrot', 'dough', 'milk', 'drawing', 'floor', 'ceiling', 'phone', 'stovefan', 'mat', 'ceilinglamp', 'shower', 'faucet', 'bowl', 'wall', 'nightstand', 'oven', 'powersocket', 'cup', 'photoframe', 'coffe_maker', 'food_food', 'check', 'oven_mitts', 'tray', 'doorjamb', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'napkin', 'light', 'dishwasher', 'table']\nTask:Cook some food\nresponse:\n", "output": {"thoughts": "Put oatmeal into a bowl.  Add milk.  Heat in a microwave.  Put pod of coffee into a coffee maker.  Activate.  Pour juice into a glass.", "actions": ["[WALK] <dining_room>", "[WALK] <cupboard>", "[FIND] <cupboard>", "[OPEN] <cupboard>", "[FIND] <bowl>", "[GRAB] <bowl>", "[FIND] <food_oatmeal>", "[GRAB] <food_oatmeal>", "[PUTBACK] <food_oatmeal> <bowl>", "[GRAB] <food_oatmeal>", "[PUTOBJBACK] <food_oatmeal>", "[CLOSE] <cupboard>", "[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <milk>", "[GRAB] <milk>", "[POUR] <milk> <bowl>", "[PUTOBJBACK] <milk>", "[CLOSE] <freezer>", "[FIND] <microwave>", "[OPEN] <microwave>", "[PUTIN] <bowl> <microwave>", "[CLOSE] <microwave>", "[SWITCHON] <microwave>", "[FIND] <ground_coffee>", "[GRAB] <ground_coffee>", "[FIND] <coffe_maker>", "[OPEN] <coffe_maker>", "[PUTBACK] <ground_coffee> <coffe_maker>", "[CLOSE] <coffe_maker>", "[SWITCHON] <coffe_maker>", "[FIND] <cup>", "[GRAB] <cup>", "[WALK] <freezer>", "[OPEN] <freezer>", "[FIND] <juice>", "[GRAB] <juice>", "[POUR] <juice> <cup>", "[PUTOBJBACK] <juice>", "[CLOSE] <freezer>", "[FIND] <table>", "[PUTBACK] <cup> <table>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'tvstand', 'faucet', 'mousepad', 'closetdrawer', 'couch', 'food_jam', 'wall', 'nightstand', 'oven', 'newspaper', 'food_food', 'vacuum_cleaner', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": I go to the bathroom, walk to the sink, turn on the faucet and then wash my hands under the water.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <faucet>', '[TURNTO] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'food_salt', 'chair', 'bathroom', 'orchid', 'cpuscreen', 'bathroom_counter', 'desk', 'keyboard', 'button', 'piano_bench', 'ceilinglamp', 'stereo', 'floor_lamp', 'oil', 'mousepad', 'closetdrawer', 'tape', 'love_seat', 'newspaper', 'bed', 'check', 'video_game_controller', 'mouthwash', 'curtain', 'lighter', 'diary', 'doorjamb', 'dresser', 'sink']\nTask:Read\nresponse:\n", "output": {"thoughts": "Sit on an easy chair.  Turn on music.  Take a book and read.  Turn on lamp at night.", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>", "[FIND] <newspaper>", "[GRAB] <newspaper>", "[FIND] <love_seat>", "[SIT] <love_seat>", "[FIND] <floor_lamp>", "[SWITCHON] <floor_lamp>", "[READ] <newspaper>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'tablelamp', 'chair', 'freezer', 'cat', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'stereo', 'faucet', 'picture', 'mousepad', 'couch', 'wall', 'nightstand', 'powersocket', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'home_office', 'light']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": I go to the bedroom and sit at my desk. I turn my radio on and listen to music.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <desk>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <stereo>', '[SWITCHON] <stereo>']\n}\n", "input": "\nScene_Objects:['blender', 'milk', 'drawing', 'orchid', 'needle', 'hanger', 'bathroom_counter', 'floor', 'phone', 'computer', 'bookmark', 'toaster', 'mat', 'tvstand', 'electric_shaver', 'clothes_socks', 'closetdrawer', 'couch', 'nightstand', 'wall', 'bed', 'keys', 'photoframe', 'tray', 'centerpiece', 'dresser', 'bag', 'soap', 'clothes_shirt', 'teeth']\nTask:Read book\nresponse:\n", "output": {"thoughts": "Climb into bed, then read the novel", "actions": ["[WALK] <bedroom>", "[WALK] <novel>", "[FIND] <novel>", "[GRAB] <novel>", "[WALK] <bed>", "[LIE] <bed>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'stovefan', 'plate', 'shower', 'picture', 'faucet', 'dish_soap', 'pillow', 'wall', 'powersocket', 'cutting_board', 'tape', 'cup', 'coffe_maker', 'food_food', 'television', 'lighter', 'centerpiece', 'mouse', 'kitchen_counter', 'chessboard', 'dresser', 'cupboard', 'bathroom_cabinet', 'table', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": I go to the kitchen and open the dishwasher. I fill it up with dirty dishes and glasses. Then I put dish soap in the dishwasher, close it and turn it on.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['food_bread', 'filing_cabinet', 'toilet', 'freezer', 'dough', 'drawing', 'hanger', 'floor', 'ceiling', 'mat', 'shoe-shine_kit', 'shower', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'powersocket', 'wall_clock', 'photoframe', 'light_bulb', 'food_food', 'coffe_maker', 'razor', 'coffee_filter', 'doorjamb', 'hairbrush', 'door', 'home_office', 'light', 'soap']\nTask:Put away groceries\nresponse:\n", "output": {"thoughts": "Place groceries in refrigerator from shopping at the grocery store.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>", "[GRAB] <food_food>", "[PUTIN] <food_food> <freezer>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'pot', 'tablelamp', 'microwave', 'chair', 'freezer', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'toaster', 'mat', 'ceilinglamp', 'faucet', 'stovefan', 'shower', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'cup', 'coffe_maker', 'tray', 'doorjamb', 'coffee_pot', 'towel_rack', 'kitchen_counter', 'cupboard', 'door', 'sink', 'table', 'dishwasher', 'light']\nTask:Wipe down counter\nresponse:\n{\n    \"thoughts\": Clean counter,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <rag>', '[FIND] <rag>', '[GRAB] <rag>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <rag>', '[SQUEEZE] <rag>', '[SWITCHOFF] <faucet>', '[WALK] <kitchen_counter>', '[WIPE] <kitchen_counter>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'tablelamp', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'remote_control', 'envelope', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'pasta', 'oven', 'love_seat', 'television', 'razor', 'curtain', 'dresser', 'cupboard', 'bathroom_cabinet', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "Sit and watch the television", "actions": ["[WALK] <home_office>", "[WALK] <remote_control>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <love_seat>", "[SIT] <love_seat>", "[FIND] <television>", "[SWITCHON] <television>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'tablelamp', 'blender', 'tea', 'chair', 'freezer', 'drawing', 'orchid', 'hanger', 'floor', 'shampoo', 'stamp', 'bedroom', 'desk', 'computer', 'mat', 'stereo', 'mousepad', 'food_jam', 'dining_room', 'wall', 'wall_clock', 'bench', 'photoframe', 'food_food', 'dresser', 'napkin', 'home_office', 'table', 'spoon']\nTask:Eat dinner\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'food_salt', 'chair', 'bathroom', 'drawing', 'food_egg', 'floor', 'desk', 'bookshelf', 'computer', 'mat', 'stereo', 'shower', 'couch', 'food_peanut_butter', 'wall', 'powersocket', 'oven', 'cup', 'doorjamb', 'mouse', 'kitchen_counter', 'pajamas', 'controller', 'door', 'clothes_scarf', 'light', 'dishwasher', 'board_game']\nTask:Pull up carpet\nresponse:\n", "output": {"thoughts": "Pry up a corner of your old dirty carpet.  Tug as hard as you can until it comes off the tacs. Pull up the pad. Try not to be sick at all the dirt.", "actions": ["[WALK] <home_office>", "[WALK] <mat>", "[FIND] <mat>", "[TOUCH] <mat>", "[PULL] <mat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'toilet', 'freezer', 'food_carrot', 'drawing', 'hanger', 'floor', 'ceiling', 'shampoo', 'stovefan', 'mat', 'shower', 'window', 'nightstand', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'newspaper', 'food_food', 'drinking_glass', 'water', 'curtain', 'doorjamb', 'dresser', 'food_steak', 'door', 'home_office', 'light']\nTask:Drink\nresponse:\n{\n    \"thoughts\": im feeling thirsty im going to kitchen and open the freezer where i can find some cold water and im going to drink it to end up my thirst,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <drinking_glass>', '[DRINK] <drinking_glass>']\n}\n", "input": "\nScene_Objects:['spectacles', 'pot', 'scissors', 'microwave', 'chair', 'walllamp', 'knifeblock', 'food_egg', 'hanger', 'floor', 'ceiling', 'phone', 'keyboard', 'toaster', 'plate', 'faucet', 'clothes_socks', 'food_kiwi', 'wall', 'powersocket', 'clothes_gloves', 'coffe_maker', 'after_shave', 'mouse', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'bathroom_cabinet', 'dishwasher']\nTask:Do dishes\nresponse:\n", "output": {"thoughts": "Turn on water, rinse off dishes, put in dishwasher.", "actions": ["[WALK] <dining_room>", "[WALK] <sink>", "[FIND] <sink>", "[TURNTO] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <plate>", "[GRAB] <plate>", "[RINSE] <plate>", "[SWITCHOFF] <faucet>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[PUTBACK] <plate> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'food_salt', 'microwave', 'ceilingfan', 'orchid', 'bathroom_counter', 'bookshelf', 'purse', 'stovefan', 'mat', 'iron', 'electric_shaver', 'food_noodles', 'mousepad', 'couch', 'clothes_pants', 'pillow', 'powersocket', 'keys', 'coffe_maker', 'oven_mitts', 'wine', 'shaving_cream', 'pencil', 'kitchen_counter', 'vacuum_cleaner', 'dresser', 'home_office', 'light', 'tooth_paste']\nTask:Hang up car keys\nresponse:\n{\n    \"thoughts\": Open the front door. Enter the entrance hall. Take out car keys from purse. Hang car keys up on hook on the wall.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <purse>', '[FIND] <purse>', '[OPEN] <purse>', '[FIND] <keys>', '[GRAB] <keys>', '[CLOSE] <purse>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'microwave', 'jelly', 'chair', 'detergent', 'food_butter', 'knifeblock', 'wallshelf', 'kitchen_cabinet', 'floor', 'ceiling', 'button', 'toaster', 'mat', 'plate', 'faucet', 'stereo', 'pillow', 'wall', 'powersocket', 'cup', 'food_food', 'diary', 'pencil', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'light']\nTask:Get glass of water\nresponse:\n", "output": {"thoughts": "Get a glass from a cabinet. Hold it under the sink and turn the cold water on. Fill the glass. Turn off the water.", "actions": ["[WALK] <dining_room>", "[WALK] <kitchen_cabinet>", "[FIND] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[FIND] <cup>", "[GRAB] <cup>", "[CLOSE] <kitchen_cabinet>", "[WALK] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[PUTBACK] <cup> <sink>", "[GRAB] <cup>", "[SWITCHOFF] <faucet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'toaster', 'deck_of_cards', 'window', 'tvstand', 'mousepad', 'pillow', 'wall', 'pasta', 'light_bulb', 'check', 'mouthwash', 'wooden_spoon', 'mouse', 'door', 'table', 'coffee']\nTask:Browse internet\nresponse:\n{\n    \"thoughts\": Turn on computer, pull up browser, browse the internet,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>']\n}\n", "input": "\nScene_Objects:['fork', 'chair', 'freezer', 'knife', 'drawing', 'needle', 'wallshelf', 'floor', 'phone', 'ceiling', 'dvd_player', 'food_bacon', 'ceilinglamp', 'laptop', 'plate', 'shower', 'tvstand', 'tooth_paste', 'wall', 'tape', 'cup', 'novel', 'food_food', 'television', 'coffee_filter', 'hair', 'cupboard', 'table', 'board_game', 'clothes_shirt']\nTask:Eat\nresponse:\n", "output": {"thoughts": "I get my prepared dinner set on the dining table, sit down on chair, pick up utensils, eat food", "actions": ["[WALK] <dining_room>", "[WALK] <food_food>", "[FIND] <food_food>", "[GRAB] <food_food>", "[WALK] <dining_room>", "[WALK] <table>", "[FIND] <table>", "[PUTBACK] <food_food> <table>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <fork>", "[GRAB] <fork>", "[FIND] <knife>", "[GRAB] <knife>", "[FIND] <plate>", "[EAT] <plate>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'mop', 'toilet', 'ceilingfan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'character', 'video_game_console', 'food_cake', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'stereo', 'window', 'couch', 'wall', 'powersocket', 'tape', 'cup', 'video_game_controller', 'television', 'mouthwash', 'curtain', 'hairdryer', 'table', 'coffee']\nTask:Play games\nresponse:\n{\n    \"thoughts\": Turn on the television. Turn on the video game system. Insert desired game into gaming system. Follow directions on game to and push needed buttons on video  game remote controller.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[FIND] <button>', '[PUSH] <button>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['pot', 'food_bread', 'beer', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'toaster', 'mat', 'stovefan', 'shower', 'faucet', 'food_orange', 'nightstand', 'wall', 'powersocket', 'oven', 'photoframe', 'coffe_maker', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']\nTask:Make toast\nresponse:\n", "output": {"thoughts": "Place slices of bread in a toaster ,wait for the bread to pop up .Set aside.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_bread>", "[GRAB] <food_bread>", "[CLOSE] <freezer>", "[FIND] <toaster>", "[PLUGIN] <toaster>", "[PUTBACK] <food_bread> <toaster>", "[SWITCHON] <toaster>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'microwave', 'dog', 'bathroom', 'drawing', 'orchid', 'wallshelf', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'toaster', 'mat', 'faucet', 'shower', 'couch', 'wall', 'powersocket', 'newspaper', 'keys', 'wooden_spoon', 'doorjamb', 'centerpiece', 'kitchen_counter', 'door', 'home_office', 'light', 'shoe_rack']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": Switch on light in home office,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[PLUGIN] <light>', '[SWITCHON] <light>', '[WALK] <home_office>']\n}\n", "input": "\nScene_Objects:['pot', 'juice', 'microwave', 'freezer', 'blow_dryer', 'ground_coffee', 'cat', 'floor', 'legs_both', 'face', 'toaster', 'laptop', 'homework', 'closetdrawer', 'towel', 'feet_both', 'arms_both', 'basket_for_clothes', 'newspaper', 'photoframe', 'coffe_maker', 'mouthwash', 'centerpiece', 'doorjamb', 'headset', 'dresser', 'cupboard', 'napkin', 'soap', 'clothes_shirt']\nTask:Try yourself off\nresponse:\n", "output": {"thoughts": "After your shower, go into your bedroom and use a towel to dry water off of yourself before dressing.", "actions": ["[WALK] <bedroom>", "[WALK] <dresser>", "[FIND] <dresser>", "[OPEN] <dresser>", "[FIND] <towel>", "[GRAB] <towel>", "[CLOSE] <dresser>", "[FIND] <face>", "[WIPE] <face>", "[FIND] <arms_both>", "[WIPE] <arms_both>", "[FIND] <legs_both>", "[WIPE] <legs_both>", "[FIND] <feet_both>", "[WIPE] <feet_both>", "[FIND] <basket_for_clothes>", "[PUTBACK] <towel> <basket_for_clothes>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'freezer', 'ground_coffee', 'detergent', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'stovefan', 'toaster', 'faucet', 'shower', 'closetdrawer', 'candle', 'dining_room', 'wall', 'oven', 'photoframe', 'bed', 'coffe_maker', 'coffee_filter', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'table']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Make coffee in the kitchen.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[PLUGIN] <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>', '[CLOSE] <coffe_maker>', '[SWITCHON] <coffe_maker>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tea', 'measuring_cup', 'band-aids', 'knifeblock', 'cpuscreen', 'dvd_player', 'folder', 'desk', 'bookmark', 'stereo', 'faucet', 'dustpan', 'microphone', 'oven', 'cup', 'bed', 'photoframe', 'check', 'coffe_maker', 'television', 'food_rice', 'pencil', 'shredder', 'controller', 'home_office', 'light', 'table', 'scrabble', 'electrical_outlet']\nTask:Shred receipts\nresponse:\n", "output": {"thoughts": "Take old receipts and put through the shredder", "actions": ["[WALK] <home_office>", "[WALK] <filing_cabinet>", "[FIND] <filing_cabinet>", "[OPEN] <filing_cabinet>", "[FIND] <check>", "[GRAB] <check>", "[CLOSE] <filing_cabinet>", "[FIND] <electrical_outlet>", "[FIND] <shredder>", "[PLUGIN] <shredder>", "[SWITCHON] <shredder>", "[PUTBACK] <check> <shredder>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Sit and read,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[OPEN] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[CLOSE] <filing_cabinet>', '[WALK] <couch>', '[SIT] <couch>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'chair', 'jelly', 'walllamp', 'bathroom', 'knife', 'wallshelf', 'floor', 'ceiling', 'bookmark', 'ceilinglamp', 'mat', 'window', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'food_food', 'television', 'toothbrush_holder', 'wooden_spoon', 'kettle', 'shoes', 'cupboard', 'conditioner', 'clothes_dress', 'door', 'napkin', 'light']\nTask:Read book\nresponse:\n", "output": {"thoughts": "Pick up a book and open to the last page you were on. Read the book.", "actions": ["[WALK] <home_office>", "[WALK] <novel>", "[FIND] <novel>", "[GRAB] <novel>", "[WALK] <couch>", "[SIT] <couch>", "[FIND] <bookmark>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'chair', 'orchid', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'food_cake', 'thread', 'computer', 'laptop', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'oven', 'pasta', 'television', 'tray', 'doorjamb', 'mouse', 'headset', 'chessboard', 'cupboard', 'door']\nTask:Watch movie\nresponse:\n{\n    \"thoughts\": Sit in my deck chair with my laptop, find a good movie on You Tube to watch, plug in earphones and listen to movie quietly so I don't disturb my upstairs neighbor.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <laptop>', '[FIND] <laptop>', '[GRAB] <laptop>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <headset>', '[GRAB] <headset>', '[PUTON] <headset>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']\n}\n", "input": "\nScene_Objects:['fork', 'filing_cabinet', 'scissors', 'juice', 'food_salt', 'microwave', 'chair', 'food_butter', 'toothbrush', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'button', 'brush', 'ceilinglamp', 'plate', 'wall', 'tape', 'food_food', 'check', 'food_donut', 'wooden_spoon', 'rag', 'door', 'clothes_scarf', 'napkin', 'table', 'light', 'dishwasher']\nTask:Eat\nresponse:\n", "output": {"thoughts": "Serve food on dinning table in appropriate utensils, sit on the chair, eat", "actions": ["[WALK] <dining_room>", "[WALK] <table>", "[FIND] <table>", "[TURNTO] <table>", "[FIND] <chair>", "[SIT] <chair>", "[FIND] <food_food>", "[GRAB] <food_food>", "[FIND] <plate>", "[PUTBACK] <food_food> <plate>", "[GRAB] <food_food>", "[PUTOBJBACK] <food_food>", "[FIND] <fork>", "[GRAB] <fork>", "[EAT] <plate>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'mop', 'microwave', 'freezer', 'walllamp', 'detergent', 'toothbrush', 'orchid', 'drawing', 'clothes_underwear', 'floor', 'thread', 'mat', 'closetdrawer', 'wall', 'nightstand', 'toy', 'standingmirror', 'light_bulb', 'novel', 'check', 'tray', 'cards', 'mouse', 'pencil', 'vacuum_cleaner', 'headset', 'maindoor', 'napkin', 'light']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[TURNTO] <filing_cabinet>', '[LOOKAT] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'crayon', 'chair', 'freezer', 'walllamp', 'bathroom', 'woman', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'child', 'powersocket', 'check', 'coffe_maker', 'television', 'curtain', 'pencil', 'dresser', 'table']\nTask:Watch movie\nresponse:\n", "output": {"thoughts": "Sitting and watching  a movie with family", "actions": ["[WALK] <home_office>", "[WALK] <child>", "[FIND] <child>", "[TURNTO] <child>", "[LOOKAT] <child>", "[GREET] <child>", "[FIND] <woman>", "[TURNTO] <woman>", "[LOOKAT] <woman>", "[GREET] <woman>", "[WALK] <television>", "[SWITCHON] <television>", "[TURNTO] <television>", "[LOOKAT] <television>", "[TOUCH] <television>", "[TURNTO] <television>", "[LOOKAT] <television>", "[TOUCH] <television>", "[TURNTO] <television>", "[LOOKAT] <television>", "[TOUCH] <television>", "[WALK] <couch>", "[SIT] <couch>", "[TURNTO] <television>", "[LOOKAT] <television>", "[WATCH] <television>", "[WATCH] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'pot', 'juice', 'cd_player', 'toilet', 'freezer', 'trashcan', 'bedroom', 'remote_control', 'button', 'clothes_jacket', 'toaster', 'laptop', 'ceilinglamp', 'plate', 'homework', 'dining_room', 'broom', 'bench', 'tape', 'keys', 'coffe_maker', 'television', 'towel_rack', 'hair', 'cupboard', 'maindoor', 'sink', 'clothes_skirt', 'vase']\nTask:Listen to music\nresponse:\n{\n    \"thoughts\": I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cd_player>', '[FIND] <cd_player>', '[PLUGIN] <cd_player>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <button>', '[PUSH] <button>']\n}\n", "input": "\nScene_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']\nTask:Clean mirror\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_ice_cream', 'microwave', 'toilet', 'chair', 'bathroom_counter', 'floor', 'laptop', 'faucet', 'shower', 'towel', 'wall', 'wall_clock', 'nightstand', 'cup', 'bed', 'photoframe', 'water', 'tray', 'doorjamb', 'towel_rack', 'dresser', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'table', 'soap', 'scrabble', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": Go into the bathroom and go over to the sink. Grab soap and turn on the water. Wet your hands and rub them together so that the soap lathers. Rub the soap all over your hands thoroughly. Rinse off the soap with water and turn off the sink. Dry your hands with a towel.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <water>', '[GRAB] <water>', '[FIND] <hands_both>', '[POUR] <water> <hands_both>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>']\n}\n", "input": "\nScene_Objects:['pot', 'tablelamp', 'chair', 'band-aids', 'walllamp', 'detergent', 'orchid', 'drawing', 'floor', 'ceiling', 'phone', 'video_game_console', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'plate', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'photoframe', 'video_game_controller', 'television', 'curtain', 'dresser', 'table', 'dishwasher']\nTask:Play games\nresponse:\n", "output": {"thoughts": "Turn on game.  Use controller", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[PLUGIN] <television>", "[SWITCHON] <television>", "[FIND] <video_game_console>", "[PLUGIN] <video_game_console>", "[SWITCHON] <video_game_console>", "[FIND] <video_game_console>", "[FIND] <video_game_controller>", "[GRAB] <video_game_controller>", "[WALK] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'water_glass', 'pot', 'tablelamp', 'microwave', 'drawing', 'knife', 'food_egg', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'toaster', 'stovefan', 'plate', 'shower', 'dish_soap', 'mousepad', 'wall', 'oven', 'photoframe', 'coffe_maker', 'tray', 'towel_rack', 'kitchen_counter', 'cupboard', 'spoon', 'coffee_cup', 'dishwasher', 'light']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": I go to the kitchen and put plates, cutlery and glasses into the dishwasher, put the soap, close the machine and switch it on.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <dishwasher>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[PUTBACK] <coffee_cup> <dishwasher>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <dishwasher>', '[FIND] <pot>', '[GRAB] <pot>', '[PUTBACK] <pot> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[PUTBACK] <water_glass> <dishwasher>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[PUTBACK] <water_glass> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['spectacles', 'tablelamp', 'microwave', 'chair', 'wallshelf', 'hanger', 'floor', 'phone', 'food_bacon', 'piano_bench', 'stovefan', 'ceilinglamp', 'shower', 'mousepad', 'closetdrawer', 'powersocket', 'television', 'coin', 'food_donut', 'ice', 'rag', 'pencil', 'shoes', 'dresser', 'clothes_dress', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'light', 'home_office']\nTask:Hang up jacket\nresponse:\n", "output": {"thoughts": "I put clothes on hangers and hang them in the closet", "actions": ["[WALK] <bedroom>", "[WALK] <clothes_dress>", "[FIND] <clothes_dress>", "[GRAB] <clothes_dress>", "[WALK] <dresser>", "[FIND] <hanger>", "[OPEN] <dresser>", "[PUTIN] <clothes_dress> <dresser>", "[FIND] <clothes_dress>", "[GRAB] <clothes_dress>", "[WALK] <dresser>", "[PUTIN] <clothes_dress> <dresser>", "[CLOSE] <dresser>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'fork', 'pot', 'sheets', 'food_salt', 'detergent', 'food_butter', 'drawing', 'cpuscreen', 'wallshelf', 'bathroom_counter', 'floor', 'shampoo', 'desk', 'food_cake', 'mat', 'faucet', 'food_kiwi', 'wall', 'powersocket', 'toy', 'novel', 'food_food', 'curtain', 'dresser', 'sink', 'bathroom_cabinet', 'dishwasher', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": Going to the sink and scrubbing hands,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <hands_both>', '[RINSE] <hands_both>', '[SCRUB] <hands_both>', '[RINSE] <hands_both>']\n}\n", "input": "\nScene_Objects:['food_salt', 'toilet', 'freezer', 'ground_coffee', 'milk', 'orchid', 'ceiling', 'phone', 'character', 'keyboard', 'food_bacon', 'stovefan', 'ceilinglamp', 'tvstand', 'closetdrawer', 'couch', 'dining_room', 'bowl', 'nightstand', 'pasta', 'food_cheese', 'bed', 'novel', 'check', 'food_food', 'coin', 'tray', 'doorjamb', 'diary', 'table']\nTask:Look out window\nresponse:\n", "output": {"thoughts": "I head into my child's room and look out the window to view the neighborhood from a different area in the house.", "actions": ["[WALK] <bedroom>", "[WALK] <window>", "[TURNTO] <window>", "[LOOKAT] <window>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'chair', 'drawing', 'hanger', 'floor', 'phone', 'ceilinglamp', 'plate', 'iron', 'candle', 'pillow', 'wall', 'bench', 'powersocket', 'oven', 'food_food', 'video_game_controller', 'check', 'wooden_spoon', 'after_shave', 'doorjamb', 'shoes', 'dresser', 'cupboard', 'clothes_dress', 'door', 'conditioner', 'sink', 'table', 'light']\nTask:Eat dinner\nresponse:\n{\n    \"thoughts\": Put food on the table, sit down, and eat the food.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <plate>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <food_food>', '[GRAB] <food_food>', '[PUTBACK] <food_food> <plate>', '[WALK] <dining_room>', '[WALK] <table>', '[FIND] <table>', '[PUTBACK] <plate> <table>', '[FIND] <chair>', '[SIT] <chair>', '[EAT] <plate>']\n}\n", "input": "\nScene_Objects:['food_bread', 'tablelamp', 'microwave', 'chair', 'walllamp', 'floor', 'ceiling', 'character', 'bedroom', 'stovefan', 'ceilinglamp', 'faucet', 'oil', 'closetdrawer', 'couch', 'food_peanut_butter', 'pillow', 'dining_room', 'wall', 'nightstand', 'cutting_board', 'photoframe', 'television', 'mouse', 'pencil', 'hairbrush', 'pajamas', 'bathroom_cabinet', 'light', 'teeth']\nTask:Read book\nresponse:\n", "output": {"thoughts": "Bring book, lie on the sofa, read book", "actions": ["[WALK] <home_office>", "[WALK] <novel>", "[GRAB] <novel>", "[WALK] <couch>", "[LIE] <couch>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'ceilingfan', 'drawing', 'food_egg', 'floor', 'ceiling', 'bookshelf', 'remote_control', 'button', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'food_jam', 'pillow', 'dining_room', 'wall', 'nightstand', 'photoframe', 'television', 'food_rice', 'curtain', 'kitchen_counter', 'hair', 'home_office', 'table', 'light', 'dishwasher', 'dirt']\nTask:Change TV channel\nresponse:\n{\n    \"thoughts\": I go to the living room where the TV is located. I plug in the TV to the outlet. I search for the remote control. I point the remote control directly to the TV, turn it on and push the number of the channel that I want.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[FIND] <remote_control>', '[TURNTO] <television>', '[POINTAT] <television>', '[SWITCHON] <television>', '[FIND] <button>', '[PUSH] <button>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'walllamp', 'drawing', 'needle', 'cpuscreen', 'bills', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'mousepad', 'tooth_paste', 'couch', 'pillow', 'towel', 'wall', 'nightstand', 'powersocket', 'television', 'coin', 'razor', 'doorjamb', 'centerpiece', 'mouse', 'door', 'light', 'board_game']\nTask:Re arrange office\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'crayon', 'freezer', 'nail_polish', 'food_carrot', 'milk', 'cpuscreen', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mousepad', 'dining_room', 'wall', 'powersocket', 'cup', 'bed', 'food_food', 'doorjamb', 'mouse', 'pajamas', 'controller', 'door', 'spoon', 'napkin', 'light', 'dirt']\nTask:Get glass of milk\nresponse:\n{\n    \"thoughts\": Get an empty glass. Take milk from refrigerator and open it. Pour milk into glass.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <freezer>', '[OPEN] <freezer>', '[FIND] <milk>', '[GRAB] <milk>', '[POUR] <milk> <cup>', '[PUTOBJBACK] <milk>', '[CLOSE] <freezer>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'food_salt', 'tea', 'chair', 'food_carrot', 'drawing', 'floor', 'ceiling', 'phone', 'dvd_player', 'bookshelf', 'stovefan', 'mat', 'mousepad', 'food_noodles', 'dining_room', 'wall', 'powersocket', 'oven', 'cup', 'check', 'rag', 'doorjamb', 'cd', 'hairbrush', 'dresser', 'door', 'light']\nTask:Turn on light\nresponse:\n", "output": {"thoughts": "Hit light switch", "actions": ["[WALK] <bedroom>", "[WALK] <light>", "[SWITCHON] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'shoe-shine_kit', 'balanceball', 'picture', 'ceilinglamp', 'mousepad', 'wall', 'nightstand', 'newspaper', 'photoframe', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'door', 'light']\nTask:Work\nresponse:\n{\n    \"thoughts\": I need to finish some work on my computer in my home office to meet a deadline for tomorrow.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <desk>', '[OPEN] <desk>', '[PUTBACK] <keyboard> <desk>', '[FIND] <mouse>', '[GRAB] <mouse>', '[FIND] <mousepad>', '[PUTBACK] <mouse> <mousepad>', '[PLUGIN] <keyboard>', '[PLUGIN] <mouse>', '[FIND] <computer>', '[SWITCHON] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[TURNTO] <computer>', '[TYPE] <keyboard>', '[GRAB] <mouse>', '[TOUCH] <mouse>', '[LOOKAT] <computer>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'toilet', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'bookshelf', 'mat', 'tvstand', 'faucet', 'couch', 'pillow', 'wall', 'powersocket', 'bed', 'clothes_gloves', 'novel', 'toilet_paper', 'doorjamb', 'coffee_pot', 'mouse', 'kitchen_counter', 'door', 'napkin', 'bathroom_cabinet', 'light']\nTask:Turn off light\nresponse:\n", "output": {"thoughts": "Hit the switch.", "actions": ["[WALK] <bedroom>", "[WALK] <light>", "[SWITCHOFF] <light>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['beer', 'tea', 'chair', 'walllamp', 'ground_coffee', 'bills', 'orchid', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'mail', 'ceilinglamp', 'mat', 'iron', 'stereo', 'faucet', 'clothes_socks', 'clothes_hat', 'basket_for_clothes', 'food_rice', 'curtain', 'lighter', 'doorjamb', 'towel_rack', 'vacuum_cleaner', 'dishrack', 'cd', 'napkin', 'home_office']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TOUCH] <floor_lamp>', '[SWITCHON] <floor_lamp>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'microwave', 'detergent', 'knife', 'bills', 'bathroom_counter', 'phone', 'folder', 'bedroom', 'character', 'computer', 'toaster', 'stovefan', 'mat', 'window', 'mousepad', 'pillow', 'oven', 'check', 'coffe_maker', 'razor', 'after_shave', 'mouse', 'kitchen_counter', 'shoes', 'dresser', 'pajamas', 'sink', 'bag']\nTask:Get dressed\nresponse:\n", "output": {"thoughts": "I get dressed in my bedroom in the mornings.", "actions": ["[WALK] <bedroom>", "[WALK] <shoes>", "[FIND] <shoes>", "[GRAB] <shoes>", "[PUTON] <shoes>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Hang with friends\nresponse:\n{\n    \"thoughts\": Sit with friends. Talk,\n    \"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>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'band-aids', 'bathroom', 'cat', 'orchid', 'wallshelf', 'hanger', 'floor', 'phone', 'character', 'bedroom', 'purse', 'computer', 'table_cloth', 'tvstand', 'powersocket', 'toy', 'clothes_gloves', 'coffe_maker', 'razor', 'food_onion', 'centerpiece', 'headset', 'chessboard', 'cupboard', 'door', 'home_office', 'table', 'laser_pointer']\nTask:Open door\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'faucet', 'picture', 'window', 'dustpan', 'towel', 'wall', 'nightstand', 'photoframe', 'keys', 'toothbrush_holder', 'food_donut', 'mouse', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'vase', 'soap', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": Cleaning hands,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'chair', 'ground_coffee', 'woman', 'orchid', 'wallshelf', 'cpuscreen', 'hanger', 'shampoo', 'floor', 'ceiling', 'bookshelf', 'food_noodles', 'closetdrawer', 'mousepad', 'couch', 'towel', 'wall', 'food_food', 'television', 'kettle', 'mouse', 'cards', 'vacuum_cleaner', 'dresser', 'door', 'hairdryer', 'dishwasher', 'clothes_shirt']\nTask:Greet guests\nresponse:\n", "output": {"thoughts": "Greet people into my home", "actions": ["[WALK] <home_office>", "[WALK] <woman>", "[FIND] <woman>", "[GREET] <woman>", "[FIND] <woman>", "[GREET] <woman>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'fork', 'filing_cabinet', 'chair', 'cat', 'drawing', 'hanger', 'floor', 'character', 'tea_bag', 'mat', 'picture', 'electric_shaver', 'couch', 'food_jam', 'towel', 'dining_room', 'wall', 'oven', 'coffe_maker', 'tray', 'curtain', 'doorjamb', 'diary', 'cards', 'cupboard', 'door', 'bathroom_cabinet', 'light', 'tooth_paste']\nTask:Read book\nresponse:\n{\n    \"thoughts\": pick up  the book open the book and read,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <novel>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'character', 'computer', 'ceilinglamp', 'tvstand', 'shower', 'faucet', 'window', 'deck_of_cards', 'closetdrawer', 'couch', 'dustpan', 'pillow', 'food_kiwi', 'nightstand', 'wall', 'cup', 'coffe_maker', 'television', 'food_rice', 'curtain', 'dresser', 'napkin', 'table', 'light']\nTask:Watch TV\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'ceiling', 'character', 'tea_bag', 'computer', 'table_cloth', 'toaster', 'mat', 'tvstand', 'stovefan', 'electric_shaver', 'couch', 'pillow', 'wall', 'basket_for_clothes', 'newspaper', 'coffee_table', 'photoframe', 'video_game_controller', 'television', 'doorjamb', 'dresser', 'cupboard', 'dishwasher']\nTask:Read magazine\nresponse:\n{\n    \"thoughts\": Get magazine off coffee table. Sit in arm chair. Open magazine to first page. Read until finished.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <coffee_table>', '[FIND] <newspaper>', '[GRAB] <newspaper>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <newspaper>', '[PUTBACK] <newspaper> <coffee_table>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'freezer', 'ground_coffee', 'drawing', 'knifeblock', 'clothes_underwear', 'hanger', 'floor', 'desk', 'stamp', 'bookshelf', 'food_cake', 'table_cloth', 'bookmark', 'mat', 'clothes_hat', 'wall', 'pasta', 'powersocket', 'toy', 'box', 'food_cheese', 'light_bulb', 'doorjamb', 'lighter', 'kitchen_counter', 'door', 'light']\nTask:Clean\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'tablelamp', 'microwave', 'toilet', 'chair', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'wall', 'nightstand', 'box', 'novel', 'toilet_paper', 'television', 'mouse', 'dresser', 'door', 'food_steak', 'clothes_skirt', 'tooth_paste']\nTask:Read book\nresponse:\n{\n    \"thoughts\": \"walk to entrance\" \"walk to living room\" \"look for book\" \"find book\" \"pick up book\" \"look for chair\" \"find chair\" \"sit in chair\" \"read book\",\n    \"actions\": ['[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[FIND] <novel>', '[FIND] <chair>', '[TURNTO] <chair>', '[LOOKAT] <chair>', '[SIT] <chair>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['sheets', 'sponge', 'crayon', 'microwave', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'floor', 'bookshelf', 'button', 'stovefan', 'mat', 'stereo', 'mousepad', 'clothes_hat', 'bowl', 'nightstand', 'wall', 'bed', 'photoframe', 'light_bulb', 'food_food', 'television', 'kitchen_counter', 'dresser', 'door', 'sink', 'clothes_skirt', 'scrabble']\nTask:Breakfast\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'pot', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'floor', 'ceiling', 'shampoo', 'desk', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'mat', 'plate', 'stereo', 'mousepad', 'wall', 'bench', 'television', 'wine', 'rag', 'lighter', 'shaving_cream', 'mouse', 'hairbrush', 'door', 'table']\nTask:Write an email\nresponse:\n{\n    \"thoughts\": walk to living room, look at computer, find chair, sit in chair, grab keyboard, grab mouse, type using keyboard and mouse,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[WALK] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <keyboard>', '[GRAB] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TYPE] <keyboard>']\n}\n", "input": "\nScene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'beer', 'crayon', 'chair', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'bedroom', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cup', 'bed', 'keys', 'food_food', 'television', 'food_onion', 'doorjamb', 'mouse', 'home_office']\nTask:Lock door\nresponse:\n", "output": {"thoughts": "Turn the lock.", "actions": ["[WALK] <bedroom>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'walllamp', 'bathroom', 'cat', 'ceilingfan', 'knifeblock', 'phone', 'character', 'brush', 'toaster', 'mat', 'faucet', 'ceilinglamp', 'shower', 'window', 'couch', 'wall_clock', 'cup', 'newspaper', 'food_onion', 'lighter', 'towel_rack', 'mouse', 'kitchen_counter', 'headset', 'cupboard', 'table', 'vase', 'laser_pointer']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <bedroom>', '[WALK] <bedroom>', '[WALK] <home_office>', '[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[FIND] <brush>', '[GRAB] <brush>']\n}\n", "input": "\nScene_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']\nTask:Do dishes\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'crayon', 'detergent', 'ceilingfan', 'food_carrot', 'milk', 'drawing', 'knifeblock', 'food_egg', 'floor', 'phone', 'desk', 'bookshelf', 'envelope', 'ceilinglamp', 'window', 'mousepad', 'couch', 'wall', 'food_cheese', 'novel', 'television', 'food_rice', 'after_shave', 'towel_rack', 'kitchen_counter', 'comb', 'table', 'dishwasher', 'creditcard']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": I walk to the living room and find the sofa. I sit on the sofa and get comfortable.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['sheets', 'scissors', 'chair', 'dog', 'ground_coffee', 'knife', 'needle', 'bills', 'bathroom_counter', 'floor', 'phone', 'bookshelf', 'bookmark', 'ceilinglamp', 'faucet', 'shower', 'picture', 'food_noodles', 'clothes_socks', 'mousepad', 'pillow', 'wall', 'photoframe', 'food_food', 'tray', 'kitchen_counter', 'sink', 'bag', 'home_office', 'table']\nTask:Sit\nresponse:\n", "output": {"thoughts": "We sit at the dining room table", "actions": ["[WALK] <dining_room>", "[WALK] <chair>", "[FIND] <chair>", "[PULL] <chair>", "[SIT] <chair>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['freezer', 'bathroom', 'detergent', 'orchid', 'cpuscreen', 'floor', 'phone', 'desk', 'bedroom', 'purse', 'computer', 'table_cloth', 'bookmark', 'stovefan', 'stereo', 'oil', 'closetdrawer', 'coffe_maker', 'television', 'food_donut', 'food_rice', 'tray', 'centerpiece', 'doorjamb', 'pencil', 'maindoor', 'sink', 'home_office', 'table', 'clothes_skirt']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Walk to living room. Find book. Grab book. Open book. Read book.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'scissors', 'food_carrot', 'hanger', 'phone', 'desk', 'keyboard', 'computer', 'stovefan', 'deck_of_cards', 'faucet', 'window', 'closetdrawer', 'microphone', 'pillow', 'box', 'bed', 'photoframe', 'check', 'food_onion', 'diary', 'pencil', 'shoes', 'dishrack', 'dresser', 'laundry_detergent', 'spoon', 'soap', 'tooth_paste', 'shoe_rack']\nTask:Take off shoes\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'filing_cabinet', 'chair', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'mat', 'shoe-shine_kit', 'mousepad', 'pillow', 'wall', 'powersocket', 'cup', 'bed', 'wooden_spoon', 'coffee_pot', 'mouse', 'kitchen_counter', 'door', 'home_office', 'table']\nTask:Write an email\nresponse:\n{\n    \"thoughts\": I walk to the Home Office then find the computer and sit in the chair. I switch on the computer and start typing the email. I switch the computer off.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[FIND] <computer>', '[FIND] <chair>', '[SIT] <chair>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[SWITCHOFF] <computer>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'food_pizza', 'tablelamp', 'beer', 'freezer', 'blow_dryer', 'drawing', 'needle', 'cpuscreen', 'floor', 'desk', 'bookshelf', 'mat', 'mousepad', 'form', 'wall', 'powersocket', 'food_cheese', 'food_food', 'check', 'doorjamb', 'mouse', 'chessboard', 'dresser', 'laundry_detergent', 'door', 'hairdryer', 'light', 'board_game']\nTask:Put clothes away\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'chair', 'freezer', 'walllamp', 'food_butter', 'bills', 'cpuscreen', 'bathroom_counter', 'phone', 'ceiling', 'character', 'bedroom', 'computer', 'stovefan', 'ceilinglamp', 'faucet', 'floor_lamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'oven', 'cup', 'photoframe', 'television', 'kitchen_counter', 'dresser', 'bathroom_cabinet', 'table', 'light']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": Walk over to light switch, flip the switch to the on position,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <floor_lamp>', '[SWITCHON] <floor_lamp>']\n}\n", "input": "\nScene_Objects:['pot', 'food_pizza', 'ground_coffee', 'walllamp', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'character', 'computer', 'piano_bench', 'stovefan', 'toaster', 'tvstand', 'faucet', 'oil', 'pillow', 'wall', 'oven', 'powersocket', 'food_food', 'water', 'tray', 'after_shave', 'doorjamb', 'kitchen_counter', 'dresser', 'cupboard', 'door', 'dishwasher']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Get my coffee pot going", "actions": ["[WALK] <dining_room>", "[WALK] <coffee_pot>", "[FIND] <coffee_pot>", "[GRAB] <coffee_pot>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[POUR] <water> <coffee_pot>", "[FIND] <ground_coffee>", "[GRAB] <ground_coffee>", "[PUTBACK] <ground_coffee> <coffee_pot>", "[GRAB] <ground_coffee>", "[PUTOBJBACK] <ground_coffee>", "[WALK] <oven>", "[PUTBACK] <coffee_pot> <oven>", "[SWITCHON] <oven>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'chair', 'knifeblock', 'knife', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'mail', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'stereo', 'pillow', 'dining_room', 'wall', 'cup', 'bed', 'novel', 'coffe_maker', 'doorjamb', 'kitchen_counter', 'cupboard', 'controller', 'laundry_detergent', 'hairdryer', 'sink', 'home_office', 'dishwasher']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Making coffee,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>']\n}\n", "input": "\nScene_Objects:['spectacles', 'tablelamp', 'beer', 'measuring_cup', 'band-aids', 'woman', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'ceiling', 'character', 'desk', 'man', 'thread', 'clothes_jacket', 'tvstand', 'stereo', 'faucet', 'window', 'shower', 'couch', 'form', 'cutting_board', 'novel', 'television', 'bathroom_cabinet', 'table', 'dishwasher', 'instrument_violin']\nTask:Greet guests\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'scissors', 'tablelamp', 'crayon', 'microwave', 'freezer', 'bathroom', 'trashcan', 'ceilingfan', 'knifeblock', 'clothes_underwear', 'longboard', 'shampoo', 'dvd_player', 'folder', 'mail', 'bookmark', 'toaster', 'shower', 'homework', 'couch', 'bed', 'clothes_gloves', 'towel_rack', 'mouse', 'pencil', 'cupboard', 'maindoor', 'table', 'laser_pointer']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": I walk into the living room and I pet the cat,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['sheets', 'food_pizza', 'tablelamp', 'chair', 'walllamp', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'man', 'food_bacon', 'stovefan', 'ceilinglamp', 'brush', 'mat', 'oil', 'couch', 'food_jam', 'pillow', 'wall', 'nightstand', 'newspaper', 'novel', 'coffe_maker', 'television', 'mouse', 'chessboard', 'soap', 'instrument_violin', 'teeth']\nTask:Have conversation with boyfriend\nresponse:\n", "output": {"thoughts": "Sit on sofa, talk", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[FIND] <couch>", "[WALK] <couch>", "[SIT] <couch>", "[FIND] <man>", "[GREET] <man>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'microwave', 'toilet', 'dog', 'freezer', 'drawing', 'knifeblock', 'longboard', 'floor', 'folder', 'computer', 'ceilinglamp', 'window', 'couch', 'wall', 'nightstand', 'bench', 'cup', 'bed', 'clothes_gloves', 'novel', 'television', 'curtain', 'towel_rack', 'cupboard', 'sink', 'home_office', 'table']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": I'm tired and want to relax on the sofa,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['food_pizza', 'microwave', 'toilet', 'jelly', 'freezer', 'band-aids', 'drawing', 'knifeblock', 'clothes_underwear', 'kitchen_cabinet', 'floor', 'ceiling', 'toaster', 'mat', 'faucet', 'shower', 'wall', 'nightstand', 'powersocket', 'cup', 'basket_for_clothes', 'photoframe', 'food_food', 'water', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'sink', 'light']\nTask:Get drink\nresponse:\n", "output": {"thoughts": "I go to the fridge and open the door. I look for the water pitcher, and take it out, making sure to close the fridge door behind me. Then I take a pint glass out of the upper cabinet over the sink and use the water pitcher to pour a full glass of water. Then I return the pitcher to the fridge and shut the door again, and take my glass of water out of the kitche.", "actions": ["[WALK] <dining_room>", "[WALK] <sink>", "[FIND] <kitchen_cabinet>", "[OPEN] <kitchen_cabinet>", "[FIND] <cup>", "[GRAB] <cup>", "[CLOSE] <kitchen_cabinet>", "[WALK] <freezer>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[POUR] <water> <cup>", "[OPEN] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['blender', 'walllamp', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'remote_control', 'thread', 'bookshelf', 'toaster', 'ceilinglamp', 'tvstand', 'mat', 'clothes_socks', 'wall', 'pasta', 'powersocket', 'cutting_board', 'cup', 'clothes_gloves', 'novel', 'television', 'rag', 'doorjamb', 'shoes', 'door', 'table', 'dishwasher']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": turn on the tv,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']\n}\n", "input": "\nScene_Objects:['sheets', 'sponge', 'mop', 'chair', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'window', 'mousepad', 'clothes_socks', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'pasta', 'nightstand', 'light_bulb', 'coffe_maker', 'television', 'wooden_spoon', 'mouse', 'shoes', 'vacuum_cleaner', 'sink']\nTask:Check email\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'laptop', 'faucet', 'mousepad', 'candle', 'microphone', 'food_orange', 'wall', 'photoframe', 'check', 'mouthwash', 'after_shave', 'doorjamb', 'cupboard', 'pajamas', 'conditioner', 'door', 'sink', 'bathroom_cabinet', 'light', 'soap', 'clothes_shirt', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": I go into the bathroom and turn on the light. I walk to the sink and turn on the water. I grab the soap and wash my hands,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <hands_both>', '[WASH] <hands_both>', '[RINSE] <hands_both>', '[PUTOBJBACK] <soap>', '[SWITCHOFF] <faucet>']\n}\n", "input": "\nScene_Objects:['microwave', 'toilet', 'jelly', 'walllamp', 'detergent', 'knifeblock', 'orchid', 'floor', 'ceiling', 'toaster', 'plate', 'faucet', 'dish_soap', 'wall', 'nightstand', 'powersocket', 'oven', 'food_food', 'television', 'coffee_filter', 'wine', 'curtain', 'rag', 'doorjamb', 'shaving_cream', 'kitchen_counter', 'dishrack', 'cupboard', 'sink', 'bag']\nTask:Wash dishes\nresponse:\n", "output": {"thoughts": "Run hot water into tub of dirty dishes in the sink.  Add liquid soap.  Scrub dishes with wash rag. Rinse and place on drying rack.", "actions": ["[WALK] <dining_room>", "[WALK] <sink>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[POUR] <dish_soap> <sink>", "[PUTOBJBACK] <dish_soap>", "[FIND] <rag>", "[GRAB] <rag>", "[FIND] <plate>", "[GRAB] <plate>", "[SCRUB] <plate>", "[RINSE] <plate>", "[FIND] <dishrack>", "[PUTBACK] <plate> <dishrack>", "[FIND] <plate>", "[GRAB] <plate>", "[SCRUB] <plate>", "[RINSE] <plate>", "[PUTBACK] <plate> <dishrack>", "[SWITCHOFF] <faucet>", "[PUTOBJBACK] <rag>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'food_pizza', 'tablelamp', 'blender', 'food_salt', 'blow_dryer', 'trashcan', 'toothbrush', 'cpuscreen', 'hanger', 'ceiling', 'character', 'desk', 'keyboard', 'bookshelf', 'purse', 'ceilinglamp', 'tvstand', 'faucet', 'mousepad', 'microphone', 'oven', 'food_food', 'check', 'tray', 'dresser', 'napkin', 'bathroom_cabinet', 'clothes_shirt']\nTask:Leave home\nresponse:\n{\n    \"thoughts\": Put on shoes. Put on coat. Open door and exit through it. Lock door behind you.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'jelly', 'freezer', 'detergent', 'woman', 'orchid', 'drawing', 'phone', 'character', 'man', 'bookshelf', 'toaster', 'ceilinglamp', 'tvstand', 'stereo', 'food_orange', 'nightstand', 'box', 'food_cheese', 'coffe_maker', 'food_food', 'check', 'video_game_controller', 'centerpiece', 'mouse', 'kitchen_counter', 'vacuum_cleaner', 'sink', 'table', 'tooth_paste']\nTask:Greet people\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['fork', 'chair', 'walllamp', 'knife', 'food_egg', 'floor', 'food_cake', 'toaster', 'plate', 'tvstand', 'window', 'dish_soap', 'wall', 'nightstand', 'oven', 'cutting_board', 'coffe_maker', 'check', 'razor', 'television', 'food_donut', 'tray', 'centerpiece', 'doorjamb', 'dishrack', 'food_steak', 'spoon', 'light', 'dishwasher', 'colander']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": put forks, spoons, plates, knife in dishwasher, add dish soap, turn diswaser on,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[FIND] <dishrack>', '[PUTBACK] <fork> <dishrack>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishrack>', '[FIND] <spoon>', '[GRAB] <spoon>', '[PUTBACK] <spoon> <dishrack>', '[FIND] <knife>', '[GRAB] <knife>', '[PUTBACK] <knife> <dishrack>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['blender', 'freezer', 'walllamp', 'bathroom', 'drawing', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'character', 'keyboard', 'brush', 'tvstand', 'stereo', 'window', 'closetdrawer', 'towel', 'wall', 'powersocket', 'tape', 'food_food', 'television', 'curtain', 'doorjamb', 'vacuum_cleaner', 'dresser', 'door', 'clothes_scarf', 'dishwasher', 'board_game']\nTask:vacuum carpet\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": I walk to the home office. I find the telephone. I pick up the telephone handset.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'scissors', 'chair', 'bathroom', 'toothbrush', 'drawing', 'cpuscreen', 'floor', 'keyboard', 'piano_bench', 'ceilinglamp', 'oil', 'form', 'food_orange', 'wall', 'nightstand', 'oven', 'photoframe', 'check', 'food_food', 'television', 'coffee_filter', 'tray', 'mouse', 'cd', 'cupboard', 'door', 'table', 'light', 'creditcard']\nTask:Eat dinner\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'pot', 'microwave', 'bathroom', 'drawing', 'wallshelf', 'floor', 'ceiling', 'bedroom', 'toaster', 'stovefan', 'deck_of_cards', 'shower', 'pillow', 'wall', 'powersocket', 'cup', 'coffe_maker', 'check', 'wine', 'food_onion', 'curtain', 'lighter', 'kitchen_counter', 'cupboard', 'hair', 'controller', 'table', 'dishwasher', 'colander']\nTask:Take dishes out of dishwasher\nresponse:\n{\n    \"thoughts\": Take clean dishes out of the dishwasher and put away,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[OPEN] <dishwasher>', '[CLOSE] <dishwasher>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'ground_coffee', 'walllamp', 'milk', 'cpuscreen', 'ceiling', 'phone', 'keyboard', 'stovefan', 'plate', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'oven', 'coffe_maker', 'food_food', 'wine', 'tray', 'food_onion', 'mouse', 'kitchen_counter', 'headset', 'comb', 'cupboard', 'door', 'bathroom_cabinet', 'dishwasher']\nTask:Get out dish\nresponse:\n", "output": {"thoughts": "Open cupboard.  Get out the dish.", "actions": ["[WALK] <dining_room>", "[WALK] <cupboard>", "[OPEN] <cupboard>", "[FIND] <plate>", "[GRAB] <plate>", "[CLOSE] <cupboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_pizza', 'chair', 'freezer', 'walllamp', 'food_carrot', 'knifeblock', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'toaster', 'mat', 'faucet', 'window', 'oil', 'couch', 'wall', 'bench', 'powersocket', 'photoframe', 'bed', 'television', 'curtain', 'after_shave', 'towel_rack', 'kitchen_counter', 'bathtub', 'sink', 'light']\nTask:Open bathroom window\nresponse:\n{\n    \"thoughts\": Make sure bathroom window is unlocked. Lift up bathroom window so it is open.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <window>', '[FIND] <window>', '[OPEN] <window>']\n}\n", "input": "\nScene_Objects:['sheets', 'pot', 'food_salt', 'cpuscreen', 'clothes_underwear', 'floor', 'bedroom', 'food_cake', 'computer', 'stovefan', 'ceilinglamp', 'oil', 'couch', 'powersocket', 'cutting_board', 'food_cheese', 'photoframe', 'food_food', 'razor', 'oven_mitts', 'coffee_pot', 'mouse', 'shoes', 'dishrack', 'chessboard', 'cupboard', 'controller', 'food_steak', 'hairdryer', 'spoon']\nTask:Clean\nresponse:\n", "output": {"thoughts": "Clean the welcome mat", "actions": ["[WALK] <home_office>", "[WALK] <vacuum_cleaner>", "[FIND] <vacuum_cleaner>", "[GRAB] <vacuum_cleaner>", "[SWITCHON] <vacuum_cleaner>", "[SWITCHOFF] <vacuum_cleaner>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'food_ice_cream', 'mop', 'microwave', 'detergent', 'ceilingfan', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bedroom', 'remote_control', 'stovefan', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'candle', 'wall', 'bed', 'television', 'curtain', 'dresser', 'maindoor', 'table', 'dishwasher', 'vase', 'coffee']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": Walk to livingroom, sit on couch, grab remote and turn on tv.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['sheets', 'measuring_cup', 'microwave', 'jelly', 'ground_coffee', 'drawing', 'knifeblock', 'bathroom_counter', 'character', 'bookshelf', 'keyboard', 'stovefan', 'ceilinglamp', 'brush', 'faucet', 'picture', 'mat', 'closetdrawer', 'powersocket', 'oven', 'cup', 'basket_for_clothes', 'clothes_gloves', 'novel', 'television', 'kettle', 'cupboard', 'sink', 'spoon', 'table']\nTask:Read book\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Bring book, lie on the sofa, read book,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[GRAB] <novel>', '[WALK] <couch>', '[LIE] <couch>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'food_pizza', 'blender', 'tea', 'toilet', 'chair', 'freezer', 'bathroom', 'woman', 'knifeblock', 'drawing', 'wallshelf', 'floor', 'phone', 'character', 'desk', 'man', 'button', 'deck_of_cards', 'mousepad', 'clothes_pants', 'child', 'coffe_maker', 'tray', 'comb', 'dresser', 'cupboard', 'hairbrush', 'soap', 'tooth_paste']\nTask:Greet guests\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'sheets', 'tablelamp', 'toilet', 'chair', 'walllamp', 'nail_polish', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'ceilinglamp', 'mat', 'tvstand', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'novel', 'coffe_maker', 'check', 'television', 'curtain', 'lighter', 'bathroom_cabinet', 'table']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": walk into living room, look at the sofa which one is available, sit on the sofa, now take relax on the sofa,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['pot', 'food_bread', 'beer', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_bacon', 'stovefan', 'mat', 'toaster', 'shower', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'food_vegetable', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'tooth_paste']\nTask:Cook some food\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'chair', 'knifeblock', 'knife', 'orchid', 'floor', 'ceiling', 'phone', 'keyboard', 'mail', 'stovefan', 'ceilinglamp', 'deck_of_cards', 'stereo', 'pillow', 'dining_room', 'wall', 'cup', 'bed', 'novel', 'coffe_maker', 'doorjamb', 'kitchen_counter', 'cupboard', 'controller', 'laundry_detergent', 'hairdryer', 'sink', 'home_office', 'dishwasher']\nTask:Make coffee\nresponse:\n{\n    \"thoughts\": Making coffee,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <coffe_maker>', '[FIND] <coffe_maker>', '[SWITCHON] <coffe_maker>']\n}\n", "input": "\nScene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'food_carrot', 'orchid', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'mat', 'ceilinglamp', 'tvstand', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'television', 'oven_mitts', 'wooden_spoon', 'doorjamb', 'mouse', 'pajamas', 'door', 'light', 'table']\nTask:Write an email\nresponse:\n", "output": {"thoughts": "Compose an email in the home office.", "actions": ["[WALK] <home_office>", "[WALK] <computer>", "[FIND] <computer>", "[SWITCHON] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'tablelamp', 'toilet', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'remote_control', 'computer', 'toaster', 'tvstand', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'love_seat', 'clothes_gloves', 'television', 'tray', 'curtain', 'food_onion', 'dresser', 'cupboard', 'instrument_guitar', 'table', 'light']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": I'll watch TV,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['spectacles', 'sheets', 'tablelamp', 'toilet', 'chair', 'walllamp', 'nail_polish', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'ceilinglamp', 'mat', 'tvstand', 'stereo', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'photoframe', 'novel', 'coffe_maker', 'check', 'television', 'curtain', 'lighter', 'bathroom_cabinet', 'table']\nTask:Relax on sofa\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['beer', 'microwave', 'trashcan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'keyboard', 'ceilinglamp', 'mat', 'picture', 'window', 'couch', 'dining_room', 'wall', 'oven', 'powersocket', 'toy', 'photoframe', 'television', 'oven_mitts', 'tray', 'centerpiece', 'kettle', 'towel_rack', 'pencil', 'dishrack', 'table', 'vase']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": go to the living room and sit on the couch, ease into the sofa and relax.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[LIE] <couch>']\n}\n", "input": "\nScene_Objects:['chair', 'walllamp', 'bathroom', 'detergent', 'food_butter', 'orchid', 'wallshelf', 'floor', 'ceiling', 'character', 'bedroom', 'button', 'table_cloth', 'stovefan', 'mat', 'brush', 'stereo', 'picture', 'mousepad', 'couch', 'clothes_pants', 'food_jam', 'powersocket', 'oven', 'newspaper', 'cards', 'shoes', 'controller', 'clothes_skirt', 'board_game']\nTask:Listen to music\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['freezer', 'walllamp', 'bathroom', 'drawing', 'orchid', 'floor', 'ceiling', 'video_game_console', 'desk', 'keyboard', 'stovefan', 'ceilinglamp', 'tvstand', 'mat', 'window', 'couch', 'pillow', 'wall', 'powersocket', 'video_game_controller', 'television', 'food_rice', 'ice', 'curtain', 'doorjamb', 'dresser', 'door', 'bathroom_cabinet', 'table', 'laser_pointer']\nTask:Play games\nresponse:\n{\n    \"thoughts\": Turn on game.  Use controller,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[PLUGIN] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[WALK] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['sponge', 'glue', 'toilet', 'chair', 'detergent', 'dough', 'drawing', 'orchid', 'hanger', 'floor', 'ceiling', 'keyboard', 'alcohol', 'stovefan', 'ceilinglamp', 'couch', 'microphone', 'wall', 'nightstand', 'photoframe', 'coffe_maker', 'coffee_filter', 'doorjamb', 'kitchen_counter', 'hairbrush', 'cupboard', 'home_office', 'dishwasher', 'coffee', 'shoe_rack']\nTask:Make coffee\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'freezer', 'walllamp', 'bathroom', 'dough', 'knife', 'orchid', 'thread', 'computer', 'ceilinglamp', 'deck_of_cards', 'shower', 'clothes_socks', 'food_noodles', 'dustpan', 'nightstand', 'photoframe', 'light_bulb', 'television', 'coffee_filter', 'mirror', 'curtain', 'doorjamb', 'laundry_detergent', 'sink', 'bag', 'table', 'soap', 'clothes_shirt', 'creditcard']\nTask:Look at mirror\nresponse:\n{\n    \"thoughts\": I look at my reflection to check my cleanliness.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <mirror>', '[FIND] <mirror>', '[TURNTO] <mirror>', '[LOOKAT] <mirror>']\n}\n", "input": "\nScene_Objects:['microwave', 'dog', 'walllamp', 'cat', 'knifeblock', 'drawing', 'bills', 'floor', 'ceiling', 'clothes_jacket', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'iron', 'dish_soap', 'food_noodles', 'mousepad', 'couch', 'wall', 'nightstand', 'mouthwash', 'curtain', 'mouse', 'kitchen_counter', 'cupboard', 'conditioner', 'door', 'sink', 'dishwasher']\nTask:Wash dishes by hand\nresponse:\n", "output": {"thoughts": "Walk to Kitchen, find sink, find dishes and dish soap. Put soap on plate. open faucet, rinse dishes close faucet.", "actions": ["[WALK] <dining_room>", "[WALK] <sink>", "[FIND] <sink>", "[FIND] <plate>", "[GRAB] <plate>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[PUTBACK] <dish_soap> <plate>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[RINSE] <plate>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'microwave', 'walllamp', 'trashcan', 'drawing', 'wallshelf', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'bookshelf', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'keys', 'television', 'curtain', 'doorjamb', 'towel_rack', 'mouse', 'door', 'light', 'table']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": I want to relax on the sofa to some relaxing music in the living room.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[WALK] <stereo>', '[PLUGIN] <stereo>', '[SWITCHON] <stereo>', '[WALK] <couch>', '[SIT] <couch>', '[LIE] <couch>']\n}\n", "input": "\nScene_Objects:['sponge', 'toilet', 'freezer', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'keyboard', 'ceilinglamp', 'mat', 'shower', 'food_noodles', 'couch', 'towel', 'wall', 'powersocket', 'oven', 'cutting_board', 'photoframe', 'newspaper', 'water', 'food_donut', 'curtain', 'doorjamb', 'headset', 'door', 'bathroom_cabinet', 'light', 'soap', 'tooth_paste']\nTask:Take shower\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'pot', 'water_glass', 'tablelamp', 'microwave', 'chair', 'freezer', 'drawing', 'orchid', 'floor', 'ceiling', 'phone', 'tea_bag', 'toaster', 'stovefan', 'mat', 'shower', 'faucet', 'ceilinglamp', 'oil', 'wall', 'oven', 'powersocket', 'coffe_maker', 'food_food', 'water', 'ice', 'tray', 'doorjamb', 'towel_rack', 'coffee_pot', 'kitchen_counter', 'cupboard', 'door', 'sink', 'bag', 'table', 'dishwasher', 'light']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Going to the kitchen to get a drink of water.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <faucet>', '[SWITCHON] <faucet>', '[FIND] <water>', '[FIND] <sink>', '[PUTBACK] <water_glass> <sink>', '[GRAB] <water_glass>', '[SWITCHOFF] <faucet>', '[DRINK] <water_glass>', '[FIND] <kitchen_counter>', '[PUTBACK] <water_glass> <kitchen_counter>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'toilet', 'chair', 'freezer', 'detergent', 'food_butter', 'wallshelf', 'hanger', 'phone', 'character', 'desk', 'remote_control', 'button', 'piano_bench', 'toaster', 'mat', 'tvstand', 'picture', 'oil', 'couch', 'clothes_pants', 'pillow', 'towel', 'wall', 'novel', 'razor', 'diary', 'conditioner', 'table', 'coffee']\nTask:Change TV channel\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['toilet', 'detergent', 'drawing', 'orchid', 'cpuscreen', 'hanger', 'bathroom_counter', 'floor', 'character', 'desk', 'keyboard', 'thread', 'table_cloth', 'tvstand', 'balanceball', 'shower', 'mousepad', 'couch', 'wall', 'photoframe', 'bed', 'toilet_paper', 'food_onion', 'towel_rack', 'mouse', 'kitchen_counter', 'cd', 'hairbrush', 'bathroom_cabinet', 'light']\nTask:Go to toilet\nresponse:\n{\n    \"thoughts\": walk to bathroom , run to toilet,\n    \"actions\": ['[WALK] <bathroom>', '[RUN] <toilet>']\n}\n", "input": "\nScene_Objects:['pot', 'food_pizza', 'food_salt', 'microwave', 'freezer', 'orchid', 'drawing', 'hanger', 'button', 'table_cloth', 'tvstand', 'homework', 'couch', 'dining_room', 'nightstand', 'keys', 'coffe_maker', 'television', 'oven_mitts', 'curtain', 'doorjamb', 'diary', 'cards', 'kitchen_counter', 'comb', 'dresser', 'food_steak', 'home_office', 'light', 'clothes_skirt']\nTask:Pet cat\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['walllamp', 'orchid', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'window', 'couch', 'clothes_hat', 'pillow', 'wall', 'nightstand', 'powersocket', 'photoframe', 'newspaper', 'television', 'curtain', 'doorjamb', 'door', 'home_office', 'light', 'table']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": walk to living room. look at remote control. grab remote control. plug in television. switch on television. lie in sofa. point at remote control. watch television.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[TURNTO] <remote_control>', '[LOOKAT] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[LIE] <couch>', '[TURNTO] <remote_control>', '[POINTAT] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['sponge', 'spectacles', 'pot', 'microwave', 'knifeblock', 'floor', 'ceiling', 'folder', 'character', 'toaster', 'plate', 'drying_rack', 'faucet', 'dish_soap', 'couch', 'wall', 'powersocket', 'food_cheese', 'photoframe', 'bed', 'food_food', 'mouse', 'kitchen_counter', 'cupboard', 'door', 'sink', 'hairdryer', 'light', 'dirt', 'coffee']\nTask:Wash dishes by hand\nresponse:\n", "output": {"thoughts": "I walk in to the Kitchen. I find a plate, a sponge, and the dish soap. I find the faucet. I turn the faucet on. I pour water on the sponge and plate. I add dish soap to the sponge. I put the dish soap back. I scrub the plate. I rinse the plate. I place the plate on the drying rack. I rinse the sponge. I turn the faucet off.", "actions": ["[WALK] <dining_room>", "[WALK] <faucet>", "[FIND] <faucet>", "[SWITCHON] <faucet>", "[FIND] <sponge>", "[GRAB] <sponge>", "[RINSE] <sponge>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[POUR] <dish_soap> <sponge>", "[PUTOBJBACK] <dish_soap>", "[FIND] <plate>", "[GRAB] <plate>", "[WASH] <plate>", "[RINSE] <plate>", "[FIND] <drying_rack>", "[PUTBACK] <plate> <plate>", "[RINSE] <sponge>", "[PUTOBJBACK] <sponge>", "[SWITCHOFF] <faucet>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'filing_cabinet', 'bathroom', 'detergent', 'food_butter', 'drawing', 'wallshelf', 'floor', 'desk', 'bookshelf', 'plate', 'faucet', 'picture', 'iron', 'window', 'dish_soap', 'food_jam', 'wall', 'nightstand', 'toy', 'cutting_board', 'food_food', 'television', 'curtain', 'pajamas', 'conditioner', 'light', 'dishwasher', 'tooth_paste', 'shoe_rack']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Go to the kitchen.  Find the dishwasher.  Open the dishwasher.  Find the plates.  Load the plates into the dishwasher.  Find the soap.  Load the soap into the dishwasher.  Close the dishwasher.  Turn on the dishwasher.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['sponge', 'sheets', 'filing_cabinet', 'crayon', 'toilet', 'bathroom_counter', 'ceiling', 'folder', 'shower', 'iron', 'window', 'mousepad', 'food_peanut_butter', 'pillow', 'wall', 'oven', 'toy', 'basket_for_clothes', 'photoframe', 'novel', 'coffe_maker', 'food_food', 'tray', 'cd', 'dishrack', 'door', 'napkin', 'light', 'dishwasher', 'board_game']\nTask:Read book\nresponse:\n", "output": {"thoughts": "pick up your book and read it", "actions": ["[WALK] <bedroom>", "[WALK] <novel>", "[GRAB] <novel>", "[READ] <novel>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'walllamp', 'drawing', 'hanger', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'laptop', 'faucet', 'mat', 'closetdrawer', 'teeth', 'dining_room', 'wall', 'pasta', 'toy', 'shelf', 'standingmirror', 'novel', 'check', 'television', 'curtain', 'console', 'dresser', 'napkin', 'table', 'light', 'scrabble', 'coffee']\nTask:Look at painting\nresponse:\n{\n    \"thoughts\": Walk to the painting.  Look up at the painting.  Admire it on the wall.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'microwave', 'chair', 'dog', 'toothbrush', 'knifeblock', 'wallshelf', 'hanger', 'bathroom_counter', 'floor', 'phone', 'ceiling', 'character', 'desk', 'mat', 'tvstand', 'shower', 'homework', 'dining_room', 'wall', 'bed', 'clothes_gloves', 'toothbrush_holder', 'after_shave', 'doorjamb', 'mouse', 'pencil', 'cd', 'tooth_paste', 'shoe_rack']\nTask:Wash teeth\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'scissors', 'walllamp', 'needle', 'wallshelf', 'cpuscreen', 'hanger', 'bedroom', 'keyboard', 'bookmark', 'stovefan', 'shower', 'oil', 'dining_room', 'wall', 'powersocket', 'bench', 'love_seat', 'standingmirror', 'novel', 'coffe_maker', 'check', 'after_shave', 'towel_rack', 'mouse', 'pencil', 'kitchen_counter', 'maindoor', 'bathtub', 'soap']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']\n}\n", "input": "\nScene_Objects:['fork', 'juice', 'food_salt', 'measuring_cup', 'chair', 'detergent', 'milk', 'drawing', 'kitchen_cabinet', 'floor', 'shampoo', 'dvd_player', 'keyboard', 'computer', 'table_cloth', 'stovefan', 'ceilinglamp', 'plate', 'tvstand', 'candle', 'towel', 'food_cheese', 'light_bulb', 'television', 'razor', 'curtain', 'kitchen_counter', 'headset', 'table', 'soap']\nTask:Set up table\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'food_pizza', 'tablelamp', 'food_ice_cream', 'crayon', 'shampoo', 'keyboard', 'mail', 'bookmark', 'stovefan', 'faucet', 'pillow', 'dining_room', 'broom', 'wall', 'love_seat', 'photoframe', 'novel', 'food_food', 'wine', 'tray', 'after_shave', 'shaving_cream', 'kettle', 'headset', 'pajamas', 'laundry_detergent', 'door', 'bathroom_cabinet', 'shoe_rack']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Obtain a book from the book shelf. Sit in the easy chair.  Read the book.  Mark the stopping point with a bookmark.  Put the book back on the book shelf.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <love_seat>', '[SIT] <love_seat>', '[READ] <novel>', '[FIND] <bookmark>', '[GRAB] <bookmark>', '[PUTBACK] <bookmark> <novel>', '[PUTOBJBACK] <novel>']\n}\n", "input": "\nScene_Objects:['food_salt', 'ceiling', 'phone', 'bookshelf', 'ceilinglamp', 'shoe-shine_kit', 'tvstand', 'homework', 'mousepad', 'food_jam', 'form', 'pillow', 'dining_room', 'wall', 'powersocket', 'bed', 'television', 'tray', 'curtain', 'doorjamb', 'pencil', 'dresser', 'controller', 'laundry_detergent', 'door', 'napkin', 'light', 'dishwasher', 'table', 'teeth']\nTask:Pick up phone\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'tea', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'computer', 'piano_bench', 'mat', 'shoe-shine_kit', 'balanceball', 'oil', 'clothes_hat', 'dining_room', 'wall', 'powersocket', 'photoframe', 'bed', 'food_food', 'mouthwash', 'doorjamb', 'towel_rack', 'vacuum_cleaner', 'door', 'home_office', 'light', 'soap']\nTask:Turn on light\nresponse:\n{\n    \"thoughts\": switching on the light,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>']\n}\n", "input": "\nScene_Objects:['sheets', 'food_pizza', 'toilet', 'freezer', 'ground_coffee', 'bathroom', 'drawing', 'knifeblock', 'floor', 'ceiling', 'desk', 'bookshelf', 'alcohol', 'mat', 'shower', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'wall', 'powersocket', 'photoframe', 'food_food', 'television', 'doorjamb', 'mouse', 'door', 'light', 'colander', 'coffee']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'toilet', 'bathroom', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'character', 'desk', 'tea_bag', 'remote_control', 'ceilinglamp', 'tvstand', 'balanceball', 'picture', 'window', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'cutting_board', 'novel', 'check', 'television', 'curtain', 'conditioner', 'hairdryer', 'clothes_dress', 'table']\nTask:Watch TV\nresponse:\n{\n    \"thoughts\": watching TV from sofa,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[FIND] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[DROP] <remote_control>', '[TURNTO] <television>', '[LOOKAT] <television>']\n}\n", "input": "\nScene_Objects:['pot', 'mop', 'microwave', 'walllamp', 'detergent', 'food_carrot', 'knifeblock', 'wallshelf', 'hanger', 'floor', 'ceiling', 'keyboard', 'stovefan', 'toaster', 'stereo', 'window', 'oil', 'clothes_socks', 'wall', 'oven', 'food_vegetable', 'bed', 'photoframe', 'television', 'food_donut', 'water', 'tray', 'kitchen_counter', 'cupboard', 'dishwasher']\nTask:Cook some food\nresponse:\n", "output": {"thoughts": "walk to kicthen , find stove , find cooking pot , find vegetables , find water  ,put vegetables in cooking pot, pour water to cooking pot,put cooking pot on stove, switch on stove", "actions": ["[WALK] <dining_room>", "[WALK] <oven>", "[FIND] <oven>", "[FIND] <pot>", "[FIND] <food_vegetable>", "[FIND] <water>", "[GRAB] <water>", "[WASH] <food_vegetable>", "[POUR] <water> <pot>", "[FIND] <pot>", "[GRAB] <pot>", "[PUTBACK] <pot> <oven>", "[SWITCHON] <oven>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'mousepad', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'curtain', 'mouse', 'door', 'hairdryer', 'sink', 'food_steak', 'light', 'dishwasher', 'spoon', 'table', 'board_game']\nTask:Write  school paper\nresponse:\n{\n    \"thoughts\": Writing  and drafting a paper for  class work,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'toilet', 'chair', 'walllamp', 'cat', 'food_carrot', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'bookshelf', 'computer', 'laptop', 'ceilinglamp', 'homework', 'mousepad', 'wall', 'coffe_maker', 'video_game_controller', 'ice', 'doorjamb', 'diary', 'mouse', 'kitchen_counter', 'shoes', 'comb', 'dresser', 'hairdryer']\nTask:Write an email\nresponse:\n", "output": {"thoughts": "I open my laptop and then login to Windows. Then I open Google Chrome, and type gmail.com into the address bar. My email automatically logs in, then I click the Compose button, type in the address of the recipient, then the subject of the email, and then start typing my email", "actions": ["[WALK] <laptop>", "[SWITCHON] <laptop>", "[FIND] <keyboard>", "[TYPE] <keyboard>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'microwave', 'toilet', 'walllamp', 'bathroom', 'drawing', 'orchid', 'knifeblock', 'floor', 'ceiling', 'bookshelf', 'stovefan', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'toy', 'novel', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'kitchen_counter', 'shoes', 'cupboard', 'door', 'home_office', 'table', 'light']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Go to the living room and find the book you want to read. Take it and then go to the couch. Sit on it, open the book and start reading.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <novel>', '[FIND] <novel>', '[GRAB] <novel>', '[FIND] <couch>', '[SIT] <couch>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['spectacles', 'filing_cabinet', 'blender', 'walllamp', 'orchid', 'cpuscreen', 'hanger', 'floor', 'bedroom', 'bookshelf', 'stovefan', 'food_peanut_butter', 'clothes_hat', 'clothes_pants', 'dining_room', 'nightstand', 'wall_clock', 'video_game_controller', 'food_donut', 'curtain', 'kettle', 'shoes', 'dresser', 'cupboard', 'hairbrush', 'controller', 'home_office', 'light', 'clothes_skirt', 'soap']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "Walk into the living room. Walk up to the radio. Turn on the radio. Listen to the radio.", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'microwave', 'orchid', 'drawing', 'hanger', 'floor', 'phone', 'character', 'keyboard', 'toaster', 'plate', 'faucet', 'shower', 'window', 'mousepad', 'closetdrawer', 'dining_room', 'oven', 'powersocket', 'cup', 'bed', 'food_food', 'coffe_maker', 'tray', 'doorjamb', 'dresser', 'sink', 'bathtub', 'home_office', 'table']\nTask:Drink\nresponse:\n{\n    \"thoughts\": I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <cup>', '[FIND] <cup>', '[GRAB] <cup>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <cup>', '[DRINK] <cup>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'bathroom', 'knifeblock', 'cpuscreen', 'hanger', 'bathroom_counter', 'ceiling', 'folder', 'character', 'keyboard', 'bookshelf', 'envelope', 'computer', 'dining_room', 'wall', 'nightstand', 'cup', 'clothes_gloves', 'light_bulb', 'check', 'curtain', 'pencil', 'kitchen_counter', 'controller', 'sink', 'napkin', 'clothes_skirt', 'tooth_paste']\nTask:Browse internet\nresponse:\n", "output": {"thoughts": "I turn on computer. I use keyboard to type. I open browser. I search.", "actions": ["[WALK] <bedroom>", "[WALK] <computer>", "[FIND] <keyboard>", "[TYPE] <keyboard>", "[TURNTO] <computer>", "[LOOKAT] <computer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['freezer', 'cat', 'drawing', 'knife', 'knifeblock', 'hanger', 'floor', 'bedroom', 'keyboard', 'computer', 'piano_bench', 'ceilinglamp', 'faucet', 'iron', 'window', 'mousepad', 'couch', 'form', 'dining_room', 'wall', 'oven', 'box', 'newspaper', 'bed', 'novel', 'toilet_paper', 'television', 'tray', 'sink', 'table']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": I walk to the living room.  I locate the cat.  I walk to the couch and sit down beside the cat.  I pet the cat.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[WALK] <couch>', '[SIT] <couch>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'beer', 'measuring_cup', 'microwave', 'dog', 'orchid', 'wallshelf', 'floor', 'bedroom', 'computer', 'mop_bucket', 'ceilinglamp', 'faucet', 'electric_shaver', 'couch', 'food_peanut_butter', 'broom', 'cutting_board', 'photoframe', 'newspaper', 'mouthwash', 'ice', 'tray', 'curtain', 'kitchen_counter', 'shoes', 'headset', 'bathroom_cabinet', 'board_game']\nTask:Pet cat\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'crayon', 'toilet', 'chair', 'bathroom', 'orchid', 'floor', 'ceiling', 'character', 'bedroom', 'desk', 'computer', 'tvstand', 'faucet', 'stereo', 'food_orange', 'photoframe', 'novel', 'television', 'curtain', 'doorjamb', 'diary', 'towel_rack', 'mouse', 'shoes', 'dresser', 'cupboard', 'sink', 'bathtub', 'home_office']\nTask:Get dressed\nresponse:\n{\n    \"thoughts\": I get dressed in my bedroom in the mornings.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[PUTON] <shoes>']\n}\n", "input": "\nScene_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']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "walk over and pick up the phone", "actions": ["[WALK] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'mop', 'microwave', 'freezer', 'walllamp', 'detergent', 'toothbrush', 'orchid', 'drawing', 'clothes_underwear', 'floor', 'thread', 'mat', 'closetdrawer', 'wall', 'nightstand', 'toy', 'standingmirror', 'light_bulb', 'novel', 'check', 'tray', 'cards', 'mouse', 'pencil', 'vacuum_cleaner', 'headset', 'maindoor', 'napkin', 'light']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Walk to the Living Room. Look at the Cabinet. Find a Textbook. Grab the textbook. Open the Textbook. Read the textbook.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <filing_cabinet>', '[FIND] <filing_cabinet>', '[TURNTO] <filing_cabinet>', '[LOOKAT] <filing_cabinet>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['pot', 'freezer', 'blow_dryer', 'bathroom', 'nail_polish', 'drawing', 'knife', 'cpuscreen', 'character', 'bookshelf', 'table_cloth', 'mop_bucket', 'bookmark', 'faucet', 'homework', 'nightstand', 'wall', 'novel', 'check', 'coffee_filter', 'coffee_pot', 'shaving_cream', 'kitchen_counter', 'pajamas', 'cupboard', 'clothes_dress', 'laundry_detergent', 'napkin', 'table', 'washing_machine']\nTask:Wash clothes\nresponse:\n", "output": {"thoughts": "walk to kitchen. grab clothes_dress. look at washing machine. open washing machine. put clothes_dress on washing machine. close washing machine. switch on washing machine. switch off washing machine.", "actions": ["[WALK] <dining_room>", "[WALK] <clothes_dress>", "[FIND] <clothes_dress>", "[GRAB] <clothes_dress>", "[FIND] <washing_machine>", "[TURNTO] <washing_machine>", "[LOOKAT] <washing_machine>", "[OPEN] <washing_machine>", "[PUTBACK] <clothes_dress> <washing_machine>", "[CLOSE] <washing_machine>", "[SWITCHON] <washing_machine>", "[SWITCHOFF] <washing_machine>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['measuring_cup', 'mop', 'walllamp', 'clothes_underwear', 'hanger', 'floor', 'ceiling', 'dvd_player', 'desk', 'tvstand', 'window', 'clothes_socks', 'closetdrawer', 'oil', 'dining_room', 'wall', 'toy', 'photoframe', 'television', 'curtain', 'rag', 'doorjamb', 'console', 'kitchen_counter', 'shoes', 'dresser', 'pajamas', 'bathroom_cabinet', 'table', 'tooth_paste']\nTask:Put away shoes\nresponse:\n{\n    \"thoughts\": Pick up shoes from entry hall. Open entry way closet. Put shoes in closet. Close closet door.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <shoes>', '[FIND] <shoes>', '[GRAB] <shoes>', '[FIND] <dresser>', '[OPEN] <dresser>', '[PUTIN] <shoes> <dresser>', '[CLOSE] <dresser>']\n}\n", "input": "\nScene_Objects:['sheets', 'filing_cabinet', 'mop', 'bathroom', 'dough', 'knifeblock', 'hanger', 'keyboard', 'alcohol', 'toaster', 'shower', 'foundation', 'couch', 'bowl', 'wall', 'pasta', 'basket_for_clothes', 'check', 'television', 'razor', 'tray', 'doorjamb', 'chessboard', 'dishrack', 'hairbrush', 'napkin', 'bathroom_cabinet', 'light', 'dishwasher', 'table']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "go to living room, find phone, pick up phone", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[FIND] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'toilet', 'freezer', 'ground_coffee', 'ceilingfan', 'drawing', 'orchid', 'floor', 'ceiling', 'character', 'video_game_console', 'table_cloth', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'dustpan', 'pillow', 'wall', 'cup', 'video_game_controller', 'television', 'curtain', 'dishrack', 'napkin', 'table', 'vase', 'scrabble', 'shoe_rack']\nTask:Play games\nresponse:\n{\n    \"thoughts\": Turn on game.  Use controller,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <television>', '[PLUGIN] <television>', '[SWITCHON] <television>', '[FIND] <video_game_console>', '[PLUGIN] <video_game_console>', '[SWITCHON] <video_game_console>', '[FIND] <video_game_console>', '[FIND] <video_game_controller>', '[GRAB] <video_game_controller>', '[WALK] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['pot', 'toilet', 'freezer', 'walllamp', 'drawing', 'knifeblock', 'floor', 'ceiling', 'food_chicken', 'food_cake', 'stovefan', 'mat', 'toaster', 'shower', 'food_noodles', 'oil', 'nightstand', 'wall', 'powersocket', 'oven', 'cup', 'photoframe', 'food_food', 'tray', 'doorjamb', 'kitchen_counter', 'cupboard', 'door', 'light', 'dishwasher']\nTask:Cook some food\nresponse:\n", "output": {"thoughts": "I walk in the kitchen, I open the fridge and remove the Chicken. I grab frying fan and put it on stove. I put chicken in the frying pan and I cook food.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_chicken>", "[GRAB] <food_chicken>", "[FIND] <pot>", "[GRAB] <pot>", "[FIND] <oven>", "[PUTBACK] <pot> <oven>", "[PUTBACK] <food_chicken> <oven>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'filing_cabinet', 'juice', 'microwave', 'knifeblock', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'computer', 'piano_bench', 'toaster', 'ceilinglamp', 'plate', 'faucet', 'stovefan', 'tvstand', 'dish_soap', 'wall', 'pasta', 'coffee_filter', 'tray', 'doorjamb', 'mouse', 'kitchen_counter', 'shoes', 'dishrack', 'cupboard', 'sink', 'scrabble']\nTask:Wash dishes\nresponse:\n{\n    \"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.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <sink>', '[SWITCHOFF] <faucet>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[FIND] <sponge>', '[GRAB] <sponge>', '[POUR] <dish_soap> <sponge>', '[PUTOBJBACK] <dish_soap>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[PUTOBJBACK] <plate>', '[SWITCHON] <faucet>', '[RINSE] <sponge>', '[PUTOBJBACK] <sponge>', '[GRAB] <plate>', '[RINSE] <plate>', '[FIND] <dishrack>', '[PUTBACK] <plate> <dishrack>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishrack>', '[SWITCHOFF] <faucet>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'blender', 'chair', 'walllamp', 'blow_dryer', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'ceiling', 'thread', 'ceilinglamp', 'laptop', 'faucet', 'mousepad', 'couch', 'candle', 'food_jam', 'pillow', 'wall', 'nightstand', 'tape', 'television', 'tray', 'after_shave', 'food_onion', 'shoes', 'cupboard']\nTask:Relax on sofa\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'band-aids', 'walllamp', 'drawing', 'food_egg', 'bathroom_counter', 'ceiling', 'stamp', 'desk', 'cleaning_solution', 'computer', 'stovefan', 'deck_of_cards', 'faucet', 'tvstand', 'window', 'couch', 'wall', 'nightstand', 'coffe_maker', 'television', 'mirror', 'after_shave', 'paper_towel', 'clothes_dress', 'sink', 'bag', 'bathroom_cabinet', 'dishwasher', 'laser_pointer']\nTask:Clean mirror\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'tablelamp', 'chair', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'phone', 'bedroom', 'button', 'plate', 'dish_soap', 'wall', 'nightstand', 'food_cheese', 'photoframe', 'newspaper', 'coffe_maker', 'check', 'tray', 'kettle', 'pencil', 'kitchen_counter', 'comb', 'cupboard', 'door', 'table', 'dishwasher', 'light']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "Go to kitchen to put dirty dishs into dishwasher with soap to clean the dirty dishes", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[OPEN] <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[PUTBACK] <dish_soap> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'spectacles', 'microwave', 'walllamp', 'drawing', 'orchid', 'hanger', 'floor', 'character', 'desk', 'alcohol', 'stovefan', 'ceilinglamp', 'mat', 'window', 'couch', 'pillow', 'wall', 'oven', 'powersocket', 'cutting_board', 'photoframe', 'light_bulb', 'television', 'curtain', 'kettle', 'napkin', 'bathroom_cabinet', 'table', 'creditcard']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": walk to living room, walk to sofa, sit on sofa.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[SIT] <couch>']\n}\n", "input": "\nScene_Objects:['spectacles', 'food_salt', 'microwave', 'walllamp', 'dough', 'hanger', 'ceiling', 'phone', 'character', 'keyboard', 'bookmark', 'toaster', 'mat', 'tvstand', 'stereo', 'window', 'oil', 'food_peanut_butter', 'tape', 'check', 'video_game_controller', 'razor', 'oven_mitts', 'food_rice', 'curtain', 'kitchen_counter', 'hairbrush', 'food_steak', 'bathroom_cabinet', 'home_office']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "I walk into the bedroom. I walk to stereo. I turn on stereo.", "actions": ["[WALK] <bedroom>", "[WALK] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'desk', 'keyboard', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'stereo', 'shower', 'mousepad', 'closetdrawer', 'dustpan', 'wall', 'powersocket', 'box', 'television', 'fax_machine', 'doorjamb', 'mouse', 'dresser', 'light', 'table', 'printing_paper']\nTask:Print out papers\nresponse:\n{\n    \"thoughts\": Turn on printer and fill with blank paper. Use computer to click on printing option. Take printed page out of print.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <fax_machine>', '[FIND] <fax_machine>', '[SWITCHON] <fax_machine>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[PUTBACK] <printing_paper> <fax_machine>', '[FIND] <computer>', '[FIND] <mouse>', '[GRAB] <mouse>', '[GRAB] <printing_paper>']\n}\n", "input": "\nScene_Objects:['fork', 'pot', 'filing_cabinet', 'tablelamp', 'blender', 'beer', 'toilet', 'jelly', 'freezer', 'blow_dryer', 'detergent', 'orchid', 'knifeblock', 'wallshelf', 'cpuscreen', 'bathroom_counter', 'floor', 'mail', 'computer', 'bookmark', 'stereo', 'window', 'couch', 'microphone', 'check', 'television', 'rag', 'pencil', 'controller', 'dishwasher']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Pet Cat", "actions": ["[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[WALK] <cat>", "[TURNTO] <cat>", "[LOOKAT] <cat>", "[TOUCH] <cat>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'bathroom', 'knife', 'bathroom_counter', 'floor', 'shampoo', 'ceiling', 'stovefan', 'mat', 'faucet', 'mousepad', 'couch', 'food_peanut_butter', 'dustpan', 'towel', 'wall', 'wall_clock', 'oven', 'novel', 'ice', 'tray', 'rag', 'shoes', 'maindoor', 'sink', 'bathroom_cabinet', 'vase', 'soap', 'tooth_paste', 'hands_both']\nTask:Wash hands\nresponse:\n{\n    \"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.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['filing_cabinet', 'tablelamp', 'toilet', 'walllamp', 'detergent', 'orchid', 'floor', 'ceiling', 'keyboard', 'remote_control', 'computer', 'button', 'alcohol', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'nightstand', 'wall', 'check', 'mouthwash', 'television', 'coffe_maker', 'curtain', 'dresser', 'clothes_dress', 'door', 'sink', 'table']\nTask:Change TV channel\nresponse:\n", "output": {"thoughts": "I go to the livingroom. The TV is on. I pick up the remote and press the next channel button. I look at the television, and see that the channel has changed.", "actions": ["[WALK] <home_office>", "[WALK] <television>", "[FIND] <television>", "[TURNTO] <television>", "[LOOKAT] <television>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <button>", "[PUSH] <button>", "[TURNTO] <television>", "[LOOKAT] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'filing_cabinet', 'chair', 'walllamp', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'bedroom', 'desk', 'computer', 'ceilinglamp', 'deck_of_cards', 'stereo', 'window', 'couch', 'clothes_pants', 'wall', 'cup', 'novel', 'toilet_paper', 'television', 'wine', 'kitchen_counter', 'dishrack', 'comb', 'dresser', 'coffee_cup', 'table', 'teeth']\nTask:Relax on sofa\nresponse:\n{\n    \"thoughts\": you walk to the living room, open the door, find a comfy sofa, sit on it, read a book or sip a cup of coffee and relax.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[FIND] <coffee_cup>', '[GRAB] <coffee_cup>', '[SIT] <couch>', '[FIND] <novel>', '[GRAB] <novel>', '[READ] <novel>', '[DRINK] <coffee_cup>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'beer', 'crayon', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'food_cake', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'food_food', 'television', 'curtain', 'pencil', 'kitchen_counter', 'door']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "I walk to the sofa, and lie down on the sofa.", "actions": ["[WALK] <couch>", "[LIE] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['glue', 'mop', 'toilet', 'cat', 'trashcan', 'ceilingfan', 'drawing', 'knifeblock', 'orchid', 'floor', 'ceiling', 'computer', 'clothes_jacket', 'table_cloth', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'window', 'couch', 'wall', 'nightstand', 'food_food', 'mouthwash', 'television', 'food_donut', 'curtain', 'after_shave', 'dresser', 'table']\nTask:Look at painting\nresponse:\n{\n    \"thoughts\": Walk to the painting.  Look up at the painting.  Admire it on the wall.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'juice', 'toilet', 'freezer', 'walllamp', 'detergent', 'milk', 'drawing', 'floor', 'ceiling', 'phone', 'computer', 'toaster', 'mat', 'ceilinglamp', 'shower', 'food_orange', 'pillow', 'dining_room', 'nightstand', 'wall', 'powersocket', 'photoframe', 'newspaper', 'food_food', 'toothbrush_holder', 'doorjamb', 'door', 'sink', 'light']\nTask:Put groceries in Fridge\nresponse:\n", "output": {"thoughts": "I walk to the kitchen, open the fridge and put the groceries in the fridge. Then I close the fridge.", "actions": ["[WALK] <dining_room>", "[WALK] <freezer>", "[FIND] <freezer>", "[OPEN] <freezer>", "[FIND] <food_food>", "[GRAB] <food_food>", "[PUTIN] <food_food> <freezer>", "[CLOSE] <freezer>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['dry_pasta', 'food_ice_cream', 'walllamp', 'nail_polish', 'cat', 'orchid', 'drawing', 'floor', 'ceiling', 'purse', 'alcohol', 'mail', 'table_cloth', 'mat', 'tvstand', 'ceilinglamp', 'window', 'couch', 'pillow', 'towel', 'wall', 'oven', 'cup', 'food_cheese', 'television', 'curtain', 'doorjamb', 'door', 'table', 'clothes_shirt']\nTask:Straighten paintings on wall\nresponse:\n{\n    \"thoughts\": Go up to the painting and tilt it which ever way it is uneven until it looks straight.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <wall>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[WALK] <drawing>', '[FIND] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TOUCH] <drawing>', '[PULL] <drawing>', '[PUSH] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>', '[TURNTO] <drawing>', '[LOOKAT] <drawing>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'measuring_cup', 'microwave', 'orchid', 'knifeblock', 'wallshelf', 'character', 'keyboard', 'stovefan', 'mat', 'closetdrawer', 'dining_room', 'food_kiwi', 'box', 'cup', 'bed', 'coffe_maker', 'television', 'water', 'colander', 'tray', 'curtain', 'kitchen_counter', 'cd', 'cupboard', 'door', 'bag', 'soap', 'creditcard']\nTask:Wash hands\nresponse:\n", "output": {"thoughts": "put soap on hands, scrub it and rinse with water", "actions": ["[WALK] <bathroom>", "[WALK] <soap>", "[FIND] <soap>", "[SCRUB] <soap>", "[FIND] <water>", "[RINSE] <water>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'toilet', 'chair', 'bathroom', 'detergent', 'orchid', 'knifeblock', 'drawing', 'bathroom_counter', 'bedroom', 'keyboard', 'button', 'toaster', 'tvstand', 'food_noodles', 'pillow', 'check', 'television', 'oven_mitts', 'wine', 'curtain', 'rag', 'doorjamb', 'kettle', 'mouse', 'pencil', 'hairbrush', 'food_steak', 'home_office', 'dishwasher']\nTask:Pet cat\nresponse:\n{\n    \"thoughts\": Find the cat; pet the cat by touching it,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <cat>', '[FIND] <cat>', '[TOUCH] <cat>']\n}\n", "input": "\nScene_Objects:['food_bread', 'microwave', 'toilet', 'walllamp', 'knifeblock', 'wallshelf', 'floor', 'shampoo', 'character', 'computer', 'bookmark', 'toaster', 'plate', 'faucet', 'shoe-shine_kit', 'dish_soap', 'wall', 'toy', 'light_bulb', 'coffe_maker', 'rag', 'kitchen_counter', 'hairbrush', 'cupboard', 'dresser', 'controller', 'sink', 'home_office', 'table', 'dishwasher']\nTask:Wash dishes by hand\nresponse:\n", "output": {"thoughts": "Make some dish water, grab a dish rag, put dishes in dish water and wash.", "actions": ["[RUN] <sink>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[FIND] <plate>", "[PUTBACK] <dish_soap> <plate>", "[RINSE] <dish_soap>", "[FIND] <plate>", "[WASH] <plate>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_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']\nTask:Read book\nresponse:\n{\n    \"thoughts\": Walk over to the bookshelf. Pick storybook off the shelf. Sit on bed. Open storybook and read out loud.,\n    \"actions\": ['[WALK] <bedroom>', '[WALK] <bookshelf>', '[FIND] <novel>', '[GRAB] <novel>', '[TURNTO] <novel>', '[LOOKAT] <novel>', '[WALK] <bed>', '[SIT] <bed>', '[READ] <novel>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'pot', 'filing_cabinet', 'food_ice_cream', 'jelly', 'bathroom', 'orchid', 'knifeblock', 'wallshelf', 'bathroom_counter', 'desk', 'keyboard', 'ceilinglamp', 'iron', 'stereo', 'closetdrawer', 'clothes_pants', 'food_jam', 'cup', 'photoframe', 'toothbrush_holder', 'tray', 'curtain', 'centerpiece', 'coffee_pot', 'kitchen_counter', 'door', 'spoon', 'dishwasher', 'clothes_shirt']\nTask:Pick up phone\nresponse:\n", "output": {"thoughts": "Enter living room. Walk to telephone. Pick up from hook.", "actions": ["[WALK] <home_office>", "[WALK] <phone>", "[GRAB] <phone>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['mop', 'chair', 'jelly', 'walllamp', 'drawing', 'wallshelf', 'food_egg', 'hanger', 'floor', 'ceiling', 'character', 'desk', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'food_rice', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'coffee']\nTask:Watch  horror  movie\nresponse:\n{\n    \"thoughts\": I would  find something  scary  to  watch on dvd,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']\n}\n", "input": "\nScene_Objects:['sheets', 'water_glass', 'pot', 'glue', 'filing_cabinet', 'knife', 'wallshelf', 'bathroom_counter', 'stamp', 'bedroom', 'keyboard', 'clothes_jacket', 'piano_bench', 'electric_shaver', 'food_jam', 'cutting_board', 'novel', 'check', 'coffee_filter', 'water', 'ice', 'curtain', 'food_onion', 'pencil', 'kitchen_counter', 'cd', 'headset', 'dresser', 'door', 'light']\nTask:Drink\nresponse:\n", "output": {"thoughts": "Drinking a glass of water", "actions": ["[WALK] <dining_room>", "[WALK] <water>", "[FIND] <water>", "[GRAB] <water>", "[FIND] <water_glass>", "[POUR] <water> <water_glass>", "[FIND] <water_glass>", "[GRAB] <water_glass>", "[DRINK] <water_glass>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'pot', 'food_bread', 'tablelamp', 'scissors', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'tvstand', 'faucet', 'dish_soap', 'bowl', 'wall', 'oven', 'cup', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'curtain', 'maindoor', 'table', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Using dishwasher to wash dishes,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['sheets', 'blender', 'food_salt', 'crayon', 'tea', 'cat', 'milk', 'knifeblock', 'hanger', 'shampoo', 'bedroom', 'bookshelf', 'computer', 'brush', 'stovefan', 'toaster', 'foundation', 'window', 'mousepad', 'clothes_pants', 'clothes_hat', 'tape', 'bed', 'coffe_maker', 'food_onion', 'after_shave', 'dresser', 'light', 'dishwasher', 'laser_pointer']\nTask:Pet cat\nresponse:\n", "output": {"thoughts": "Every time this animal is seen, you must approach it and show compassion for it by petting it in a gentle manner.", "actions": ["[WALK] <home_office>", "[WALK] <bedroom>", "[WALK] <bedroom>", "[WALK] <home_office>", "[WALK] <home_office>", "[WALK] <cat>", "[FIND] <cat>", "[FIND] <brush>", "[GRAB] <brush>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tablelamp', 'microwave', 'walllamp', 'bathroom', 'trashcan', 'drawing', 'orchid', 'bathroom_counter', 'floor', 'ceiling', 'bedroom', 'keyboard', 'mat', 'ceilinglamp', 'window', 'mousepad', 'closetdrawer', 'couch', 'pillow', 'wall', 'wall_clock', 'cup', 'video_game_controller', 'television', 'curtain', 'doorjamb', 'cupboard', 'door', 'light', 'table']\nTask:Gaze out window\nresponse:\n{\n    \"thoughts\": Look at the yard from the window,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <window>', '[FIND] <window>', '[TURNTO] <window>', '[LOOKAT] <window>']\n}\n", "input": "\nScene_Objects:['fork', 'filing_cabinet', 'food_pizza', 'knifeblock', 'food_egg', 'hanger', 'phone', 'desk', 'tea_bag', 'purse', 'envelope', 'clothes_jacket', 'table_cloth', 'faucet', 'window', 'closetdrawer', 'clothes_pants', 'food_jam', 'wall', 'basket_for_clothes', 'bed', 'cd', 'comb', 'laundry_detergent', 'clothes_scarf', 'napkin', 'home_office', 'bathroom_cabinet', 'washing_machine', 'teeth']\nTask:Wash clothes\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sponge', 'pot', 'food_bread', 'tablelamp', 'scissors', 'microwave', 'chair', 'walllamp', 'hanger', 'floor', 'food_cake', 'toaster', 'plate', 'shower', 'tvstand', 'faucet', 'dish_soap', 'bowl', 'wall', 'oven', 'cup', 'basket_for_clothes', 'photoframe', 'coffe_maker', 'food_food', 'tray', 'curtain', 'maindoor', 'table', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n{\n    \"thoughts\": Using dishwasher to wash dishes,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[FIND] <bowl>', '[GRAB] <bowl>', '[WALK] <dishwasher>', '[PUTBACK] <bowl> <dishwasher>', '[GRAB] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']\n}\n", "input": "\nScene_Objects:['toilet', 'chair', 'dog', 'ground_coffee', 'detergent', 'floor', 'ceiling', 'shampoo', 'envelope', 'clothes_jacket', 'piano_bench', 'ceilinglamp', 'mat', 'couch', 'dining_room', 'wall', 'coffe_maker', 'food_food', 'television', 'coffee_filter', 'water', 'coffee_pot', 'console', 'kitchen_counter', 'dresser', 'cupboard', 'pajamas', 'bathroom_cabinet', 'light', 'dishwasher']\nTask:Make coffee\nresponse:\n", "output": {"thoughts": "Making Coffee", "actions": ["[WALK] <dining_room>", "[WALK] <coffe_maker>", "[FIND] <coffe_maker>", "[FIND] <water>", "[GRAB] <water>", "[OPEN] <coffe_maker>", "[POUR] <water> <coffe_maker>", "[FIND] <ground_coffee>", "[GRAB] <ground_coffee>", "[FIND] <coffee_filter>", "[GRAB] <coffee_filter>", "[PUTBACK] <coffee_filter> <coffe_maker>", "[PUTBACK] <ground_coffee> <coffe_maker>", "[FIND] <coffee_pot>", "[GRAB] <coffee_pot>", "[PUTBACK] <coffee_pot> <coffe_maker>", "[SWITCHON] <coffe_maker>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['food_bread', 'filing_cabinet', 'tablelamp', 'food_ice_cream', 'beer', 'crayon', 'chair', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'phone', 'desk', 'bedroom', 'bookshelf', 'thread', 'toaster', 'ceilinglamp', 'mousepad', 'closetdrawer', 'pillow', 'wall', 'cup', 'bed', 'keys', 'food_food', 'television', 'food_onion', 'doorjamb', 'mouse', 'home_office']\nTask:Lock door\nresponse:\n{\n    \"thoughts\": Turn the lock.,\n    \"actions\": ['[WALK] <bedroom>']\n}\n", "input": "\nScene_Objects:['fork', 'tablelamp', 'toilet', 'chair', 'walllamp', 'floor', 'ceiling', 'phone', 'keyboard', 'envelope', 'toaster', 'ceilinglamp', 'stereo', 'faucet', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'clothes_gloves', 'novel', 'check', 'video_game_controller', 'television', 'kitchen_counter', 'hairdryer', 'light', 'table']\nTask:Relax on sofa\nresponse:\n", "output": {"thoughts": "Walk to the living room. Walk to the sofa and sit on the sofa.", "actions": ["[WALK] <home_office>", "[WALK] <couch>", "[SIT] <couch>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'tablelamp', 'microwave', 'chair', 'walllamp', 'blow_dryer', 'knifeblock', 'drawing', 'orchid', 'kitchen_cabinet', 'floor', 'ceiling', 'food_cake', 'mat', 'faucet', 'mousepad', 'couch', 'wall', 'oven', 'bench', 'toilet_paper', 'television', 'water', 'drinking_glass', 'curtain', 'kitchen_counter', 'cupboard', 'sink', 'light', 'table']\nTask:Drink\nresponse:\n{\n    \"thoughts\": I go to the kitchen to get a glass from the cabinet. I turn on the faucet and fill up the glass. I take a drink.,\n    \"actions\": ['[WALK] <dining_room>', '[WALK] <kitchen_cabinet>', '[FIND] <kitchen_cabinet>', '[OPEN] <kitchen_cabinet>', '[FIND] <drinking_glass>', '[GRAB] <drinking_glass>', '[WALK] <sink>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[PUTBACK] <drinking_glass> <sink>', '[FIND] <water>', '[GRAB] <drinking_glass>', '[PUTBACK] <drinking_glass> <sink>', '[GRAB] <drinking_glass>', '[DRINK] <drinking_glass>']\n}\n", "input": "\nScene_Objects:['tablelamp', 'chair', 'walllamp', 'milk', 'orchid', 'drawing', 'knifeblock', 'floor', 'ceiling', 'folder', 'computer', 'ceilinglamp', 'tvstand', 'window', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'wall', 'nightstand', 'cup', 'bed', 'television', 'razor', 'toothbrush_holder', 'tray', 'curtain', 'dresser', 'laundry_detergent', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "go to the living room to watch TV", "actions": ["[RUN] <home_office>", "[WALK] <remote_control>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[WALK] <couch>", "[SIT] <couch>", "[FIND] <television>", "[TURNTO] <television>", "[POINTAT] <television>", "[TOUCH] <remote_control>", "[SWITCHON] <television>", "[TURNTO] <television>", "[LOOKAT] <television>", "[WATCH] <television>", "[DROP] <remote_control>", "[TURNTO] <television>", "[LOOKAT] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['sheets', 'filing_cabinet', 'food_pizza', 'walllamp', 'orchid', 'needle', 'cpuscreen', 'bathroom_counter', 'shampoo', 'desk', 'bookshelf', 'computer', 'stovefan', 'ceilinglamp', 'toaster', 'shower', 'faucet', 'couch', 'dining_room', 'cup', 'bed', 'tray', 'curtain', 'wooden_spoon', 'pencil', 'door', 'bathroom_cabinet', 'light', 'dishwasher', 'table']\nTask:Pick up phone\nresponse:\n{\n    \"thoughts\": I walk to the home office. I find the telephone. I pick up the telephone handset.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <phone>', '[FIND] <phone>', '[GRAB] <phone>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'tablelamp', 'chair', 'walllamp', 'orchid', 'floor', 'ceiling', 'phone', 'bookshelf', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'window', 'oil', 'closetdrawer', 'couch', 'pillow', 'dining_room', 'nightstand', 'wall', 'oven', 'bed', 'coffe_maker', 'television', 'curtain', 'dresser', 'door', 'instrument_guitar', 'table']\nTask:Watch TV\nresponse:\n", "output": {"thoughts": "I go to the living room, switch on the tv, take the remote and sit on the sofa.", "actions": ["[WALK] <home_office>", "[WALK] <remote_control>", "[FIND] <remote_control>", "[GRAB] <remote_control>", "[FIND] <couch>", "[SIT] <couch>", "[FIND] <television>", "[SWITCHON] <television>", "[TURNTO] <television>", "[WATCH] <television>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['spectacles', 'tablelamp', 'chair', 'freezer', 'walllamp', 'drawing', 'wallshelf', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'tvstand', 'laptop', 'mousepad', 'couch', 'pillow', 'wall', 'oven', 'tape', 'photoframe', 'television', 'doorjamb', 'mouse', 'kitchen_counter', 'door', 'light']\nTask:Use laptop\nresponse:\n{\n    \"thoughts\": Sit down on a couch and perform tasks such as navigating the internet on a laptop,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <laptop>', '[SWITCHON] <laptop>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <keyboard>', '[LOOKAT] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <laptop>', '[LOOKAT] <laptop>']\n}\n", "input": "\nScene_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']\nTask:Wash clothes\nresponse:\n", "output": {"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>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['filing_cabinet', 'food_ice_cream', 'chair', 'wallshelf', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'stovefan', 'mat', 'faucet', 'shower', 'window', 'mousepad', 'couch', 'towel', 'wall', 'bed', 'photoframe', 'curtain', 'after_shave', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'light', 'soap', 'hands_both', 'shoe_rack']\nTask:Wash hands\nresponse:\n{\n    \"thoughts\": Wash hands with soap and hot water,\n    \"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>']\n}\n", "input": "\nScene_Objects:['juice', 'microwave', 'toilet', 'ground_coffee', 'bathroom', 'cpuscreen', 'hanger', 'floor', 'phone', 'character', 'bookshelf', 'computer', 'table_cloth', 'mat', 'tvstand', 'shower', 'couch', 'pillow', 'bowl', 'wall', 'powersocket', 'novel', 'food_food', 'video_game_controller', 'check', 'food_onion', 'doorjamb', 'napkin', 'home_office', 'coffee']\nTask:Listen to music\nresponse:\n", "output": {"thoughts": "I walk into the living room. I find the stereo and turn it on, and I listen to the music.", "actions": ["[WALK] <home_office>", "[WALK] <stereo>", "[FIND] <stereo>", "[SWITCHON] <stereo>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['microwave', 'chair', 'walllamp', 'bathroom', 'drawing', 'cpuscreen', 'bathroom_counter', 'floor', 'ceiling', 'character', 'keyboard', 'alcohol', 'toaster', 'tvstand', 'shower', 'closetdrawer', 'nightstand', 'wall_clock', 'bench', 'powersocket', 'food_food', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'sink', 'home_office', 'table', 'light', 'coffee']\nTask:Walk through\nresponse:\n{\n    \"thoughts\": Walk through the hallway.,\n    \"actions\": ['[WALK] <home_office>', '[WALK] <dining_room>', '[WALK] <home_office>']\n}\n", "input": "\nScene_Objects:['dry_pasta', 'pot', 'microwave', 'walllamp', 'toothbrush', 'drawing', 'knifeblock', 'wallshelf', 'keyboard', 'food_cake', 'ceilinglamp', 'tvstand', 'shower', 'stereo', 'oil', 'tooth_paste', 'couch', 'closetdrawer', 'dining_room', 'toy', 'basket_for_clothes', 'light_bulb', 'check', 'centerpiece', 'kettle', 'mouse', 'kitchen_counter', 'shoes', 'light', 'board_game']\nTask:Brush teeth\nresponse:\n", "output": {"thoughts": "EARLY MORNING AND BEFORE GOING TO BED", "actions": ["[WALK] <bathroom>", "[WALK] <tooth_paste>", "[FIND] <tooth_paste>", "[GRAB] <tooth_paste>", "[FIND] <toothbrush>", "[GRAB] <toothbrush>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['pot', 'crayon', 'tea', 'beer', 'microwave', 'toilet', 'trashcan', 'food_carrot', 'knifeblock', 'cpuscreen', 'bathroom_counter', 'floor', 'character', 'bedroom', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'window', 'dining_room', 'food_kiwi', 'nightstand', 'bed', 'photoframe', 'doorjamb', 'dishrack', 'cupboard', 'sink', 'home_office']\nTask:Open bathroom window\nresponse:\n{\n    \"thoughts\": Make sure bathroom window is unlocked. Lift up bathroom window so it is open.,\n    \"actions\": ['[WALK] <bathroom>', '[WALK] <window>', '[FIND] <window>', '[OPEN] <window>']\n}\n", "input": "\nScene_Objects:['blender', 'toilet', 'freezer', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'ceilinglamp', 'shoe-shine_kit', 'shower', 'faucet', 'mat', 'oil', 'food_peanut_butter', 'towel', 'wall', 'nightstand', 'powersocket', 'photoframe', 'bed', 'toilet_paper', 'curtain', 'doorjamb', 'kitchen_counter', 'door', 'sink', 'bathroom_cabinet', 'light', 'colander']\nTask:Take shower\nresponse:\n", "output": {"thoughts": "Walk to Bathroom. Open the Bathroom Cabinet. Grab a Towel. Close the Bathroom Cabinet. Rinse the Shower.", "actions": ["[WALK] <bathroom>", "[WALK] <bathroom_cabinet>", "[FIND] <bathroom_cabinet>", "[OPEN] <bathroom_cabinet>", "[FIND] <towel>", "[GRAB] <towel>", "[CLOSE] <bathroom_cabinet>", "[FIND] <shower>", "[RINSE] <shower>"]}}
{"instruction": "\nYou serve as an AI task planner. \n1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format \"[verb] <target1> <target2>\", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.\n2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together. \nEnsure that you response can be parsed by Python json.loads.\n\n\nHere is an example plan to achieve a goal for reference: \nScene_Objects:['tea', 'toilet', 'freezer', 'band-aids', 'knifeblock', 'food_egg', 'shampoo', 'phone', 'bookshelf', 'purse', 'thread', 'deck_of_cards', 'shower', 'picture', 'clothes_socks', 'oven', 'food_cheese', 'novel', 'food_food', 'check', 'coffe_maker', 'tray', 'after_shave', 'curtain', 'doorjamb', 'cupboard', 'controller', 'bag', 'table', 'scrabble']\nTask:Drink\nresponse:\n{\n    \"thoughts\": Pour water into a glass and drink from the glass.,\n    \"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>']\n}\n", "input": "\nScene_Objects:['pot', 'filing_cabinet', 'freezer', 'walllamp', 'drawing', 'needle', 'orchid', 'floor', 'stamp', 'keyboard', 'plate', 'faucet', 'shower', 'dish_soap', 'oil', 'wall', 'keys', 'coffe_maker', 'coffee_filter', 'pencil', 'kitchen_counter', 'dishrack', 'dresser', 'cupboard', 'controller', 'pajamas', 'food_steak', 'spoon', 'light', 'dishwasher']\nTask:Wash dishes with dishwasher\nresponse:\n", "output": {"thoughts": "Walk to the kitchen. Find the dishwasher. Walk to the dishwasher. Open the dishwasher. Find plate no.1. Grab plate no.1. Put plate no.1 into the dishwasher. Find plate no.2. Grab plate no.2. Put plate no.2 into the dishwasher. Find the spoon. Grab the spoon. Put the spoon into the dishwasher. Find the dish soap. Put the dish soap into the dishwasher. Close the dishwasher. Switch on the dishwasher.", "actions": ["[WALK] <dining_room>", "[WALK] <dishwasher>", "[FIND] <dishwasher>", "[WALK] <dishwasher>", "[OPEN] <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <plate>", "[GRAB] <plate>", "[PUTBACK] <plate> <dishwasher>", "[FIND] <spoon>", "[GRAB] <spoon>", "[PUTBACK] <spoon> <dishwasher>", "[FIND] <dish_soap>", "[GRAB] <dish_soap>", "[PUTBACK] <dish_soap> <dishwasher>", "[CLOSE] <dishwasher>", "[SWITCHON] <dishwasher>"]}}