DistillationDatasets
Collection
2 items
•
Updated
llm_prompt
stringlengths 8.07k
11.8k
| identifier
stringlengths 3
6
|
|---|---|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
bathroom, id: 1, properties: []
dining_room, id: 201, properties: []
basket_for_clothes, id: 1000, properties: ['CAN_OPEN', 'CONTAINERS', 'MOVABLE', 'GRABBABLE']
washing_machine, id: 1001, properties: ['CONTAINERS', 'HAS_SWITCH', 'HAS_PLUG', 'CAN_OPEN', 'RECIPIENT']
soap, id: 1002, properties: ['CREAM', 'MOVABLE', 'GRABBABLE']
clothes_jacket, id: 1003, properties: ['HANGABLE', 'MOVABLE', 'GRABBABLE', 'CLOTHES']
The current environment state is
Nodes:
washing_machine, states: ['PLUGGED_IN', 'OFF', 'CLOSED', 'CLEAN'], properties:['CONTAINERS', 'HAS_SWITCH', 'HAS_PLUG', 'CAN_OPEN', 'RECIPIENT']
Edges:
<soap> (1002) is NEAR to <basket_for_clothes> (1000)
<basket_for_clothes> (1000) is NEAR to <clothes_jacket> (1003)
<character> (65) is INSIDE to <bathroom> (1)
<clothes_jacket> (1003) is NEAR to <basket_for_clothes> (1000)
<clothes_jacket> (1003) is INSIDE to <washing_machine> (1001)
<basket_for_clothes> (1000) is NEAR to <soap> (1002)
Node goals are:
washing_machine is CLOSED
washing_machine is ON
washing_machine is PLUGGED_IN
Edge goals are:
clothes_jacket is ON to washing_machine
soap is ON to washing_machine
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
27_2
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
washing_machine, id: 1000, properties: ['CONTAINERS', 'HAS_SWITCH', 'HAS_PLUG', 'CAN_OPEN', 'RECIPIENT']
clothes_pants, id: 1001, properties: ['HANGABLE', 'MOVABLE', 'GRABBABLE', 'CLOTHES']
clothes_pants, id: 1002, properties: ['HANGABLE', 'MOVABLE', 'GRABBABLE', 'CLOTHES']
clothes_shirt, id: 1003, properties: ['HANGABLE', 'MOVABLE', 'GRABBABLE', 'CLOTHES']
clothes_shirt, id: 1004, properties: ['HANGABLE', 'MOVABLE', 'GRABBABLE', 'CLOTHES']
soap, id: 1005, properties: ['CREAM', 'MOVABLE', 'GRABBABLE']
The current environment state is
Nodes:
washing_machine, states: ['PLUGGED_IN', 'OFF', 'CLOSED', 'CLEAN'], properties:['CONTAINERS', 'HAS_SWITCH', 'HAS_PLUG', 'CAN_OPEN', 'RECIPIENT']
Edges:
<clothes_shirt> (1004) is INSIDE to <washing_machine> (1000)
<clothes_pants> (1001) is INSIDE to <washing_machine> (1000)
<soap> (1005) is INSIDE to <washing_machine> (1000)
<clothes_shirt> (1003) is INSIDE to <washing_machine> (1000)
<clothes_pants> (1002) is INSIDE to <washing_machine> (1000)
Node goals are:
washing_machine is CLOSED
washing_machine is ON
washing_machine is PLUGGED_IN
Edge goals are:
clothes_pants is ON to washing_machine
clothes_shirt is ON to washing_machine
clothes_shirt is ON to washing_machine
clothes_pants is ON to washing_machine
soap is ON to washing_machine
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
417_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
bathroom, id: 1, properties: []
washing_machine, id: 1000, properties: ['CONTAINERS', 'HAS_SWITCH', 'HAS_PLUG', 'CAN_OPEN', 'RECIPIENT']
dining_room, id: 201, properties: []
laundry_detergent, id: 1002, properties: ['POURABLE', 'MOVABLE', 'GRABBABLE']
clothes_pants, id: 1001, properties: ['HANGABLE', 'MOVABLE', 'GRABBABLE', 'CLOTHES']
The current environment state is
Nodes:
washing_machine, states: ['PLUGGED_IN', 'OFF', 'CLOSED', 'CLEAN'], properties:['CONTAINERS', 'HAS_SWITCH', 'HAS_PLUG', 'CAN_OPEN', 'RECIPIENT']
Edges:
<clothes_pants> (1001) is INSIDE to <washing_machine> (1000)
<character> (65) is INSIDE to <dining_room> (201)
Node goals are:
washing_machine is CLOSED
washing_machine is ON
washing_machine is PLUGGED_IN
Edge goals are:
clothes_pants is ON to washing_machine
laundry_detergent is ON to washing_machine
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
850_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
bathroom, id: 1, properties: []
washing_machine, id: 1001, properties: ['CONTAINERS', 'HAS_SWITCH', 'HAS_PLUG', 'CAN_OPEN', 'RECIPIENT']
clothes_dress, id: 1002, properties: ['HANGABLE', 'MOVABLE', 'GRABBABLE', 'CLOTHES']
clothes_pants, id: 1003, properties: ['HANGABLE', 'MOVABLE', 'GRABBABLE', 'CLOTHES']
clothes_shirt, id: 1004, properties: ['HANGABLE', 'MOVABLE', 'GRABBABLE', 'CLOTHES']
clothes_underwear, id: 1005, properties: ['HANGABLE', 'MOVABLE', 'GRABBABLE', 'CLOTHES']
soap, id: 1006, properties: ['CREAM', 'MOVABLE', 'GRABBABLE']
home_office, id: 319, properties: []
The current environment state is
Nodes:
washing_machine, states: ['PLUGGED_IN', 'OFF', 'CLOSED', 'CLEAN'], properties:['CONTAINERS', 'HAS_SWITCH', 'HAS_PLUG', 'CAN_OPEN', 'RECIPIENT']
Edges:
<clothes_shirt> (1004) is INSIDE to <washing_machine> (1001)
<clothes_dress> (1002) is INSIDE to <washing_machine> (1001)
<clothes_underwear> (1005) is INSIDE to <washing_machine> (1001)
<soap> (1006) is INSIDE to <washing_machine> (1001)
<clothes_pants> (1003) is INSIDE to <washing_machine> (1001)
<character> (65) is INSIDE to <home_office> (319)
Node goals are:
washing_machine is CLOSED
washing_machine is ON
washing_machine is PLUGGED_IN
Edge goals are:
clothes_shirt is ON to washing_machine
clothes_pants is ON to washing_machine
clothes_underwear is ON to washing_machine
soap is ON to washing_machine
clothes_dress is ON to washing_machine
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
954_2
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
floor_lamp, id: 1000, properties: ['HAS_SWITCH', 'MOVABLE']
character, id: 65, properties: []
bedroom, id: 67, properties: []
dining_room, id: 201, properties: []
The current environment state is
Nodes:
floor_lamp, states: ['OFF', 'CLEAN'], properties:['HAS_SWITCH', 'MOVABLE']
Edges:
<character> (65) is INSIDE to <dining_room> (201)
Node goals are:
floor_lamp is ON
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
11_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
floor_lamp, id: 1000, properties: ['HAS_SWITCH', 'MOVABLE']
character, id: 65, properties: []
light, id: 411, properties: ['HAS_SWITCH', 'HAS_PLUG']
light, id: 245, properties: ['HAS_SWITCH', 'HAS_PLUG']
The current environment state is
Nodes:
floor_lamp, states: ['OFF', 'CLEAN'], properties:['HAS_SWITCH', 'MOVABLE']
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
Node goals are:
light is ON
light is PLUGGED_IN
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
120_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
computer, id: 417, properties: ['LOOKABLE', 'HAS_SWITCH']
bedroom, id: 67, properties: []
chair, id: 356, properties: ['SITTABLE', 'SURFACES', 'GRABBABLE', 'MOVABLE']
light, id: 411, properties: ['HAS_SWITCH', 'HAS_PLUG']
home_office, id: 319, properties: []
The current environment state is
Nodes:
character, states: [], properties:[]
light, states: ['PLUGGED_OUT', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
<character> (65) is INSIDE to <bedroom> (67)
Node goals are:
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
125_2
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
light, id: 411, properties: ['HAS_SWITCH', 'HAS_PLUG']
bathroom, id: 1, properties: []
home_office, id: 319, properties: []
The current environment state is
Nodes:
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
<character> (65) is INSIDE to <bathroom> (1)
Node goals are:
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
150_2
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
controller, id: 1000, properties: ['HAS_PLUG', 'MOVABLE', 'GRABBABLE']
dining_room, id: 201, properties: []
light, id: 1002, properties: ['HAS_SWITCH', 'HAS_PLUG']
light, id: 411, properties: ['HAS_SWITCH', 'HAS_PLUG']
controller, id: 1001, properties: ['HAS_PLUG', 'MOVABLE', 'GRABBABLE']
home_office, id: 319, properties: []
The current environment state is
Nodes:
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
<character> (65) is INSIDE to <dining_room> (201)
Node goals are:
light is ON
light is PLUGGED_IN
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
160_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
dining_room, id: 201, properties: []
light, id: 245, properties: ['HAS_SWITCH', 'HAS_PLUG']
bathroom, id: 1, properties: []
The current environment state is
Nodes:
character, states: ['SITTING'], properties:[]
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
<character> (65) is INSIDE to <bathroom> (1)
Node goals are:
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
180_2
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
light, id: 169, properties: ['HAS_SWITCH', 'HAS_PLUG']
bedroom, id: 67, properties: []
home_office, id: 319, properties: []
The current environment state is
Nodes:
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
<character> (65) is INSIDE to <home_office> (319)
Node goals are:
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
205_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
light, id: 411, properties: ['HAS_SWITCH', 'HAS_PLUG']
dining_room, id: 201, properties: []
home_office, id: 319, properties: []
The current environment state is
Nodes:
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
<character> (65) is INSIDE to <dining_room> (201)
Node goals are:
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
222_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
bathroom, id: 1, properties: []
dining_room, id: 201, properties: []
light, id: 245, properties: ['HAS_SWITCH', 'HAS_PLUG']
light, id: 1000, properties: ['HAS_SWITCH', 'HAS_PLUG']
light, id: 1001, properties: ['HAS_SWITCH', 'HAS_PLUG']
The current environment state is
Nodes:
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
<character> (65) is INSIDE to <bathroom> (1)
Node goals are:
light is ON
light is PLUGGED_IN
light is ON
light is PLUGGED_IN
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
232_2
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
light, id: 169, properties: ['HAS_SWITCH', 'HAS_PLUG']
bedroom, id: 67, properties: []
dining_room, id: 201, properties: []
The current environment state is
Nodes:
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
<character> (65) is INSIDE to <dining_room> (201)
Node goals are:
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
310_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
floor_lamp, id: 1000, properties: ['HAS_SWITCH', 'MOVABLE']
character, id: 65, properties: []
bathroom, id: 1, properties: []
home_office, id: 319, properties: []
The current environment state is
Nodes:
floor_lamp, states: ['OFF', 'CLEAN'], properties:['HAS_SWITCH', 'MOVABLE']
Edges:
<character> (65) is INSIDE to <bathroom> (1)
Node goals are:
floor_lamp is ON
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
311_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
bedroom, id: 67, properties: []
light, id: 411, properties: ['HAS_SWITCH', 'HAS_PLUG']
home_office, id: 319, properties: []
The current environment state is
Nodes:
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
<character> (65) is INSIDE to <bedroom> (67)
Node goals are:
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
331_2
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
dining_room, id: 201, properties: []
light, id: 245, properties: ['HAS_SWITCH', 'HAS_PLUG']
home_office, id: 319, properties: []
The current environment state is
Nodes:
character, states: ['SITTING'], properties:[]
Edges:
<character> (65) is INSIDE to <home_office> (319)
Node goals are:
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
339_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
home_office, id: 319, properties: []
remote_control, id: 1000, properties: ['HAS_SWITCH', 'MOVABLE', 'GRABBABLE']
dining_room, id: 201, properties: []
light, id: 411, properties: ['HAS_SWITCH', 'HAS_PLUG']
filing_cabinet, id: 399, properties: ['SURFACES', 'CONTAINERS', 'CAN_OPEN']
The current environment state is
Nodes:
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
<remote_control> (1000) is ON to <filing_cabinet> (399)
<character> (65) is INSIDE to <dining_room> (201)
<remote_control> (1000) is NEAR to <filing_cabinet> (399)
<filing_cabinet> (399) is NEAR to <remote_control> (1000)
Node goals are:
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
345_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
light, id: 64, properties: ['HAS_SWITCH', 'HAS_PLUG']
character, id: 65, properties: []
The current environment state is
Nodes:
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
Node goals are:
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
392_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
light, id: 245, properties: ['HAS_SWITCH', 'HAS_PLUG']
The current environment state is
Nodes:
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
Node goals are:
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
394_2
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
floor_lamp, id: 1000, properties: ['HAS_SWITCH', 'MOVABLE']
character, id: 65, properties: []
bathroom, id: 1, properties: []
home_office, id: 319, properties: []
The current environment state is
Nodes:
floor_lamp, states: ['OFF', 'CLEAN'], properties:['HAS_SWITCH', 'MOVABLE']
Edges:
<character> (65) is INSIDE to <bathroom> (1)
Node goals are:
floor_lamp is ON
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
432_1
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
floor_lamp, id: 1000, properties: ['HAS_SWITCH', 'MOVABLE']
character, id: 65, properties: []
bedroom, id: 67, properties: []
dining_room, id: 201, properties: []
The current environment state is
Nodes:
floor_lamp, states: ['OFF', 'CLEAN'], properties:['HAS_SWITCH', 'MOVABLE']
Edges:
<character> (65) is INSIDE to <dining_room> (201)
Node goals are:
floor_lamp is ON
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
443_2
|
The task is to guide the robot to take actions from current state to fulfill some node goals, edge goals, and action goals. The input will be the related objects in the scene, nodes and edges in the current environment, and the desired node goals, edge goals, and action goals. The output should be action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy the goals.
Data format:
Objects in the scene indicates those objects involved in the action execution. It follows the format: <object_name> (object_id)
Nodes and edges in the current environment shows the nodes' names, states and properties, and edges in the environment.
Nodes follow the format: object_name, states:... , properties:...
Edges follow the format: object_name A is ... to object_name B
Node goals show the target object states in the ending environment. They follow the format: object_name is ... (some state)
Edge goals show the target relationships of objects in the ending environment. They follow the format: object_name A is ... (some relationship) to object_name B.
Action goals specify the necessary actions you need to include in your predicted action commands sequence, and the order they appear in action goals should also be the RELATIVE order they appear in your predicted action commands sequence if there are more than one line. Each line in action goals include one action or more than one actions concatenated by OR. You only need to include ONE of the actions concatenated by OR in the same line. For example, if the action goal is:
The following action(s) should be included:
GRAB
TYPE or TOUCH
OPEN
------------------------
Then your predicted action commands sequence should include GRAB, either TYPE or TOUCH, and OPEN. Besides, GRAB should be executed earlier than TYPE or TOUCH, and TYPE or TOUCH should be executed earlier than OPEN.
If the action goal is:
The following action(s) should be included:
There is no action requirement.
It means there is no action you have to include in output, and you can use any action to achieve the node and edge goals. Warning: No action requirement does not mean empty output. You should always output some actions and their arguments.
Action commands include action name and objects. The number of objects (required_number of parameters) for each action is fixed and is given below, either 0, 1, or 2. The output action commands should be in json format. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action, where [] is for 0 object, [object] is for 1 object, [object 1, object 2] is for 2 objects. The action commands order is represented by the order they appear in the json dictionary. The key value pair appearing first will be executed first, the key value pair appearing second will be executed second, so on and so forth.
For example, if you want to first FIND the sink and then PUTBACK cup to the sink, you should express it as {'FIND':['sink'], 'PUTBACK':['cup', 'sink']}
The object of action also needs to satisfied some properties preconditions. For example, SWITCHON's object number is 1. To switch on something, the object should 'HAS_SWITCH'. The rule is represented as SWITCHON = ("Switch on", 1, [['HAS_SWITCH']]). Another example is POUR. POUR's object number is 2. To pour sth A into sth B, A should be pourable and drinkable, and B should be RECIPIENT. The rule is represented as POUR = ("Pour", 2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]).
Action Definitions Format:
Each action is defined as a combination of:
Action Name (String): A descriptive name for the action.
Required Number of Parameters (Integer): The count of parameters needed to perform the action.
Preconditions for Each Object (List of Lists of Strings): Conditions that must be met for each object involved in the action.
Supported Actions List:
CLOSE: (1, [['CAN_OPEN']]) # Change state from OPEN to CLOSED
DRINK: (1, [['DRINKABLE', 'RECIPIENT']]) # Consume a drinkable item
FIND: (1, [[]]) # Locate and approach an item
WALK: (1, [[]]) # Move towards something
GRAB: (1, [['GRABBABLE']]) # Take hold of an item that can be grabbed
LOOKAT: (1, [[]]) # Direct your gaze towards something
OPEN: (1, [['CAN_OPEN']]) # Open an item that can be opened
POINTAT: (1, [[]]) # Point towards something
PUTBACK: (2, [['GRABBABLE'], []]) # Place one object back onto or into another
PUTIN: (2, [['GRABBABLE'], ['CAN_OPEN']]) # Insert one object into another
RUN: (1, [[]]) # Run towards something
SIT: (1, [['SITTABLE']]) # Sit on a suitable object
STANDUP: (0, []) # Stand up from a sitting or lying position
SWITCHOFF: (1, [['HAS_SWITCH']]) # Turn off an item with a switch
SWITCHON: (1, [['HAS_SWITCH']]) # Turn on an item with a switch
TOUCH: (1, [[]]) # Physically touch something
TURNTO: (1, [[]]) # Turn your body to face something
WATCH: (1, [[]]) # Observe something attentively
WIPE: (1, [[]]) # Clean or dry something by rubbing
PUTON: (1, [['CLOTHES']]) # Dress oneself with an item of clothing
PUTOFF: (1, [['CLOTHES']]) # Remove an item of clothing
GREET: (1, [['PERSON']]) # Offer a greeting to a person
DROP: (1, [[]]) # Let go of something so it falls
READ: (1, [['READABLE']]) # Read text from an object
LIE: (1, [['LIEABLE']]) # Lay oneself down on an object
POUR: (2, [['POURABLE', 'DRINKABLE'], ['RECIPIENT']]) # Transfer a liquid from one container to another
PUSH: (1, [['MOVABLE']]) # Exert force on something to move it away from you
PULL: (1, [['MOVABLE']]) # Exert force on something to bring it towards you
MOVE: (1, [['MOVABLE']]) # Change the location of an object
WASH: (1, [[]]) # Clean something by immersing and agitating it in water
RINSE: (1, [[]]) # Remove soap from something by applying water
SCRUB: (1, [[]]) # Clean something by rubbing it hard with a brush
SQUEEZE: (1, [['CLOTHES']]) # Compress clothes to extract liquid
PLUGIN: (1, [['HAS_PLUG']]) # Connect an electrical device to a power source
PLUGOUT: (1, [['HAS_PLUG']]) # Disconnect an electrical device from a power source
CUT: (1, [['EATABLE', 'CUTABLE']]) # Cut some food
EAT: (1, [['EATABLE']]) # Eat some food
RELEASE: (1, [[]]) # Let go of something inside the current room
TYPE: (1, [['HAS_SWITCH']]) # Type on a keyboard
Notice:
1. CLOSE action is opposed to OPEN action, CLOSE sth means changing the object's state from OPEN to CLOSE.
2. You cannot [PUTIN] <character> <room name>. If you want robot INSIDE some room, please [WALK] <room name>.
3. The subject of all these actions is <character>, that is, robot itself. Do not include <character> as object_name. NEVER EVER use character as any of the object_name, that is, the argument of actions.
4. The action name should be upper case without white space.
5. Importantly, if you want to apply ANY action on <object_name>, you should NEAR it. Therefore, you should apply WALK action as [WALK] <object_name> to first get near to the object before you apply any following actions, if you have no clue you are already NEAR <object_name>
6. When output the objects, please only output object names but not their ids. Follow strictly the parameter number for each action.
7. Output should not be empty! Always output some actions and their arguments.
Input:
The relevant objects in the scene are:
character, id: 65, properties: []
bedroom, id: 67, properties: []
light, id: 1000, properties: ['HAS_SWITCH', 'HAS_PLUG']
light, id: 411, properties: ['HAS_SWITCH', 'HAS_PLUG']
home_office, id: 319, properties: []
The current environment state is
Nodes:
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
light, states: ['PLUGGED_IN', 'OFF', 'CLEAN'], properties:['HAS_SWITCH', 'HAS_PLUG']
Edges:
<character> (65) is INSIDE to <bedroom> (67)
Node goals are:
light is ON
light is PLUGGED_IN
light is ON
light is PLUGGED_IN
Edge goals are:
Action goals are:
There is no action requirement.
Please output the list of action commands in json format so that after the robot executes the action commands sequentially, the ending environment would satisfy all the node goals, edge goals and action goals. The dictionary keys should be action names. The dictionary values should be a list containing the objects of the corresponding action. Only output the json of action commands in a dictionary with nothing else.
Output:
|
445_1
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 3
Size of downloaded dataset files:
3.02 MB
Size of the auto-converted Parquet files:
331 kB
Number of rows:
342