python_code
stringlengths 0
4.04M
| repo_name
stringlengths 8
58
| file_path
stringlengths 5
147
|
|---|---|---|
import sys
import logging
import random
import re
import time
from core import BaseAgent
from base_util import hash_user
random.seed(0)
# a BaseAgent with:
# 1: a controller that is (mostly) a dialogue manager, and the dialogue manager
# is powered by a neural semantic parser.
# 2: has a turnable head, can point, and has basic locomotion
# 3: can send and receive chats
# this name is pathetic please help
class LocoMCAgent(BaseAgent):
def __init__(self, opts, name=None):
logging.info("Agent.__init__ started")
self.name = name or default_agent_name()
self.opts = opts
self.init_physical_interfaces()
super(LocoMCAgent, self).__init__(opts, name=self.name)
self.uncaught_error_count = 0
self.last_chat_time = 0
self.last_task_memid = None
self.areas_to_perceive = []
def init_physical_interfaces(self):
"""
should define or otherwise set up
(at least):
self.send_chat(),
movement primitives, including
self.look_at(x, y, z):
self.set_look(look):
self.point_at(...),
self.relative_head_pitch(angle)
...
"""
raise NotImplementedError
def init_perception(self):
"""
should define (at least):
self.get_pos()
self.get_incoming_chats()
and the perceptual modules that write to memory
all modules that should write to memory on a perceive() call
should be registered in self.perception_modules, and have
their own .perceive() fn
"""
raise NotImplementedError
def init_memory(self):
""" something like:
self.memory = memory.AgentMemory(
db_file=os.environ.get("DB_FILE", ":memory:"),
db_log_path="agent_memory.{}.log".format(self.name),
)
"""
raise NotImplementedError
def init_controller(self):
"""
dialogue_object_classes["interpreter"] = ....
dialogue_object_classes["get_memory"] = ....
dialogue_object_classes["put_memory"] = ....
self.dialogue_manager = NSPDialogueManager(self,
dialogue_object_classes,
self.opts)
logging.info("Initialized DialogueManager")
"""
raise NotImplementedError
def handle_exception(self, e):
logging.exception(
"Default handler caught exception, db_log_idx={}".format(self.memory.get_db_log_idx())
)
self.send_chat("Oops! I got confused and wasn't able to complete my last task :(")
self.memory.task_stack_clear()
self.dialogue_manager.dialogue_stack.clear()
self.uncaught_error_count += 1
if self.uncaught_error_count >= 100:
sys.exit(1)
def step(self):
if self.count == 0:
logging.info("First top-level step()")
super().step()
def task_step(self, sleep_time=0.25):
# Clean finished tasks
while (
self.memory.task_stack_peek() and self.memory.task_stack_peek().task.check_finished()
):
self.memory.task_stack_pop()
# If nothing to do, wait a moment
if self.memory.task_stack_peek() is None:
time.sleep(sleep_time)
return
# If something to do, step the topmost task
task_mem = self.memory.task_stack_peek()
if task_mem.memid != self.last_task_memid:
logging.info("Starting task {}".format(task_mem.task))
self.last_task_memid = task_mem.memid
task_mem.task.step(self)
self.memory.task_stack_update_task(task_mem.memid, task_mem.task)
def get_time(self):
# round to 100th of second, return as
# n hundreth of seconds since agent init
return self.memory.get_time()
def perceive(self, force=False):
for v in self.perception_modules.values():
v.perceive(force=force)
def controller_step(self):
"""Process incoming chats and modify task stack"""
raw_incoming_chats = self.get_incoming_chats()
if raw_incoming_chats:
# force to get objects
self.perceive(force=True)
logging.info("Incoming chats: {}".format(raw_incoming_chats))
incoming_chats = []
for raw_chat in raw_incoming_chats:
match = re.search("^<([^>]+)> (.*)", raw_chat)
if match is None:
logging.info("Ignoring chat: {}".format(raw_chat))
continue
speaker, chat = match.group(1), match.group(2)
speaker_hash = hash_user(speaker)
logging.info("Incoming chat: ['{}' -> {}]".format(speaker_hash, chat))
if chat.startswith("/"):
continue
incoming_chats.append((speaker, chat))
self.memory.add_chat(self.memory.get_player_by_name(speaker).memid, chat)
if len(incoming_chats) > 0:
# change this to memory.get_time() format?
self.last_chat_time = time.time()
# for now just process the first incoming chat
self.dialogue_manager.step(incoming_chats[0])
else:
self.dialogue_manager.step((None, ""))
def default_agent_name():
"""Use a unique name based on timestamp"""
return "bot.{}".format(str(time.time())[3:13])
| craftassist-master | python/base_agent/loco_mc_agent.py |
import copy
# move location inside reference_object for Fill and Destroy actions
def fix_fill_and_destroy_location(action_dict):
action_name = action_dict["action_type"]
if action_name in ["FILL", "DESTROY"]:
if "location" in action_dict:
if "reference_object" not in action_dict:
action_dict["reference_object"] = {}
action_dict["reference_object"]["location"] = action_dict["location"]
action_dict.pop("location")
return action_dict
# fix for location_type, adding them to reference object instead
def fix_location_type_in_location(d):
new_d = copy.deepcopy(d)
for key, value in d.items():
if key == "location_type":
if value in ["SPEAKER_LOOK", "AGENT_POS", "SPEAKER_POS", "COORDINATES"]:
# keep value the same for SPEAKER_LOOK, update for all others.
updated_value = value
if value == "AGENT_POS":
updated_value = "AGENT"
elif value == "SPEAKER_POS":
updated_value = "SPEAKER"
elif value == "COORDINATES":
updated_value = {"coordinates_span": d["coordinates"]}
# add to reference object instead
if "reference_object" in d:
if not new_d.get("filters"):
new_d["filters"] = []
new_d["reference_object"]["special_reference"] = updated_value
else:
new_d["reference_object"] = {"special_reference": updated_value}
new_d.pop(key)
new_d.pop("coordinates", None)
if type(value) == dict:
new_d[key] = fix_location_type_in_location(value)
return new_d
# fix reference object to have properties inside 'filters'
def fix_reference_object_with_filters(d):
new_d = copy.deepcopy(d)
for key, value in d.items():
if key in ["reference_object", "reference_object_1", "reference_object_2"]:
val = d[key]
if "repeat" in val:
new_d[key] = {"repeat": val["repeat"]}
val.pop("repeat")
new_d[key]["filters"] = val
elif "location" in val:
new_d[key] = fix_location_type_in_location(val)
else:
new_d[key] = {"filters": val}
if type(val) == dict:
new_d[key]["filters"] = fix_reference_object_with_filters(val)
elif type(value) == dict:
new_d[key] = fix_reference_object_with_filters(value)
return new_d
def post_process_logical_form(logical_form):
# since model is now updated
return logical_form
# TODO(kavya): Also post process PUT_MEMORY and GET_MEMORY
if logical_form["dialogue_type"] != "HUMAN_GIVE_COMMAND":
return logical_form
new_action_sequence = []
for action_dict in logical_form["action_sequence"]:
dict_with_fill_destroy_fix = fix_fill_and_destroy_location(action_dict)
dict_with_location_type_fix = fix_location_type_in_location(
copy.deepcopy(dict_with_fill_destroy_fix)
)
dict_with_filters_fix = fix_reference_object_with_filters(
copy.deepcopy(dict_with_location_type_fix)
)
new_action_sequence.append(dict_with_filters_fix)
logical_form["action_sequence"] = new_action_sequence
return logical_form
| craftassist-master | python/base_agent/post_process_logical_form.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# TODO rewrite functions in intepreter and helpers as classes
# finer granularity of (code) objects
# interpreter is an input to interpret ref object, maybe clean that up?
class ReferenceObjectInterpreter:
def __init__(self, interpret_reference_object):
self.interpret_reference_object = interpret_reference_object
def __call__(self, *args, **kwargs):
return self.interpret_reference_object(*args, **kwargs)
| craftassist-master | python/base_agent/dialogue_objects/reference_object_helpers.py |
from condition import (
LinearExtentValue,
LinearExtentAttribute,
FixedValue,
convert_comparison_value,
)
from base_util import ErrorWithResponse, number_from_span
from base_agent.memory_nodes import ReferenceObjectNode
from dialogue_object_utils import tags_from_dict
def interpret_span_value(interpreter, speaker, d, comparison_measure=None):
num = number_from_span(d)
if num:
v = FixedValue(interpreter.agent, num)
# always convert everything to internal units
# FIXME handle this better
v = convert_comparison_value(v, comparison_measure)
else:
v = FixedValue(interpreter.agent, d)
return v
def maybe_specific_mem(interpreter, speaker, ref_obj_d):
mem = None
search_data = None
if ref_obj_d.get("special_reference"):
# this is a special ref object, not filters....
cands = interpreter.subinterpret["reference_objects"](interpreter, speaker, ref_obj_d)
return cands[0], None
filters_d = ref_obj_d.get("filters", {})
coref = filters_d.get("contains_coreference")
if coref != "NULL":
# this is a particular entity etc, don't search for the mem at check() time
if isinstance(coref, ReferenceObjectNode):
mem = coref
else:
cands = interpreter.subinterpret["reference_objects"](interpreter, speaker, ref_obj_d)
if not cands:
# FIXME fix this error
raise ErrorWithResponse("I don't know which objects attribute you are talking about")
# TODO if more than one? ask?
else:
mem = cands[0]
else:
# this object is only defined by the filters and might be different at different moments
tags = tags_from_dict(filters_d)
# make a function, reuse code with get_reference_objects FIXME
search_data = [{"pred_text": "has_tag", "obj_text": tag} for tag in tags]
return mem, search_data
def interpret_linear_extent(interpreter, speaker, d, force_value=False):
location_data = {}
default_frame = getattr(interpreter.agent, "default_frame") or "AGENT"
frame = d.get("frame", default_frame)
if frame == "SPEAKER":
frame = speaker
if type(frame) is dict:
frame = frame.get("player_span", "unknown_player")
if frame == "AGENT":
location_data["frame"] = "AGENT"
else:
p = interpreter.agent.memory.get_player_by_name(frame)
if p:
location_data["frame"] = p.eid
else:
raise ErrorWithResponse("I don't understand in whose frame of reference you mean")
location_data["relative_direction"] = d.get("relative_direction", "AWAY")
# FIXME!!!! has_measure
rd = d.get("source")
fixed_role = "source"
if not rd:
rd = d.get("destination")
fixed_role = "destination"
mem, sd = maybe_specific_mem(interpreter, speaker, rd)
L = LinearExtentAttribute(interpreter.agent, location_data, mem=mem, fixed_role=fixed_role)
# TODO some sort of sanity check here, these should be rare:
if (d.get("source") and d.get("destination")) or force_value:
rd = d.get("destination")
mem = None
sd = None
if rd:
mem, sd = maybe_specific_mem(interpreter, speaker, rd["filters"])
L = LinearExtentValue(interpreter.agent, L, mem=mem, search_data=sd)
return L
| craftassist-master | python/base_agent/dialogue_objects/attribute_helper.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import logging
import numpy as np
import random
from string_lists import MAP_YES, MAP_NO
from base_util import pos_to_np
from enum import Enum
class DialogueObject(object):
def __init__(self, agent, memory, dialogue_stack, featurizer=None, max_steps=50):
self.agent = agent
self.memory = memory
self.dialogue_stack = dialogue_stack
self.featurizer = featurizer
self.finished = False
self.awaiting_response = False
self.max_steps = max_steps # finish after this many steps to avoid getting stuck
self.current_step = 0
self.progeny_data = (
[]
) # this should have more structure and some methods for adding/accessing?
def step(self):
raise NotImplementedError("Subclasses must implement step()")
def update_progeny_data(self, data):
self.progeny_data.append(data)
def check_finished(self):
"""Check if the object is finished processing."""
self.current_step += 1
if self.current_step == self.max_steps:
logging.error("Stepped {} {} times, finishing".format(self, self.max_steps))
self.finished = True
return self.finished
def featurize(self):
if self.featurizer is not None:
return self.featurizer(self)
else:
return "empty"
def __repr__(self):
return str(type(self))
"""This class represents a sub-type of DialogueObject to await
a response from the user."""
# TODO check who is speaking
class AwaitResponse(DialogueObject):
def __init__(self, wait_time=800, **kwargs):
super().__init__(**kwargs)
self.init_time = self.memory.get_time()
self.response = []
self.wait_time = wait_time
self.awaiting_response = True
def step(self):
"""Wait for wait_time for an answer. Mark finished when a chat comes in."""
chatmem = self.memory.get_most_recent_incoming_chat(after=self.init_time + 1)
if chatmem is not None:
self.finished = True
return "", {"response": chatmem}
if self.memory.get_time() - self.init_time > self.wait_time:
self.finished = True
# FIXME this shouldn't return data
return "Okay! I'll stop waiting for you to answer that.", {"response": None}
return "", None
"""This class represents a sub-type of DialogueObject to say / send a chat
to the user."""
class Say(DialogueObject):
def __init__(self, response_options, **kwargs):
super().__init__(**kwargs)
if len(response_options) == 0:
raise ValueError("Cannot init a Say with no response options")
if type(response_options) is str:
self.response_options = [response_options]
else:
self.response_options = response_options
def step(self):
"""Return one of the response_options."""
self.finished = True
return random.choice(self.response_options), None
"""This class represents a sub-type of the Say DialogueObject above to answer
something about the current capabilities of the bot, to the user."""
class BotCapabilities(Say):
def __init__(self, **kwargs):
response_options = [
'Try looking at something and tell me "go there"',
'Try looking at a structure and tell me "destroy that"',
'Try looking somewhere and tell me "build a wall there"',
"Try building something and giving it a name",
"Try naming something and telling me to build it",
]
super().__init__(response_options, **kwargs)
"""Types of bot greetings."""
class GreetingType(Enum):
HELLO = "hello"
GOODBYE = "goodbye"
"""This class represents a sub-type of the Say DialogueObject above to greet
the user as a reply to a greeting."""
class BotGreet(Say):
def __init__(self, greeting_type, **kwargs):
if greeting_type == GreetingType.GOODBYE.value:
response_options = ["goodbye", "bye", "see you next time!"]
else:
response_options = ["hi there!", "hello", "hey", "hi"]
super().__init__(response_options, **kwargs)
"""This class represents a sub-type of the DialogueObject to answer
questions about the current status of the bot, to the user."""
class BotStackStatus(DialogueObject):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.ing_mapping = {
"Build": "building",
"Destroy": "excavating",
"Dig": "digging",
"Move": "moving",
}
def step(self):
"""return the current task name status."""
self.finished = True
task_mem = self.memory.task_stack_find_lowest_instance(list(self.ing_mapping.keys()))
if task_mem is None:
answer_options = [
"Idle. You can tell me what to do!",
"I am doing nothing.",
"Nothing. Waiting for your command.",
]
else:
doing = self.ing_mapping[task_mem.task.__class__.__name__]
answer_options = ["I am " + doing, doing]
return random.choice(answer_options), None
"""This class represents a sub-type of the DialogueObject to register feedback /
reward given by the user in the form of chat."""
class GetReward(DialogueObject):
def step(self):
"""associate pos / neg reward to chat memory."""
self.finished = True
chatmem = self.memory.get_most_recent_incoming_chat()
if chatmem.chat_text in [
"that is wrong",
"that was wrong",
"that was completely wrong",
"not that",
"that looks horrible",
"that is not what i asked",
"that is not what i told you to do",
"that is not what i asked for" "not what i told you to do",
"you failed",
"failure",
"fail",
"not what i asked for",
]:
self.memory.tag(chatmem.memid, "neg_reward")
# should probably tag recent actions too? not just the text of the chat
elif chatmem.chat_text in [
"good job",
"that is really cool",
"that is awesome",
"awesome",
"that is amazing",
"that looks good",
"you did well",
"great",
"good",
"nice",
]:
self.memory.tag(chatmem.memid, "pos_reward")
return "Thanks for letting me know.", None
"""This class represents a sub-type of the DialogueObject to answer questions
about the current location of the bot."""
class BotLocationStatus(DialogueObject):
def step(self):
"""Extract bot's current location."""
self.finished = True
# Get the agent's current location
agent_pos = pos_to_np(self.agent.get_player().pos)
agent_coordinates = " , ".join([str(pos) for pos in agent_pos])
answer_options = [
"I am here at location : %r" % (agent_coordinates),
"I am standing at : %r" % (agent_coordinates),
"I am at : %r" % (agent_coordinates),
]
return random.choice(answer_options), None
"""This class represents a sub-type of the DialogueObject to answer questions
about where the bot is heading."""
class BotMoveStatus(DialogueObject):
def step(self):
"""Extract bot's target coordinates."""
self.finished = True
task = self.memory.task_stack_find_lowest_instance("Move")
if task is None:
answer_options = [
"I am not going anywhere",
"I am not heading anywhere",
"I am not off to anywhere",
]
else:
target_coordinates = " , ".join([str(pos) for pos in task.target])
answer_options = [
"I am heading to location : %r" % (target_coordinates),
"I am walking over to : %r" % (target_coordinates),
"I am moving to : %r" % (target_coordinates),
]
return random.choice(answer_options), None
"""This class represents a sub-type of the DialogueObject to ask a clarification
question about something."""
class ConfirmTask(DialogueObject):
def __init__(self, question, tasks, **kwargs):
super().__init__(**kwargs)
self.question = question # chat text that will be sent to user
self.tasks = tasks # list of Task objects, will be pushed in order
self.asked = False
def step(self):
"""Ask a confirmation question and wait for response."""
# Step 1: ask the question
if not self.asked:
self.dialogue_stack.append_new(AwaitResponse)
self.dialogue_stack.append_new(Say, self.question)
self.asked = True
return "", None
# Step 2: check the response and add the task if necessary
self.finished = True
if len(self.progeny_data) == 0:
return None, None
if hasattr(self.progeny_data[-1]["response"], "chat_text"):
response_str = self.progeny_data[-1]["response"].chat_text
else:
response_str = "UNK"
if response_str in MAP_YES:
for task in self.tasks:
self.memory.task_stack_push(task)
return None, None
"""This class represents a sub-type of the DialogueObject to confirm if the
reference object is correct."""
class ConfirmReferenceObject(DialogueObject):
def __init__(self, reference_object, **kwargs):
super().__init__(**kwargs)
r = reference_object
if hasattr(r, "get_point_at_target"):
self.bounds = r.get_point_at_target()
else:
# this should be an error
self.bounds = tuple(np.min(r, axis=0)) + tuple(np.max(r, axis=0))
self.pointed = False
self.asked = False
def step(self):
"""Confirm the block object by pointing and wait for answer."""
if not self.asked:
self.dialogue_stack.append_new(Say, "do you mean this?")
self.asked = True
return "", None
if not self.pointed:
self.agent.point_at(self.bounds)
self.dialogue_stack.append_new(AwaitResponse)
self.pointed = True
return "", None
self.finished = True
if len(self.progeny_data) == 0:
output_data = None
else:
if hasattr(self.progeny_data[-1]["response"], "chat_text"):
response_str = self.progeny_data[-1]["response"].chat_text
else:
response_str = "UNK"
if response_str in MAP_YES:
output_data = {"response": "yes"}
elif response_str in MAP_NO:
output_data = {"response": "no"}
else:
output_data = {"response": "unkown"}
return "", output_data
| craftassist-master | python/base_agent/dialogue_objects/dialogue_object.py |
import os
import sys
sys.path.append(os.path.dirname(__file__))
from dialogue_object import (
AwaitResponse,
BotCapabilities,
BotGreet,
BotLocationStatus,
BotStackStatus,
DialogueObject,
GetReward,
ConfirmTask,
ConfirmReferenceObject,
Say,
)
from dialogue_object_utils import (
SPEAKERLOOK,
SPEAKERPOS,
AGENTPOS,
is_loc_speakerlook,
process_spans,
coref_resolve,
tags_from_dict,
strip_prefix,
)
from reference_object_helpers import ReferenceObjectInterpreter
from condition_helper import ConditionInterpreter
__all__ = [
AwaitResponse,
BotCapabilities,
BotGreet,
BotLocationStatus,
BotStackStatus,
DialogueObject,
GetReward,
ConfirmTask,
ConfirmReferenceObject,
Say,
SPEAKERLOOK,
SPEAKERPOS,
AGENTPOS,
is_loc_speakerlook,
coref_resolve,
process_spans,
tags_from_dict,
strip_prefix,
ReferenceObjectInterpreter,
ConditionInterpreter,
]
| craftassist-master | python/base_agent/dialogue_objects/__init__.py |
from typing import Optional
from base_util import ErrorWithResponse
from condition import (
Condition,
NeverCondition,
AndCondition,
OrCondition,
Comparator,
MemoryColumnValue,
FixedValue,
TimeCondition,
TableColumn,
)
from attribute_helper import interpret_linear_extent, interpret_span_value, maybe_specific_mem
class ConditionInterpreter:
def __init__(self):
# extra layer of indirection to allow easier split into base_agent and specialized agent conditions...
self.condition_types = {
"NEVER": self.interpret_never,
"AND": self.interpret_and,
"OR": self.interpret_or,
"TIME": self.interpret_time,
"COMPARATOR": self.interpret_comparator,
}
# to avoid having to redefine interpret_comparator in agents if necessary ...
# TODO distance between
self.value_extractors = {
"filters": MemoryColumnValue,
"span": FixedValue,
"distance_between": None,
}
def __call__(self, interpreter, speaker, d) -> Optional[Condition]:
ct = d.get("condition_type")
if ct:
if self.condition_types.get(ct):
# condition_type NEVER doesn't have a "condition" sibling
if ct == "NEVER":
return self.condition_types[ct](interpreter, speaker, d)
if not d.get("condition"):
raise ErrorWithResponse(
"I thought there was a condition but I don't understand it"
)
return self.condition_types[ct](interpreter, speaker, d["condition"])
else:
raise ErrorWithResponse("I don't understand that condition")
else:
return None
def interpret_never(self, interpreter, speaker, d) -> Optional[Condition]:
return NeverCondition(interpreter.agent)
def interpret_or(self, interpreter, speaker, d) -> Optional[Condition]:
orlist = d["or_condition"]
conds = []
for c in orlist:
new_condition = self(interpreter, speaker, d)
if new_condition:
conds.append(new_condition)
return OrCondition(interpreter.agent, conds)
def interpret_and(self, interpreter, speaker, d) -> Optional[Condition]:
orlist = d["and_condition"]
conds = []
for c in orlist:
new_condition = self(interpreter, speaker, d)
if new_condition:
conds.append(new_condition)
return AndCondition(interpreter.agent, conds)
def interpret_time(self, interpreter, speaker, d):
event = None
if d.get("special_time_event"):
return TimeCondition(interpreter.agent, d["special_time_event"])
else:
if not d.get("comparator"):
raise ErrorWithResponse("I don't know how to interpret this time condition")
dc = d["comparator"]
dc["input_left"] = {"value_extractor": "NULL"}
comparator = self.interpret_comparator(interpreter, speaker, dc)
if d.get("event"):
event = self(interpreter, speaker, d["event"])
return TimeCondition(interpreter.agent, comparator, event=event)
# TODO distance between
# TODO make this more modular. what if we want to redefine just distance_between in a new agent?
def interpret_comparator(self, interpreter, speaker, d):
input_left_d = d.get("input_left")
input_right_d = d.get("input_right")
if (not input_right_d) or (not input_left_d):
return None
value_extractors = {}
for inp_pos in ["input_left", "input_right"]:
inp = d[inp_pos]["value_extractor"]
if type(inp) is str:
if inp == "NULL":
value_extractors[inp_pos] = None
else:
# this is a span
cm = d.get("comparison_measure")
v = interpret_span_value(interpreter, speaker, inp, comparison_measure=cm)
value_extractors[inp_pos] = v
elif inp.get("output"):
# this is a filter
# TODO FIXME! deal with count
# TODO logical form etc.?
a = inp["output"]["attribute"]
if type(a) is str:
search_data = {"attribute": TableColumn(interpreter.agent, a)}
elif a.get("linear_extent"):
search_data = {
"attribute": interpret_linear_extent(
interpreter, speaker, a["linear_extent"]
)
}
mem, sd = maybe_specific_mem(interpreter, speaker, {"filters": inp})
if sd:
for k, v in sd.items():
search_data[k] = v
# TODO wrap this in a ScaledValue using condtition.convert_comparison_value
# and "comparison_measure"
value_extractors[inp_pos] = MemoryColumnValue(
interpreter.agent, search_data, mem=mem
)
else:
raise ErrorWithResponse(
"I don't know understand that condition, looks like a comparator but value is not filters or span"
)
comparison_type = d.get("comparison_type")
if not comparison_type:
ErrorWithResponse(
"I think you want me to compare two things in a condition, but am not sure what type of comparison"
)
return Comparator(
interpreter.agent,
value_left=value_extractors["input_left"],
value_right=value_extractors["input_right"],
comparison_type=comparison_type,
)
# TODO not
| craftassist-master | python/base_agent/dialogue_objects/condition_helper.py |
from copy import deepcopy
SPEAKERLOOK = {"reference_object": {"special_reference": "SPEAKER_LOOK"}}
SPEAKERPOS = {"reference_object": {"special_reference": "SPEAKER"}}
AGENTPOS = {"reference_object": {"special_reference": "AGENT"}}
def strip_prefix(s, pre):
if s.startswith(pre):
return s[len(pre) :]
return s
# FIXME!? maybe start using triples appropriately now?
def tags_from_dict(d):
return [
strip_prefix(tag, "the ")
for key, tag in d.items()
if key.startswith("has_") and isinstance(tag, str)
]
def is_loc_speakerlook(d):
# checks a location dict to see if it is SPEAKER_LOOK
r = d.get("reference_object")
if r and r.get("special_reference"):
if r["special_reference"] == "SPEAKER_LOOK":
return True
return False
def process_spans(d, original_words, lemmatized_words):
if type(d) is not dict:
return
for k, v in d.items():
if type(v) == dict:
process_spans(v, original_words, lemmatized_words)
elif type(v) == list and type(v[0]) == dict:
for a in v:
process_spans(a, original_words, lemmatized_words)
else:
try:
sentence, (L, R) = v
if sentence != 0:
raise NotImplementedError("Must update process_spans for multi-string inputs")
assert 0 <= L <= R <= (len(lemmatized_words) - 1)
except ValueError:
continue
except TypeError:
continue
original_w = " ".join(original_words[L : (R + 1)])
# The lemmatizer converts 'it' to -PRON-
if original_w == "it":
d[k] = original_w
else:
d[k] = " ".join(lemmatized_words[L : (R + 1)])
#####FIXME!!!
# this is bad
# and
# in addition to being bad, abstraction is leaking
def coref_resolve(memory, d, chat):
"""Walk logical form "d" and replace coref_resolve values
Possible substitutions:
- a subdict lik SPEAKERPOS
- a MemoryNode object
- "NULL"
Assumes spans have been substituted.
"""
c = chat.split()
if not type(d) is dict:
return
for k, v in d.items():
if type(v) == dict:
coref_resolve(memory, v, chat)
if type(v) == list:
for a in v:
coref_resolve(memory, a, chat)
v_copy = v
if k == "location":
# v is a location dict
for k_ in v:
if k_ == "contains_coreference":
v_copy = deepcopy(v)
val = SPEAKERPOS if "here" in c else SPEAKERLOOK
v_copy["reference_object"] = val["reference_object"]
v_copy["contains_coreference"] = "resolved"
d[k] = v_copy
elif k == "filters":
# v is a reference object dict
for k_ in v:
if k_ == "contains_coreference":
v_copy = deepcopy(v)
if "this" in c or "that" in c:
v_copy["location"] = SPEAKERLOOK
v_copy["contains_coreference"] = "resolved"
else:
mems = memory.get_recent_entities("BlockObject")
if len(mems) == 0:
mems = memory.get_recent_entities(
"Mob"
) # if its a follow, this should be first, FIXME
if len(mems) == 0:
v_copy[k_] = "NULL"
else:
v_copy[k_] = mems[0]
else:
v_copy[k_] = mems[0]
d[k] = v_copy
# fix/delete this branch! its for old broken spec
else:
for k_ in v:
if k_ == "contains_coreference":
v_copy = deepcopy(v)
if "this" in c or "that" in c:
v_copy["location"] = SPEAKERLOOK
v_copy["contains_coreference"] = "resolved"
d[k] = v_copy
if __name__ == "__main__":
x = eval(
"{'dialogue_type': 'PUT_MEMORY', 'filters': {'reference_object':{'contains_coreference': 'yes'}}, 'upsert': {'memory_data': {'memory_type': 'TRIPLE', 'has_tag': 'j'}}}"
)
y = coref_resolve(None, x, "that is a j")
| craftassist-master | python/base_agent/dialogue_objects/dialogue_object_utils.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file has the definitions and properties of the components that go into the
action tree.
Following is a list of component nodes:
- Schematic, that can be of type:
- CategoryObject
- Shape, that can be of type:
- BlockShape
- RectanguloidShape
- HollowRectanguloidShape
- CubeShape
- HollowCubeShape
- SphereShape
- HollowSphereShape
- PyramidShape
- RectangleShape
- SquareShape
- TriangleShape
- CircleShape
- DiskShape
- EllipsoidShape
- DomeShape
- ArchShape
- TowerShape
- Location, that can be of type:
- Coordinates
- LocationDelta
- SpeakerLook
- SpeakerPos
- AgentPos
- BlockObject, that can be of type:
- Object
- PointedObject
- Mob
"""
import os
import random
from collections import OrderedDict
from generate_utils import *
SUBCOMPONENT_LABELS = [
"wall",
"roof",
"window",
"foundation",
"door",
"floor",
"ceiling",
"siding",
"column",
"porch",
"entrance",
"corner",
"balcony",
"railing",
"decoration",
"support",
"base",
"pillar",
"beam",
"step",
"ledge",
"fence",
"facade",
"overhang",
"footing",
"walkway",
"stairs",
"basement",
"chimney",
"doorway",
"cornerstone",
"deck",
"side",
"eave",
"sill",
"patio",
"frame",
"steps",
"windowsill",
"post",
"header",
"pane",
"ridge",
"roofing",
"awning",
"rooftop",
"trim",
"stair",
"gable",
"garden",
"light",
"brick",
"edge",
"fascia",
"entryway",
"gutter",
"platform",
"panel",
"foot",
"ground",
"trap",
"frontage",
"storage",
"torch",
"crawlspace",
"soffit",
"eaves",
"tower",
"parapet",
"jamb",
"attic",
"staircase",
"skylight",
"barrier",
"glass",
"terrace",
"room",
"doorstep",
"pier",
"ladder",
"bedroom",
"cladding",
"partition",
"kitchen",
"doorknob",
"stairway",
"opening",
"shutter",
"exterior",
"strut",
"garage",
"glazing",
"shingles",
"stoop",
"yard",
"sidewalk",
"rail",
"casing",
"substructure",
"paneling",
]
MOBS = [
"elder guardian",
"wither skeleton",
"stray",
"husk",
"zombie villager",
"skeleton horse",
"zombie horse",
"donkey",
"mule",
"evoker",
"vex",
"vindicator",
"creeper",
"skeleton",
"spider",
"zombie",
"slime",
"ghast",
"zombie pigman",
"enderman",
"cave spider",
"silverfish",
"blaze",
"magma cube",
"bat",
"witch",
"endermite",
"guardian",
"pig",
"sheep",
"cow",
"chicken",
"squid",
"mooshroom",
"horse",
"rabbit",
"polar bear",
"llama",
"parrot",
"villager",
"ocelot",
"wolf",
"shulker",
]
BLOCK_TYPES = [
"air",
"stone",
"granite",
"polished granite",
"diorite",
"polished diorite",
"andesite",
"polished andesite",
"dirt",
"coarse dirt",
"podzol",
"cobblestone",
"oak wood plank",
"spruce wood plank",
"birch wood plank",
"jungle wood plank",
"acacia wood plank",
"dark oak wood plank",
"oak sapling",
"spruce sapling",
"birch sapling",
"jungle sapling",
"acacia sapling",
"dark oak sapling",
"bedrock",
"flowing water",
"still water",
"flowing lava",
"still lava",
"sand",
"red sand",
"gravel",
"gold ore",
"iron ore",
"coal ore",
"oak wood",
"spruce wood",
"birch wood",
"jungle wood",
"oak leaves",
"spruce leaves",
"birch leaves",
"jungle leaves",
"sponge",
"wet sponge",
"glass",
"lapis lazuli ore",
"lapis lazuli block",
"dispenser",
"sandstone",
"chiseled sandstone",
"smooth sandstone",
]
ABSTRACT_SIZE = [
"really tiny",
"very tiny",
"tiny",
"really small",
"very small",
"really little",
"very little",
"small",
"little",
"medium",
"medium sized",
"big",
"large",
"really big",
"very big",
"really large",
"very large",
"huge",
"gigantic",
"really huge",
"very huge",
"really gigantic",
"very gigantic",
]
COLOURS = ["red", "blue", "green", "yellow", "purple", "grey", "brown", "black", "orange"]
with open(os.path.join(os.path.dirname(__file__), "categories.txt")) as f:
CATEGORIES = [line.strip() for line in f.readlines()] + SUBCOMPONENT_LABELS
SHAPE_NAMES = [
"box",
"rectanguloid",
"cube",
"empty box",
"hollow box",
"hollow rectanguloid",
"cube",
"empty cube",
"hollow cube",
"ball",
"sphere",
"dome",
"empty sphere",
"empty ball",
"hollow ball",
"spherical shell",
"hollow sphere",
"pyramid",
"rectangle",
"square",
"triangle",
"circle",
"disk",
"ellipsoid",
"dome",
"arch",
"tower",
"wall",
"platform",
"slab",
]
CONCRETE_OBJECT_NAMES = SHAPE_NAMES + SUBCOMPONENT_LABELS + CATEGORIES
CONDITION_TYPES = ["ADJACENT_TO_BLOCK_TYPE", "NEVER"]
class ComponentNode:
"""This class is a node in the action tree and represents the components of the
tree that are not Actions.
A node can have a list of node types, it can be (CHOICES).
generate() : is responsible for initializing the CHOICES.
generate_description() : Generates the natural language description.
to_dict() : Generates the action tree recursively over the children.
"""
CHOICES = None # a list of node types that can be substituted for this node
def __init__(self, template_attr={}):
self.args = None # populated by self.generate()
self.description = None # populated by self.generate_description()
self._action_description = None
self._template_attr = template_attr
def generate_description(self):
if self.description is None:
self.description = self._generate_description()
return self.description
@classmethod
def generate(cls):
if cls.CHOICES:
c = random.choice(cls.CHOICES)
return c.generate()
return cls()
def __repr__(self):
if self.args:
return "<{} ({})>".format(type(self).__name__, ", ".join(map(str, self.args)))
else:
return "<{}>".format(type(self).__name__)
def to_dict(self):
d = {}
if hasattr(self, "location_type") and type(self.location_type) == type:
self.location_type = to_snake_case(self.location_type.__name__, case="upper")
if self.location_type in ["BLOCK_OBJECT", "MOB"]:
self.location_type = "REFERENCE_OBJECT"
# For each recursive child, pass along the description of topmost action.
if getattr(self, "_location", None) is not None:
self._location._action_description = self._action_description
d["location"] = self._location.to_dict()
if getattr(self, "_reference_object", None) is not None:
self._reference_object._action_description = self._action_description
d["reference_object"] = self._reference_object.to_dict()
if getattr(self, "_block_object", None) is not None:
self._block_object._action_description = self._action_description
d["reference_object"] = self._block_object.to_dict()
if getattr(self, "_block_object_1", None) is not None:
self._block_object_1._action_description = self._action_description
d["reference_object_1"] = self._block_object_1.to_dict()
if getattr(self, "_block_object_2", None) is not None:
self._block_object_2._action_description = self._action_description
d["reference_object_2"] = self._block_object_2.to_dict()
if getattr(self, "_repeat", None):
self._repeat._action_description = self._action_description
# For between or any repeats that only need plural of names
# don't add repeat dict
if self._repeat.to_dict()["repeat_key"] != "ALL_ONLY":
d["repeat"] = self._repeat.to_dict()
if getattr(self, "_mob", None) is not None:
self._mob._action_description = self._action_description
d["reference_object"] = self._mob.to_dict()
if getattr(self, "_mob_1", None) is not None:
self._mob_1._action_description = self._action_description
d["reference_object_1"] = self._mob_1.to_dict()
if getattr(self, "_mob_2", None) is not None:
self._mob_2._action_description = self._action_description
d["reference_object_2"] = self._mob_2.to_dict()
# fix reference object filters
for key in ["reference_object", "reference_object_1", "reference_object_2"]:
if key in d:
val = d[key]
if "repeat" in val:
d[key] = {"repeat": val["repeat"]}
val.pop("repeat")
d[key]["filters"] = val
else:
d[key] = {"filters": val}
if getattr(self, "_memory_data", None) is not None:
self._memory_data._action_description = self._action_description
d["memory_data"] = self._memory_data.to_dict()
for attr, val in self.__dict__.items():
if (
not attr.startswith("_")
and val not in (None, "")
and attr != "args"
and attr != "description"
and attr != "template"
):
d[attr] = val
if (attr.startswith("has_")) or (
attr
in ["coordinates", "steps", "block_type", "repeat_count", "target_action_type"]
):
span = find_span(self._action_description, val)
d[attr] = span
# fix location type now
if "location_type" in d:
value = d["location_type"]
if value in ["SPEAKER_LOOK", "AGENT_POS", "SPEAKER_POS", "COORDINATES"]:
updated_value = value # same for coordinates and speaker_look
if value == "AGENT_POS":
updated_value = "AGENT"
elif value == "SPEAKER_POS":
updated_value = "SPEAKER"
elif value == "COORDINATES":
updated_value = {"coordinates_span": d["coordinates"]}
# add to reference object instead
if "reference_object" in d:
d["reference_object"]["special_reference"] = updated_value
else:
d["reference_object"] = {"special_reference": updated_value}
d.pop("location_type")
d.pop("coordinates", None)
return d
###############
## SCHEMATIC ##
###############
class CategoryObject(ComponentNode):
"""CategoryObject is picked from a list of objects we have from the
minecraft_specs folder.
__init__ (): Pick the object, assign name and block_type.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(template_attr=template_attr)
cat_object = random.choice(self._template_attr.get("non_shape_names", CATEGORIES))
if repeat_key:
cat_object = make_plural(cat_object)
self.has_name = cat_object
self.has_block_type = (
random.choice(self._template_attr.get("block_types", BLOCK_TYPES))
if block_type
else None
)
def _generate_description(self):
out_dict = {}
out_dict["word"] = self.has_name
if self.has_block_type:
out_dict["block_type"] = self.has_block_type
return out_dict
class Shape(ComponentNode):
"""Shape is a superclass for different Shape types like: Cube, rectanguloid,
sphere etc.
__init__(): Picks the block_type. The specific shape attributes are assigned in the individual
child classes.
"""
KEYS = [
"has_size",
"has_thickness",
"has_radius",
"has_height",
"has_slope",
"has_orientation",
"has_distance",
"has_base",
]
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(template_attr=template_attr)
self.has_block_type = (
random.choice(self._template_attr.get("block_types", BLOCK_TYPES))
if block_type
else None
)
self.has_name = None
def _generate_description(self):
of = random.choice(["of", "with"])
attrs = []
for key in self.KEYS:
val = getattr(self, key, None)
if val is None:
continue
if type(val) in (list, tuple):
# For has_size format the text as: a b c
# a x b x c or a by b by c
if key == "has_size":
val = random.choice(
[
" ".join(map(str, val)),
" x ".join(map(str, val)),
" by ".join(map(str, val)),
]
)
key = key[4:] # extract "size" from "has_size"
attrs.append("{} {} {}".format(of, key, val))
random.shuffle(attrs)
out_dict = {}
out_dict["word"] = self._word
if attrs:
out_dict["shape_attributes"] = attrs
if self.has_block_type:
out_dict["block_type"] = self.has_block_type
return out_dict
class BlockShape(Shape):
"""Subclass of Shape represents a single block.
__init__(): Assigning shape type, size and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type)
# block is a 1 X 1 X 1 rectanguloid
"""schematic_attributes specifies whether any 1x3 size can be assigned or height, width etc
are assigned separately one at a time.
"""
self._word = random.choice(["block", "square"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class RectanguloidShape(Shape):
"""Subclass of Shape represents a rectanguloid.
__init__(): Assigning shape type, size and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
# rectanguloid is width x height x thickness
"""schematic_attributes specifies whether any 1x3 size can be assigned or height, width etc
are assigned separately one at a time.
"""
if schematic_attributes:
if type(schematic_attributes) == bool:
self.has_size = random.sample(
self._template_attr.get("size", range(3, 51)), 3
) # pick 3 random numbers
elif type(schematic_attributes) == dict: # assign only what's specified.
if "height" in schematic_attributes:
self.has_height = schematic_attributes["height"]
if "width" in schematic_attributes:
self.has_width = schematic_attributes["width"]
self._word = random.choice(["rectanguloid"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class HollowRectanguloidShape(Shape):
"""Subclass of Shape, represents a hollow rectanguloid.
__init__(): Assigning shape type, size, thickness and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if (
schematic_attributes
): # schematic_attributes specifies that the size and thickness have to be assigned
self.has_size = random.sample(self._template_attr.get("size", range(3, 51)), 3)
self.has_thickness = (
random.choice(self._template_attr.get("thickness", range(1, 6)))
if pick_random()
else None
)
self._word = random.choice(["box", "empty box", "hollow box", "hollow rectanguloid"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class CubeShape(Shape):
"""Subclass of Shape, represents a cube.
__init__(): Assigning shape type, size and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
self.has_size = (
random.choice(self._template_attr.get("size", range(3, 51)))
if schematic_attributes
else None
)
self._word = random.choice(["cube"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class HollowCubeShape(Shape):
"""Subclass of Shape, represents a hollow cube.
__init__(): Assigning shape type, size, thickness and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
self.has_size = random.choice(self._template_attr.get("size", range(3, 51)))
self.has_thickness = (
random.choice(self._template_attr.get("thickness", range(1, 6)))
if pick_random()
else None
)
self._word = random.choice(["empty cube", "hollow cube"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class SphereShape(Shape):
"""Subclass of Shape, represents a sphere.
__init__(): Assigning shape type, radius and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
self.has_radius = random.choice(self._template_attr.get("radius", range(3, 51)))
self._word = random.choice(["ball", "sphere"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class HollowSphereShape(Shape):
"""Subclass of Shape, repesents a hollow sphere.
__init__(): Assigning shape type, radius, thickness and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
self.has_thickness = random.choice(self._template_attr.get("thickness", range(1, 6)))
self.has_radius = (
random.choice(self._template_attr.get("radius", range(3, 51)))
if pick_random()
else None
)
self._word = random.choice(
["empty sphere", "empty ball", "hollow ball", "spherical shell", "hollow sphere"]
)
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class PyramidShape(Shape):
"""Subclass of Shape, repesents a pyramid.
__init__(): Assigning shape type, radius, height, slope and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
self.has_radius = random.choice(self._template_attr.get("radius", range(3, 51)))
self.has_height = (
random.choice(self._template_attr.get("height", range(3, 51)))
if pick_random()
else None
)
self.has_slope = (
random.choice(self._template_attr.get("slope", range(1, 11)))
if pick_random()
else None
)
self._word = random.choice(["pyramid"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class RectangleShape(Shape):
"""Subclass of Shape, repesents a rectangle.
__init__(): Assigning shape type, size, orientation type and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
if type(schematic_attributes) == bool:
self.has_size = random.sample(self._template_attr.get("size", range(3, 51)), 2)
self.has_orientation = random.choice(["xy", "yz", "xz"]) if pick_random() else None
elif type(schematic_attributes) == dict:
if "height" in schematic_attributes:
self.has_height = schematic_attributes["height"]
if "length" in schematic_attributes:
self.has_length = schematic_attributes["length"]
self._word = random.choice(["rectangle", "wall", "slab", "platform"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class SquareShape(Shape):
"""Subclass of Shape, repesents a square.
__init__(): Assigning shape type, size, orientation type and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
self.has_size = random.choice(self._template_attr.get("size", range(3, 51)))
self.has_orientation = random.choice(["xy", "yz", "xz"]) if pick_random() else None
self._word = random.choice(["square"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class TriangleShape(Shape):
"""Subclass of Shape, represents an equilateral triangle.
__init__(): Assigning shape type, size, orientation type, thickness and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
self.has_size = random.choice(self._template_attr.get("size", range(3, 11)))
self.has_orientation = random.choice(["xy", "yz", "xz"]) if pick_random() else None
self.has_thickness = (
random.choice(self._template_attr.get("thickness", range(1, 6)))
if pick_random()
else None
)
self._word = random.choice(["triangle"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class CircleShape(Shape):
"""Subclass of Shape, repesents a circle.
__init__(): Assigning shape type, radius, orientation type, thickness and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
self.has_radius = random.choice(self._template_attr.get("radius", range(3, 51)))
self.has_orientation = random.choice(["xy", "yz", "xz"]) if pick_random() else None
self.has_thickness = (
random.choice(self._template_attr.get("thickness", range(1, 6)))
if pick_random()
else None
)
self._word = random.choice(["circle"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class DiskShape(Shape):
"""Subclass of Shape, represents a disk.
__init__(): Assigning shape type, radius, orientation type, thickness and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
self.has_radius = random.choice(self._template_attr.get("radius", range(3, 51)))
self.has_orientation = random.choice(["xy", "yz", "xz"]) if pick_random() else None
self.has_thickness = (
random.choice(self._template_attr.get("thickness", range(1, 6)))
if pick_random()
else None
)
self._word = random.choice(["disk"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class EllipsoidShape(Shape):
"""Subclass of Shape, represents an ellipsoid.
__init__(): Assigning shape type, size, and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
self.has_size = (
random.sample(self._template_attr.get("size", range(3, 51)), 3)
if schematic_attributes
else None
)
self._word = random.choice(["ellipsoid"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class DomeShape(Shape):
"""Subclass of Shape, repesents a dome.
__init__(): Assigning shape type, radius, thickness and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
self.has_radius = random.choice(self._template_attr.get("radius", range(10, 51)))
self.has_orientation = random.choice(["xy", "yz", "xz"]) if pick_random() else None
self.has_thickness = (
random.choice(self._template_attr.get("thickness", range(1, 4)))
if pick_random()
else None
)
self._word = random.choice(["dome"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class ArchShape(Shape):
"""Subclass of Shape, repesents an arch.
__init__(): Assigning shape type, size, orientation type, distance and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
self.has_size = random.choice(self._template_attr.get("size", range(3, 51)))
self.has_orientation = random.choice(["xy", "xz"]) if pick_random() else None
self.has_distance = (
random.choice(self._template_attr.get("distance", range(1, 50, 2)))
if pick_random()
else None
)
self._word = random.choice(["arch", "archway"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class TowerShape(Shape):
"""Subclass of Shape, represents a tower.
__init__(): Assigning shape type, size, orientation type, distance and word.
"""
def __init__(
self, block_type=False, schematic_attributes=False, repeat_key=None, template_attr={}
):
super().__init__(block_type=block_type, template_attr=template_attr)
if schematic_attributes:
if type(schematic_attributes) == bool:
self.has_height = random.choice(self._template_attr.get("height", range(1, 12)))
self.has_base = (
random.choice(self._template_attr.get("base", range(-3, 6)))
if pick_random()
else None
)
elif type(schematic_attributes) == dict:
if "height" in schematic_attributes:
self.has_height = schematic_attributes["height"]
if "base" in schematic_attributes:
self.has_base = schematic_attributes["base"]
self._word = random.choice(["tower", "stack"])
if repeat_key:
self._word = make_plural(self._word)
self.has_name = self._word
class Schematic(ComponentNode):
"""A Schematic can be either a Shape or a CategoryObject
"""
def __init__(
self,
only_block_type=True, # only have a block type and no other attribute
block_type=False, # should the schematic have a block type
schematic_attributes=False, # a dict of explicit attributes requested if any
schematic_type=None, # type of Schematic : Shape or CategoryObject
abstract_size=None, # abstract size attribute
colour=None, # if the Schematic should have colour
repeat_key=None, # kind of repetition
repeat_dir=None, # direction of repetition
template_attr={},
multiple_schematics=False,
):
super().__init__(template_attr=template_attr)
self.has_size = None
self.has_colour = None
self._repeat = None
self._schematics_type = None
self.has_block_type = None
# if the Schematic only has a block type and no other attribute
if only_block_type:
self.has_block_type = random.choice(
self._template_attr.get("block_types", BLOCK_TYPES)
)
return
# if the type if given assing, else pick randomly
if schematic_type:
schematic_type = schematic_type
else:
schematic_type = random.choice([Shape, CategoryObject])
if schematic_type == Shape: # Shape class has CHOICES
schematic_type = random.choice(Shape.CHOICES)
# the repeat kind. 'FOR' indicates for count, 'ALL' indicates -> for every.
if repeat_key == "FOR":
random_step_count = random.choice(self._template_attr.get("count", range(1, 101)))
# pick a value for the count
repeat_count = random.choice(
[str(random_step_count), int_to_words(random_step_count), "a few", "some"]
)
self._repeat = Repeat(
repeat_key=repeat_key, repeat_count=repeat_count, repeat_dir=repeat_dir
)
elif repeat_key == "ALL":
self._repeat = Repeat(repeat_key="ALL", repeat_dir=repeat_dir)
elif repeat_key == "ALL_ONLY":
self._repeat = Repeat(repeat_key="ALL_ONLY")
self._schematics_type = schematic_type(
block_type=block_type,
schematic_attributes=schematic_attributes,
repeat_key=repeat_key,
template_attr=template_attr,
)
# Inherit the keys from schematic type for the action tree
for key, val in self._schematics_type.__dict__.items():
if key.startswith("has_"):
setattr(self, key, val)
if multiple_schematics:
cat_object_name = random.choice(self._template_attr.get("non_shape_names", CATEGORIES))
shape_name = random.choice(SHAPE_NAMES)
self.has_name = self.has_name + "__&&__" + random.choice([shape_name, cat_object_name])
if abstract_size: # add an abstract size if the flag is set
self.has_size = random.choice(ABSTRACT_SIZE)
if colour: # add colour if colour flag is set
self.has_colour = random.choice(COLOURS)
def _generate_description(self):
out_dict = OrderedDict()
# If the Schematic only has a block_type
if not self._schematics_type:
out_dict["block_type"] = self.has_block_type
return out_dict
# get the tree from the child an expand with the parent's attributes
child_dict = self._schematics_type.generate_description()
if self._repeat and self._repeat.repeat_key == "FOR":
out_dict["object_prefix"] = self._repeat.repeat_count
if self.has_size:
out_dict["size"] = self.has_size
if self.has_colour:
out_dict["colour"] = self.has_colour
out_dict.update(child_dict)
if "__&&__" in self.has_name:
out_dict["word"] = self.has_name
return out_dict
##############
## LOCATION ##
##############
class Coordinates(ComponentNode):
"""Coordinates is a list of x, y, z coordinates
__init__(): pick the coordinates
_generate_description() : different ways of representing coordinates in text
"""
def __init__(self, template_attr={}):
super().__init__(template_attr=template_attr)
self.coordinates = random.sample(
self._template_attr.get("coordinates", range(-100, 101)), 3
)
def __repr__(self):
return "<Abs {}>".format(self.coordinates)
def _generate_description(self):
location = random.choice(
[
"at loc {} {} {}",
"at location {} {} {}",
"at loc: {} {} {}",
"at location: {} {} {}",
"at coordinates: {} {} {}",
]
).format(*self.coordinates)
return location
class LocationDelta(ComponentNode):
"""LocationDelta picks the relative direction type.
__init__(): pick the direction type
"""
def __init__(
self,
relative_direction=True, # indicates relative to something vs itself
direction_type=None, # value of direction
additional_direction=None,
):
super().__init__()
self._relative_pos = relative_direction
if additional_direction is None:
additional_direction = []
# Assign value of _direction_type to be the key name if assigned, else True
direction_list = [
"LEFT",
"RIGHT",
"UP",
"DOWN",
"FRONT",
"BACK",
"AWAY",
] + additional_direction
self._direction_type = direction_type if direction_type else random.choice(direction_list)
def _generate_description(self):
direction_dict = {}
# LocationDelta being used as being relative to a BlockObject/ Mob
# vs being used with self (AgentPos)
if self._relative_pos:
direction_dict["LEFT"] = ["to the left of", "towards the left of"]
direction_dict["RIGHT"] = ["to the right of", "towards the right of"]
direction_dict["UP"] = ["above", "on top of", "to the top of", "over the", "over"]
direction_dict["DOWN"] = ["below", "under"]
direction_dict["FRONT"] = ["in front of"]
direction_dict["BACK"] = ["behind"]
direction_dict["AWAY"] = ["away from"]
direction_dict["INSIDE"] = ["inside"]
direction_dict["OUTSIDE"] = ["outside"]
direction_dict["NEAR"] = ["next to", "close to", "near"]
direction_dict["CLOCKWISE"] = ["clockwise"]
direction_dict["ANTICLOCKWISE"] = ["anticlockwise"]
direction_dict["BETWEEN"] = ["between", "in between", "in the middle of"]
direction_dict["ACROSS"] = ["across", "across from"]
else:
direction_dict["LEFT"] = ["to the left", "to your left", "east", "left"]
direction_dict["RIGHT"] = ["to the right", "to your right", "right", "west"]
direction_dict["UP"] = ["up", "north"]
direction_dict["DOWN"] = ["down", "south"]
direction_dict["FRONT"] = ["front", "forward", "to the front"]
direction_dict["BACK"] = ["back", "backwards", "to the back"]
direction_dict["AWAY"] = ["away"]
direction_dict["CLOCKWISE"] = ["clockwise"]
direction_dict["ANTICLOCKWISE"] = ["anticlockwise"]
return random.choice(direction_dict[self._direction_type])
class SpeakerLook(ComponentNode):
"""SpeakerLook is where the speaker is looking.
This class has no attributes of its own, except for the decription
"""
def _generate_description(self):
return random.choice(["there", "over there", "where I am looking"])
class SpeakerPos(ComponentNode):
"""SpeakerPos is where the speaker is.
This class has no attributes of its own, except for the decription
"""
def _generate_description(self):
return random.choice(["here", "over here"])
class AgentPos(ComponentNode):
"""AgentPos is where the agent is.
This class has no attributes of its own, except for the decription
"""
def _generate_description(self):
return random.choice(["where you are", "where you are standing"])
class Location(ComponentNode):
"""Location can be of different types: Coordinates, BlockObject, Mob,
AgentPos, SpeakerPos, SpeakerLook
__init__(): Pick the location_type, instantiate it (_child), pick location's coordinates
(if location_type == "Coordinates"), instantiate relative_direction if any, pick
number of steps.
"""
def __init__(
self,
location_type=None, # indicates whether type can be assigned and which one
relative_direction=None, # if relative direction id involved
relative_direction_value=None, # value of direction
additional_direction=None,
steps=False, # does Location involves steps
repeat_key=None, # repeat at Location
coref_resolve=None, # coref resolution type
bo_coref_resolve=None,
template_attr={},
):
def assign_relative_direction(self, relative_direction):
if relative_direction:
self.relative_direction = self._dirn_relative._direction_type
elif (relative_direction is None) and (self.location_type in [BlockObject, Mob]):
self.relative_direction = self._dirn_relative._direction_type
super().__init__(template_attr=template_attr)
self.steps = None
self.relative_direction = None
self.location_type = None
self.contains_coreference = None
relative_to_other = True # if True -> relative_direction is wrt to something else
# relative to itself.
"""Set the relative direction for location, if specified"""
self._dirn_relative = LocationDelta(
relative_direction=relative_to_other,
direction_type=relative_direction_value,
additional_direction=additional_direction,
)
assign_relative_direction(self, relative_direction)
"""Assign the location type"""
# Location type None is for no location type
if type(location_type) is not list:
location_type = [location_type]
bo_coref_resolve = [bo_coref_resolve] if bo_coref_resolve else None
if self.relative_direction == "BETWEEN" and len(location_type) == 1:
repeat_key = "ALL_ONLY"
self._child = []
for i, l_type in enumerate(location_type):
if l_type == "SpeakerLookMob":
# TODO: fix this!!
self.location_type = SpeakerLook
elif l_type not in [None, "ANY"]: # specific type
self.location_type = l_type
elif l_type == "ANY" and relative_direction: # relative to itself
relative_to_other = False
self.location_type = AgentPos
elif coref_resolve:
self.contains_coreference = coref_resolve
else:
# For type "ANY" or None specified, pick a random location
self.location_type = random.choice([Coordinates, BlockObject, Mob])
"""Pick the child and other attributes based on location type"""
if self.location_type not in [BlockObject, Mob]:
location_child = self.location_type() if self.location_type else None
self._child.append(location_child)
if self.location_type == Coordinates:
self.coordinates = self._child[-1].coordinates
elif self.location_type == BlockObject:
bo_type = None
no_child = False
if bo_coref_resolve and bo_coref_resolve[i]:
bo_type = PointedObject
no_child = True
# For BlockObjects, control the depth of the tree by removing the
# recursive location
coreference_type = (
bo_coref_resolve[i] if (bo_coref_resolve and bo_coref_resolve[i]) else None
)
self._child.append(
BlockObject(
block_object_location=False,
block_object_type=bo_type,
repeat_key=repeat_key,
coref_type=coreference_type,
no_child=no_child,
template_attr=template_attr,
)
)
if len(location_type) == 1:
self._block_object = self._child[-1]
elif i == 0:
self._block_object_1 = self._child[-1]
elif i == 1:
self._block_object_2 = self._child[-1]
# when the location_type needs to be SpeakerLook but we want properties of Mob
# eg : "follow that pig"
elif l_type == "SpeakerLookMob" or self.location_type == Mob:
mob_resolve = bo_coref_resolve[i] if bo_coref_resolve else None
self._child.append(
Mob(repeat_key=repeat_key, coref_type=mob_resolve, template_attr=template_attr)
)
if len(location_type) == 1:
self._mob = self._child[-1]
elif i == 0:
self._mob_1 = self._child[-1]
elif i == 1:
self._mob_2 = self._child[-1]
assign_relative_direction(self, relative_direction)
"""Select steps """
if steps:
random_step_count = random.choice(self._template_attr.get("step", range(1, 101)))
self.steps = random.choice(
[str(random_step_count), int_to_words(random_step_count), "few"]
)
def _generate_description(self):
out_dict = OrderedDict() # the OrderedDict ensures that the order of values is maintained.
if self.steps:
out_dict["steps"] = self.steps + " steps"
if self.relative_direction:
out_dict["relative_direction"] = self._dirn_relative.generate_description()
for child in self._child:
obj_name = to_snake_case(type(child).__name__) # key names are snake case
if child:
out_dict[obj_name] = child.generate_description()
if self.contains_coreference:
out_dict["coref"] = self.contains_coreference
return out_dict
#################
## BLOCKOBJECT ##
#################
class Object(ComponentNode):
"""Object can be any generic thing that exists in the Minecraft environment.
__init__(): Pick the size and colour
The name of the object is picked in _generate_description() and can be : 'thing', 'shape', 'structure', 'object'
"""
def __init__(
self, repeat_key_val=None, coref_type=None, template_attr={}
): # value of repeat key
super().__init__(template_attr=template_attr)
self._repeat = None
self._repeat_all_text = None
# Pick size and color at random.
self.has_size = random.choice([""] + ABSTRACT_SIZE) if pick_random() else None
self.has_colour = random.choice([""] + COLOURS) if pick_random() else None
# The object can either be an abstract shape with size / color or a concrete named object.
"""If none of size and colour have been picked, deifnitely pick a name,
to avoid : the shape , the structure etc"""
if (not self.has_size) and (not self.has_colour):
self.has_name = random.choice(
self._template_attr.get("non_shape_names", CONCRETE_OBJECT_NAMES)
)
else:
self.has_name = (
random.choice(self._template_attr.get("non_shape_names", CONCRETE_OBJECT_NAMES))
if pick_random()
else None
)
# pick the kind of repetition
if repeat_key_val:
if repeat_key_val == "ALL":
self._repeat = Repeat(repeat_key="ALL")
self._repeat_all_text = random.choice(["all", "each", "every"])
elif repeat_key_val == "ALL_ONLY":
self._repeat = Repeat(repeat_key="ALL_ONLY")
else:
self._repeat = Repeat(repeat_key="FOR", repeat_count=repeat_key_val)
# make name plural for all kind of repeats except for 'each' and 'every'.
if self.has_name and self._repeat:
repeat_key_type = self._repeat.repeat_key
if (
repeat_key_type == "FOR"
or (repeat_key_type == "ALL" and self._repeat_all_text == "all")
or repeat_key_type == "ALL_ONLY"
):
self.has_name = make_plural(self.has_name)
def _generate_description(self):
out_dict = {}
out_dict["object_prefix"] = "the"
if self._repeat:
repeat_key_type = self._repeat.repeat_key
if repeat_key_type == "ALL":
out_dict["object_prefix"] = self._repeat_all_text
elif repeat_key_type == "FOR":
out_dict["object_prefix"] = self._repeat.repeat_count
if self.has_size:
out_dict["size"] = self.has_size
if self.has_colour:
out_dict["colour"] = self.has_colour
if self.has_name:
out_dict["name"] = self.has_name
if "name" not in out_dict:
phrase = random.choice(["thing", "shape", "structure", "object"])
if self._repeat:
repeat_key_type = self._repeat.repeat_key
if (
repeat_key_type == "FOR"
or (repeat_key_type == "ALL" and self._repeat_all_text == "all")
or repeat_key_type == "ALL_ONLY"
):
phrase = make_plural(phrase)
out_dict["object"] = phrase
return out_dict
class PointedObject(ComponentNode):
"""PointedObject is an object that the speaker is pointing at.
__init__(): Pick the size and colour
The name is picked later in _generate_description
"""
KEYS = ["has_size", "has_colour"]
def __init__(
self, repeat_key_val=None, coref_type=None, template_attr={}
): # value of repeat key
super().__init__(template_attr=template_attr)
self._coref_type = coref_type
self._repeat = None
self.has_size = random.choice([""] + ABSTRACT_SIZE) if pick_random() else None
self.has_colour = random.choice([""] + COLOURS) if pick_random() else None
self._word = random.choice(["this", "that"])
# the kind of repetition
if repeat_key_val:
if repeat_key_val in ["ALL", "ALL_ONLY"]:
self._repeat = Repeat(repeat_key=repeat_key_val)
else:
self._repeat = Repeat(repeat_key="FOR", repeat_count=repeat_key_val)
self.has_name = (
random.choice(self._template_attr.get("non_shape_names", CONCRETE_OBJECT_NAMES))
if pick_random()
else None
)
if self.has_name and self._repeat:
self.has_name = make_plural(self.has_name)
def _generate_description(self):
out_dict = {}
out_dict["object_prefix"] = self._word
out_dict["object"] = None
if self._repeat:
repeat_key_type = self._repeat.repeat_key
if repeat_key_type == "ALL":
if self._coref_type:
out_dict["object_prefix"] = "each of"
else:
out_dict["object_prefix"] = "each of " + random.choice(["those", "these"])
elif repeat_key_type == "FOR":
phrase = random.choice(["those ", "these "])
if self._coref_type:
out_dict["object_prefix"] = self._repeat.repeat_count
else:
out_dict["object_prefix"] = phrase + self._repeat.repeat_count
if self.has_size:
out_dict["size"] = self.has_size
if self.has_colour:
out_dict["colour"] = self.has_colour
if self.has_name:
out_dict["name"] = self.has_name
object_description = random.choice(["thing", "shape", "structure", "object"])
if self._repeat:
object_description = make_plural(object_description)
# If size or colour assigned, it needs to have a description/ name.
if ("size" in out_dict) or ("colour" in out_dict):
if "name" not in out_dict:
out_dict["object"] = object_description
else:
if self._repeat:
out_dict["object"] = object_description # the plural description
# Assign name/thing optionally
elif "name" not in out_dict:
out_dict["object"] = object_description if pick_random() else None
return out_dict
class BlockObject(ComponentNode):
"""BlockObject can be anything that physically exists in the Minecraft environment.
There can be two types of physical objects: PointedObject or an Object, as described above,
__init__(): Pick the block_object_type, size, colour, description of the object.
If an explicit list of block_object_attributes is given, those are assigned, otherwise
inherit the child's attributes.
If block_object_type is specified, assign that, else picked randomly.
If block_object_location is specified, then assign a location else location is optional.
"""
def __init__(
self,
block_object_type=None, # the kind of BlockObject: Object / PointedObject
block_object_attributes=None, # explicit attributes of the blockobject
block_object_location=None, # the location of the blockobject if any
no_child=False, # should this blockobject have a child
repeat_key=None, # what kind of repetition
repeat_no_child=None, # if only repeat and no children
repeat_location=None, # repetition in location
coref_type=None, # coreference type
template_attr={},
):
super().__init__(template_attr=template_attr)
self.has_size = None
self.has_colour = None
self._object_desc = None
self._location = None
self.has_name = None
self._repeat = None
block_object_repeat_cnt = None
# the kind of repetition
if repeat_key == "FOR":
random_step_count = random.choice(self._template_attr.get("count", range(1, 101)))
block_object_repeat_cnt = random.choice(
[str(random_step_count), int_to_words(random_step_count), "few"]
)
self._repeat = Repeat(repeat_key=repeat_key, repeat_count=block_object_repeat_cnt)
elif repeat_key == "ALL":
self._repeat = Repeat(repeat_key="ALL")
block_object_repeat_cnt = "ALL"
elif repeat_key == "ALL_ONLY":
self._repeat = Repeat(repeat_key="ALL_ONLY")
block_object_repeat_cnt = "ALL_ONLY"
# If only repeat_key and no other children
if repeat_no_child:
return
"""Assign block object type"""
# If object_type is specified, assign that, else pick at random
# for "what you built" etc
if coref_type:
self.contains_coreference = coref_type
if block_object_type is None and coref_type is not None:
return
elif block_object_type:
self._block_object_type = block_object_type
else:
self._block_object_type = Object # PointedObject if pick_random(0.4) else Object
self._child = self._block_object_type(
repeat_key_val=block_object_repeat_cnt,
coref_type=coref_type,
template_attr=template_attr,
)
"""Assign block object's attributes"""
# If attribute list is not explicitly defined, pull all from
# children if child exists.
if not block_object_attributes and (not no_child):
for key, val in self._child.__dict__.items():
if key.startswith("has_"):
setattr(self, key, val)
elif block_object_attributes is not None:
# Only assign the specified attributes
for attr in block_object_attributes:
if attr == "size":
self.has_size = random.choice(ABSTRACT_SIZE)
if attr == "colour":
self.has_colour = random.choice(COLOURS)
if attr == "object":
thing_desc = random.choice(["thing", "shape", "structure", "object"])
self._object_desc = thing_desc
if attr == "objects":
self._object_desc = make_plural(
random.choice(["thing", "shape", "structure", "object"])
)
if attr == "name":
name_desc = random.choice(
self._template_attr.get("non_shape_names", CONCRETE_OBJECT_NAMES)
)
self.has_name = name_desc
if attr == "names":
self.has_name = make_plural(
random.choice(
self._template_attr.get("non_shape_names", CONCRETE_OBJECT_NAMES)
)
)
"""Assign block object location"""
if self._block_object_type == PointedObject:
if coref_type:
self._location = None # Location(coref_resolve=coref_type)
else:
self._location = Location(location_type=SpeakerLook, template_attr=template_attr)
# coref_type_val = coref_type if coref_type else self._child._word
else:
# If generic Object, if location explicitly specified then assign else optional.
if block_object_location is True:
self._location = Location(template_attr=template_attr)
elif block_object_location is False:
self._location = None
elif block_object_location is None:
self._location = Location(template_attr=template_attr) if pick_random() else None
elif block_object_location in [BlockObject, Mob]:
self._location = Location(
location_type=block_object_location,
repeat_key=repeat_location,
template_attr=template_attr,
)
def _generate_description(self):
# Also populate things from child, in case default values are needed
# Example when BlockObject is a reference for a Location.
object_desc = self._child.generate_description()
locn_desc = None
if self._block_object_type == Object and self._location:
locn_desc = self._location.generate_description()
out_dict = OrderedDict()
out_dict["object_prefix"] = object_desc["object_prefix"]
if self.has_size:
out_dict["size"] = self.has_size
if self.has_colour:
out_dict["colour"] = self.has_colour
if self.has_name:
out_dict["name"] = self.has_name
if self._object_desc:
out_dict["object"] = self._object_desc
# We need this when BlockObject is used as a reference_object
if "object" in object_desc and object_desc["object"]:
out_dict["abstract_structure"] = object_desc["object"]
if locn_desc:
out_dict["location"] = locn_desc
return out_dict
#################
## MOB ##
#################
class Mob(ComponentNode):
"""Mob is a mobile object in Minecraft. We have a list of these defined at the top.
__init__(): Pick the mob name and location
"""
def __init__(
self,
mob_location=None, # specify the location of the mob if any
repeat_key=None, # the kind of repetition
repeat_location=None, # repetitions in location if allowed
coref_type=None,
template_attr={},
):
super().__init__(template_attr=template_attr)
self._repeat = None
self._location = None
self.has_name = random.choice(self._template_attr.get("mob_names", MOBS))
self.contains_coreference = coref_type
"""Assign location of the mob if any"""
if mob_location:
self._location = Location(
location_type=mob_location, repeat_key=repeat_location, template_attr=template_attr
)
# the kind of repetition
if repeat_key == "FOR":
random_step_count = random.choice(self._template_attr.get("count", range(1, 101)))
repeat_count = random.choice(
[str(random_step_count), int_to_words(random_step_count), "few"]
)
self._repeat = Repeat(repeat_key=repeat_key, repeat_count=repeat_count)
elif repeat_key in ["ALL", "ALL_ONLY"]:
self._repeat = Repeat(repeat_key=repeat_key)
def _generate_description(self):
location_desc = None
if self._location:
location_desc = self._location.generate_description()
out_dict = {}
if self._repeat:
key_type = self._repeat.repeat_key
if key_type == "ALL":
out_dict["mob_prefix"] = random.choice(["all the", "each", "every", "all"])
elif key_type == "FOR":
out_dict["mob_prefix"] = self._repeat.repeat_count
elif key_type == "ALL_ONLY":
out_dict["mob_prefix"] = "the"
elif pick_random():
out_dict["mob_prefix"] = "the"
# update name to be plural if repetitions
if self._repeat:
if ("mob_prefix" not in out_dict) or (out_dict["mob_prefix"] not in ["each", "every"]):
self.has_name = make_plural(self.has_name)
out_dict["mob"] = self.has_name
if location_desc:
out_dict["location"] = location_desc
return out_dict
####################
## STOP CONDITION ##
####################
class StopCondition(ComponentNode):
"""Stop Condition defines the condition to terminate a loop.
The different stop condition types are specified in : CONDITION_TYPES
__init__(): Assign the condition type and other keys based on the condition
"""
def __init__(
self,
condition_type=None, # condition type to terminate the loop
block_type=None, # optional, needed for condition_type: AdjacentToBlockType
):
super().__init__()
self.condition_type = condition_type if condition_type else None
self.block_type = (
random.choice(self._template_attr.get("block_types", BLOCK_TYPES))
if block_type
else None
)
def _generate_description(self):
out_dict = {}
if self.block_type:
out_dict["block_type"] = self.block_type
return out_dict
##################
### REPEAT ###
##################
class Repeat(ComponentNode):
"""Repeat class defines the kind of loop, the number of times the loop should
be run as well the direction of loop execution.
"""
def __init__(
self,
repeat_key=None, # the loop type: 'FOR' / 'ALL'
repeat_count=None, # optional, needed for counting the loop
repeat_dir=None, # the direction of loop execution
):
super().__init__()
self.repeat_key = repeat_key if repeat_key else None
self.repeat_count = repeat_count if repeat_count else None
self.repeat_dir = repeat_dir if repeat_dir else None
def _generate_description(self):
return {}
###################
### FILTERS ###
###################
class Filters(ComponentNode):
"""Filters class defines the name of filters and their values.
This is used with GetMemory and PutMemory actions
"""
def __init__(
self,
temporal=None, # the temporal value
mem_type=None, # type of memory object
action_type=None,
block_object_attr=None,
bo_updated=False,
location_attr=None,
location_updated=False,
mob_attr=None,
mob_updated=False,
):
super().__init__()
self.temporal = temporal if temporal else None
self.type = mem_type if mem_type else None
self.action_type = action_type if action_type else None
self._location = None
self._reference_object = None
if bo_updated:
self._reference_object = BlockObject(**block_object_attr)
if location_updated:
self._location = Location(**location_attr)
if mob_updated:
self._reference_object = Mob(**mob_attr)
def _generate_description(self):
out_dict = {}
if self._reference_object:
out_dict = self._reference_object.generate_description()
if self._location:
out_dict.update(self._location.generate_description())
return out_dict
###################
### UPSERT ###
###################
class Upsert(ComponentNode):
"""Upsert class defines the memoryt type and data that needs to be upserted
into the bot's memory
"""
def __init__(
self, memory_type=None, reward_value=None, has_tag=None, has_size=None, has_colour=None
):
super().__init__()
self._memory_data = None
if memory_type:
self._memory_data = MemoryData(
reward_value=reward_value,
memory_type=memory_type,
has_tag=has_tag,
has_size=has_size,
has_colour=has_colour,
)
def _generate_description(self):
return {}
######################
### MemoryData ###
######################
class MemoryData(ComponentNode):
def __init__(
self, reward_value=None, memory_type=None, has_tag=None, has_colour=None, has_size=None
):
super().__init__()
self.reward_value = reward_value if reward_value else None
self.memory_type = memory_type if memory_type else None
self.has_tag = has_tag if has_tag else None
self.has_size = has_size if has_size else None
self.has_colour = has_colour if has_colour else None
def _generate_description(self):
return {}
##################
## CHOICE LISTS ##
##################
Shape.CHOICES = [
RectanguloidShape,
HollowRectanguloidShape,
CubeShape,
HollowCubeShape,
SphereShape,
HollowSphereShape,
PyramidShape,
RectangleShape,
SquareShape,
TriangleShape,
CircleShape,
DiskShape,
EllipsoidShape,
DomeShape,
ArchShape,
TowerShape,
BlockShape,
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/tree_components.py |
import numpy as np
import random
from generate_dialogue import generate_actions
import sys
import os
import uuid
import json
TTAD_GEN_DIR = os.path.dirname(os.path.realpath(__file__))
CRAFTASSIST_DIR = os.path.join(TTAD_GEN_DIR, "../../")
sys.path.append(CRAFTASSIST_DIR)
from generate_data import *
import re
from dialogue_objects.interpreter_helper import coref_resolve, interpret_shape_schematic
from word_maps import SPECIAL_SHAPE_FNS, SPECIAL_SHAPES_CANONICALIZE, SPAWN_OBJECTS
from size_words import size_str_to_int
import shapes
import block_data
import snowballstemmer
stemmer = snowballstemmer.stemmer("english")
# from word2number.w2n import word_to_num
CHOICES = [Move, Build, Destroy, Dig, Copy, Fill, Spawn, Dance]
#############################################################
# modified from size_words...
#############################################################
RANGES = {
"tiny": (2, 3),
"small": (2, 3),
"medium": (2, 4),
"large": (4, 5),
"huge": (5, 6),
"gigantic": (5, 6),
}
class Dummy:
pass
def inspect_ads(template_attributes, condition):
while True:
a = get_good_ad(template_attributes)
if eval(condition):
print(a[0])
print(json.dumps(a[1], sort_keys=True, indent=4))
break
return a
def process_spans(d, words):
for k, v in d.items():
if type(v) == dict:
process_spans(v, words)
continue
try:
if k != "has_attribute":
sentence, (L, R) = v
if sentence != 0:
raise NotImplementedError("Must update process_spans for multi-string inputs")
assert 0 <= L <= R <= (len(words) - 1)
except ValueError:
continue
except TypeError:
continue
d[k] = " ".join(words[L : (R + 1)])
class EmptyWorkspaceMemory:
def get_recent_entities(self, x=None):
return []
def surgery_by_value(ad, old_value, new_value):
for k, v in ad.items():
if type(v) is dict:
surgery_by_value(v, old_value, new_value)
else:
if v == old_value:
ad[k] = new_value
def get_fields_by_key(ad_and_parent, key):
parent = ad_and_parent[0]
ad = ad_and_parent[1]
if type(ad) is not dict:
return []
else:
values = []
for k, v in ad.items():
u = get_fields_by_key((k, v), key)
values.extend(u)
if k == key:
values.append((parent, v))
return values
# TODO make sure if object has attributes and a location
# e.g. speakerlook there isn't a conflict ?
def get_good_ad(template_attributes, flat=False):
ok = False
while not ok:
ad_and_text = generate_actions(1, CHOICES, template_attributes)
ok = True
if len(ad_and_text[0][0]) > 1:
# filter dialogues
ok = False
continue
text = ad_and_text[0][0][0]
ad = ad_and_text[1][0]["action_sequence"][0]
atpd = template_attributes.get("distribution")
if atpd is not None:
if np.random.rand() > atpd[ad["action_type"]]:
ok = False
continue
fill_spans_and_coref_resolve(ad, text)
ref_objs = get_fields_by_key((None, ad), "reference_object")
if len(ref_objs) > 0:
for r in ref_objs:
p = r[0]
o = r[1]
# filter things like 'go above the 5 cubes'
if p == "location" and o.get("repeat") is not None:
ok = False
# filter things like 'destroy the 5 cubes' (unfortunately killing 'all' rn too, FIXME)
if ad["action_type"] == "DESTROY" and o.get("repeat") is not None:
ok = False
# filter things like 'copy the 5 cubes' (unfortunately killing 'all' rn too, FIXME)
if ad["action_type"] == "BUILD" and o.get("repeat") is not None:
ok = False
# filter "between" FIXME!!!! probably should do two-object betweens
# betweens = get_fields_by_key((None, ad), "reference_object_1")
# if len(betweens)>0:
# ok = False
# but one object one would lead to bias bc of duplicate
betweens = get_fields_by_key((None, ad), "relative_direction")
if len(betweens) > 0 and betweens[0][1] == "BETWEEN":
ok = False
# filter exact coordinates
c = get_fields_by_key((None, ad), "coordinates")
if len(c) > 0:
ok = False
# filter stop conditions of 'ADJACENT_TO_BLOCK_TYPE'
c = get_fields_by_key((None, ad), "condition_type")
if len(c) > 0 and c[0][1] == "ADJACENT_TO_BLOCK_TYPE":
ok = False
# FOR NOW, FILTERING RELDIRS UP, DOWN, INSIDE, OUTSIDE, AWAY!!! FIXME!!
c = get_fields_by_key((None, ad), "relative_direction")
if len(c) > 0 and c[0][1] in ["UP", "DOWN", "INSIDE", "OUTSIDE", "AWAY"]:
ok = False
r = get_fields_by_key((None, ad), "repeat_key")
# filter finite repeats of move actions ("move three steps twice")
if ad["action_type"] == "MOVE" and len(r) > 0 and r[0][1] == "FOR":
ok = False
# filter large objects
# s = get_fields_by_key((None, ad), "has_size")
# for i in s:
# for size in ["gigantic", "huge", "colossal", "large", "big"]:
# if size in i[1]:
# new_size = random.choice(["medium", "small"])
# surgery_by_value(ad, size, new_size)
# text = text.replace(size, new_size)
r = get_fields_by_key((None, ad), "schematic")
if flat:
if len(r) > 0:
for s in r:
name = s[1].get("has_name")
if name is not None:
# FIXME this is not grammatical...
new_name = random.choice(template_attributes["non_shape_names"])
surgery_by_value(ad, name, new_name)
text = text.replace(name, new_name)
r = get_fields_by_key((None, ad), "has_block_type")
if len(r) > 0:
allowed_blocks = template_attributes.get("allowed_blocktypes")
if allowed_blocks:
for (_, btype) in r:
if btype not in allowed_blocks:
new_btype = random.choice(allowed_blocks)
text = text.replace(btype, new_btype)
surgery_by_value(ad, btype, new_btype)
# filter empty builds and empty moves:
# if ad["action_type"] == "MOVE": TODO
return text, ad, ref_objs
def fill_spans_and_coref_resolve(ad, text):
W = EmptyWorkspaceMemory()
process_spans(ad, re.split(r" +", text))
coref_resolve(W, ad)
return ad
def regularize_ref_obj_dict(ref_obj_dict, flat=False):
# TODO make me optional
if ref_obj_dict.get("has_colour") is None:
ref_obj_dict["has_colour"] = random.choice(list(block_data.COLOR_BID_MAP.keys()))
if flat:
ref_obj_dict["has_orientation"] = "xz"
if ref_obj_dict.get("has_size") is None:
ref_obj_dict["has_size"] = "medium"
# takes the piece of the action dict and makes it into a game object
# does not put locs, these need to be fixed after
def specify_object(ref_obj_dict, sl=32, flat=False):
shape_keys = [
"has_size",
"has_thickness",
"has_radius",
"has_depth",
"has_width",
"has_height",
"has_length",
"has_slope",
"has_orientation",
"has_distance",
"has_base",
"has_colour",
]
##############################################
# hack to deal with size ranges in size_words
##############################################
fake_interpreter = Dummy()
fake_interpreter.agent = Dummy()
def ssti(s):
return size_str_to_int(s, ranges=RANGES)
fake_interpreter.agent.size_str_to_int = ssti
name = ref_obj_dict.get("has_name")
if name is not None:
stemmed_name = stemmer.stemWord(name)
shapename = SPECIAL_SHAPES_CANONICALIZE.get(name) or SPECIAL_SHAPES_CANONICALIZE.get(
stemmed_name
)
if SPAWN_OBJECTS.get(name):
return name
elif SPAWN_OBJECTS.get(stemmed_name):
return stemmed_name
if shapename:
regularize_ref_obj_dict(ref_obj_dict, flat=flat)
blocks, _ = interpret_shape_schematic(
fake_interpreter, None, ref_obj_dict, shapename=shapename
)
return blocks
else:
# somethings wrong, abort
return None
else:
if ref_obj_dict.get("has_shape"):
regularize_ref_obj_dict(ref_obj_dict, flat=flat)
blocks, _ = interpret_shape_schematic(fake_interpreter, None, ref_obj_dict)
return blocks
elif any(k in shape_keys for k in ref_obj_dict.keys()):
regularize_ref_obj_dict(ref_obj_dict, flat=flat)
if flat:
shapename = random.choice(["TRIANGLE", "CIRCLE", "DISK", "RECTANGLE"])
else:
shapename = random.choice(list(SPECIAL_SHAPE_FNS.keys()))
blocks, _ = interpret_shape_schematic(
fake_interpreter, None, ref_obj_dict, shapename=shapename
)
return blocks
else:
# somethings wrong, abort
return None
def choose_loc(obj_rad, reldir, viewer_pos, view_vector, ref_obj_loc, sl=32, num_tries=100):
reldir_perp = np.array((-view_vector[1], view_vector[0]))
tform = np.stack((reldir_perp, view_vector), axis=1)
obj_coords = tform.transpose() @ (ref_obj_loc - viewer_pos)
for i in range(num_tries):
loc = np.random.randint(-sl // 2, sl // 2, size=(2))
loc_coords = tform.transpose() @ (loc - viewer_pos)
if reldir == "LEFT":
if loc_coords[0] > obj_coords[0] + obj_rad:
return loc
if reldir == "RIGHT":
if loc_coords[0] < obj_coords[0] - obj_rad:
return loc
if reldir == "BACK":
if loc_coords[1] < obj_coords[1] - obj_rad:
return loc
if reldir == "FRONT":
if loc_coords[1] > obj_coords[1] + obj_rad:
return loc
if reldir == "NEAR":
# 4 is arbitrary
if max(abs(np.subtract(loc, ref_obj_loc))) - obj_rad < 4:
return loc
return None
def maybe_speaker_look(ref_obj_dict, view_pos, sl):
location_type = ref_obj_dict.get("location", {}).get("location_type")
if location_type is not None and location_type == "SPEAKER_LOOK":
loc = np.add(view_pos, np.random.randint(-sl // 8, sl // 8, size=(2)))
else:
loc = np.random.randint(-sl // 2, sl // 2, size=(2))
return loc
# step 1, arrange all reference objects, holes to fill and player
# step 2, build decoys. for each ref object with some attributes (including a reference direction to another ref object)
# build/place a decoy with some attributes the same
# step 3, build random objects/mobs/pits
def build_ref_obj_scene(ad, ref_objs, sl=32, flat=False):
# first place the fake observer, we put them on a ring 75% away from the center of the cube, at ground level
c = np.random.randn(2)
c /= np.linalg.norm(c)
radius = 0.75 * sl / 2
p = radius * c
# the fake observer will look at the ground somewhere along a cone starting from the observer pointing towards
# the center of the square
# n = np.random.randn(2)
# n /= np.linalg.norm(n)
# n *= 0.05
# view_vector = -c + n
view_vector = -c
view_vector = view_vector / np.linalg.norm(
view_vector
) # unit vector in the direction of my look
d = radius + radius * np.random.uniform()
view_pos = p + d * view_vector # which grid location/cube (at ground height) am I looking at?
scene = {"mobs": [], "block_obj": [], "holes": []}
scene["fake_human"] = {"position": p, "view_vector": view_vector, "view_pos": view_pos}
scene["action_dict"] = ad
scene["ref_obj_dicts"] = {}
at = ad["action_type"]
if len(ref_objs) == 1 and at != "FILL" and at != "SPAWN":
# FIXME if loc is given in ad
loc = maybe_speaker_look(ref_objs[0][1], view_pos, sl)
obj = specify_object(ref_objs[0][1], sl=sl, flat=flat)
robj_id = uuid.uuid4().hex
scene["ref_obj_dicts"][robj_id] = ref_objs[0][1]
if type(obj) is str:
scene["mobs"].append({"mobname": obj, "loc": loc, "dict_id": robj_id})
return scene
else:
scene["block_obj"].append({"blocks": obj, "loc": loc, "dict_id": robj_id})
return scene
if len(ref_objs) == 1 and at == "FILL":
obj_loc = maybe_speaker_look(ref_objs[0][1], view_pos, sl)
obj = specify_object(ref_objs[0][1], sl=sl, flat=flat)
reldir = ad["location"]["relative_direction"]
robj_id = uuid.uuid4().hex
scene["ref_obj_dicts"][robj_id] = ref_objs[0][1]
if type(obj) is str:
scene["mobs"].append({"mobname": obj, "loc": obj_loc, "dict_id": robj_id})
hole_loc = choose_loc(1, reldir, view_pos, view_vector, obj_loc, sl=sl)
scene["holes"].append({"loc": hole_loc})
elif obj is not None and len(obj) > 0:
scene["block_obj"].append({"blocks": obj, "loc": obj_loc, "dict_id": robj_id})
bounds = shapes.get_bounds(obj)
rad = max(bounds[1] - bounds[0], bounds[3] - bounds[2], bounds[5] - bounds[4])
hole_loc = choose_loc(rad, reldir, view_pos, view_vector, obj_loc, sl=sl)
scene["holes"].append({"loc": hole_loc})
# TODO fix relative location; put this in choose_loc, input the ref_obj
elif ref_objs[0][1].get("location")["location_type"] == "SPEAKER_LOOK":
scene["holes"].append({"loc": view_pos.astype("int64")})
elif ref_objs[0][1].get("location")["location_type"] == "SPEAKER_POS":
scene["holes"].append({"loc": p.astype("int64")})
return scene
if len(ref_objs) == 2:
if at == "DESTROY":
reldir = ad["reference_object"]["location"]["relative_direction"]
if ref_objs[0][0] == "action":
d = ref_objs[0][1]
r = ref_objs[1][1]
else:
d = ref_objs[1][1]
r = ref_objs[0][1]
d_id = uuid.uuid4().hex
r_id = uuid.uuid4().hex
scene["ref_obj_dicts"][d_id] = d
scene["ref_obj_dicts"][r_id] = r
to_destroy_obj = specify_object(d, sl=sl, flat=flat)
rel_obj = specify_object(r, sl=sl, flat=flat)
rel_obj_loc = maybe_speaker_look(r, view_pos, sl)
if type(rel_obj) is str:
rad = 1
scene["mobs"].append({"mobname": rel_obj, "loc": rel_obj_loc, "dict_id": r_id})
else:
scene["block_obj"].append({"blocks": rel_obj, "loc": rel_obj_loc, "dict_id": r_id})
bounds = shapes.get_bounds(rel_obj)
rad = max(bounds[1] - bounds[0], bounds[3] - bounds[2], bounds[5] - bounds[4])
to_destroy_loc = choose_loc(rad, reldir, view_pos, view_vector, rel_obj_loc, sl=sl)
scene["block_obj"].append(
{"blocks": to_destroy_obj, "loc": to_destroy_loc, "dict_id": d_id}
)
return scene
# this is a copy, one ref object is to be copied, and the other gives
# the *target* location, so locations are independent
elif at == "BUILD":
if ref_objs[0][0] == "location":
c = ref_objs[1][1]
r = ref_objs[0][1]
else:
c = ref_objs[0][1]
r = ref_objs[1][1]
c_id = uuid.uuid4().hex
r_id = uuid.uuid4().hex
scene["ref_obj_dicts"][c_id] = c
scene["ref_obj_dicts"][r_id] = r
to_copy_obj = specify_object(c, sl=sl, flat=flat)
to_copy_obj_loc = maybe_speaker_look(c, view_pos, sl)
rel_obj = specify_object(r, sl=sl, flat=flat)
rel_obj_loc = np.random.randint(-sl // 2, sl // 2, size=(2))
scene["block_obj"].append(
{"blocks": to_copy_obj, "loc": to_copy_obj_loc, "dict_id": c_id}
)
if type(rel_obj) is str:
scene["mobs"].append({"mobname": rel_obj, "loc": rel_obj_loc, "dict_id": r_id})
else:
scene["block_obj"].append({"blocks": rel_obj, "loc": rel_obj_loc, "dict_id": r_id})
return scene
return scene
def add_distractors(
scene, template_attributes, sl=32, num_objs=3, num_holes=2, num_mobs=2, flat=False
):
while (
len(scene["block_obj"]) < num_objs
or len(scene["holes"]) < num_holes
or len(scene["mobs"]) < num_mobs
):
text, ad, ref_objs = get_good_ad(template_attributes, flat=flat)
distractor_scene = build_ref_obj_scene(ad, ref_objs, sl=sl, flat=flat)
if distractor_scene is not None:
# not careful about overlaps... should we be?
for bobj in distractor_scene["block_obj"]:
if len(scene["block_obj"]) < num_objs:
scene["block_obj"].append(bobj)
k = bobj["dict_id"]
v = distractor_scene["ref_obj_dicts"][k]
scene["ref_obj_dicts"][bobj["dict_id"]] = v
for hole in distractor_scene["holes"]:
if len(scene["holes"]) < num_holes:
scene["holes"].append(hole)
for mob in distractor_scene["mobs"]:
if len(scene["mobs"]) < num_mobs:
scene["mobs"].append(mob)
k = mob["dict_id"]
v = distractor_scene["ref_obj_dicts"][k]
scene["ref_obj_dicts"][mob["dict_id"]] = v
def get_slice(blocks, axis=0, coord=0):
return [b for b in blocks if b[0][axis] == coord]
def build_scene(template_attributes, sl=32, flat=False):
text, ad, ref_objs = get_good_ad(template_attributes, flat=flat)
S = build_ref_obj_scene(ad, ref_objs, sl=sl, flat=flat)
if S is not None:
S["non_distractors"] = []
for o in S["ref_obj_dicts"]:
S["non_distractors"].append(o)
S["text"] = text
add_distractors(S, template_attributes, sl=sl, flat=flat)
S["id_to_obj"] = {}
for m in S["mobs"]:
S["id_to_obj"][m["dict_id"]] = m
for m in S["block_obj"]:
S["id_to_obj"][m["dict_id"]] = m
if flat:
for b in S["block_obj"]:
if b["blocks"] is not None:
b["blocks"] = get_slice(b["blocks"], axis=1, coord=0)
return S
if __name__ == "__main__":
template_attributes = {"count": range(1, 5)}
template_attributes["step"] = range(1, 10)
template_attributes["non_shape_names"] = list(SPECIAL_SHAPES_CANONICALIZE.keys())
template_attributes["mob_names"] = ["pig", "sheep", "cow", "chicken", "rabbit"]
for i in range(1000):
print(i)
S = build_scene(template_attributes)
# import json
# x = {'a':{'at':'d', 'R':{'hs':'h', 'ha':'h', 'l':{'rd':'right', 'lt':'RO','R':{'hn':'donk'}}}}}
# print(json.dumps(x, sort_keys=True, indent=4))
# u = get_fields_by_key((None, x) , 'R')
# print(len(u))
| craftassist-master | python/base_agent/ttad/generation_dialogues/build_scene.py |
import os
import sys
sys.path.append(os.path.dirname(__file__))
| craftassist-master | python/base_agent/ttad/generation_dialogues/__init__.py |
if __name__ == "__main__":
import argparse
import pickle
import os
from tqdm import tqdm
from build_scene import *
from block_data import COLOR_BID_MAP
BLOCK_DATA = pickle.load(
open("/private/home/aszlam/minecraft_specs/block_images/block_data", "rb")
)
allowed_blocktypes = []
count = 0
for c, l in COLOR_BID_MAP.items():
for idm in l:
allowed_blocktypes.append(BLOCK_DATA["bid_to_name"][idm])
count += 1
parser = argparse.ArgumentParser()
parser.add_argument("--target", default="/checkpoint/aszlam/minecraft/inverse_model/flat_ads/")
parser.add_argument("--N", type=int, default=10000000)
# parser.add_argument("--num_per_chunk", type=int, default=10000000)
args = parser.parse_args()
template_attributes = {"count": range(1, 5)}
template_attributes["step"] = range(1, 10)
template_attributes["non_shape_names"] = ["triangle", "circle", "disk", "rectangle"]
template_attributes["mob_names"] = ["pig", "sheep", "cow", "chicken"]
template_attributes["allowed_blocktypes"] = allowed_blocktypes
template_attributes["distribution"] = {
"MOVE": 1.0,
"BUILD": 1.0,
"DESTROY": 1.0,
"DIG": 0.8,
"COPY": 0.8,
"FILL": 0.8,
"SPAWN": 0.1,
"DANCE": 0.8,
}
scenes = []
for i in tqdm(range(args.N)):
S = build_scene(template_attributes, sl=16, flat=True)
scenes.append(S)
f = open(os.path.join(args.target, "flat_scenes_dump.pk"), "wb")
pickle.dump(scenes, f)
f.close()
| craftassist-master | python/base_agent/ttad/generation_dialogues/build_scene_flat_script.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file generates action trees and language based on options from
command line.
"""
import json
from generate_data import *
class Action(ActionNode):
"""options for Actions"""
CHOICES = [
Move,
Build,
Destroy,
Noop,
Stop,
Resume,
Dig,
Copy,
Undo,
Fill,
Spawn,
Freebuild,
Dance,
GetMemory,
PutMemory,
]
human_give_command_actions = [
Move,
Build,
Destroy,
Stop,
Resume,
Dig,
Copy,
Undo,
Fill,
Spawn,
Freebuild,
Dance,
]
# Mapping of command line action type to action class
action_type_map = {
"move": Move,
"build": Build,
"destroy": Destroy,
"noop": Noop,
"stop": Stop,
"resume": Resume,
"dig": Dig,
"copy": Copy,
"undo": Undo,
"fill": Fill,
"spawn": Spawn,
"freebuild": Freebuild,
"dance": Dance,
"get_memory": GetMemory,
"put_memory": PutMemory,
}
arg_numeric_range_map = {
"length_range": "length",
"width_range": "width",
"depth_range": "depth",
"height_range": "height",
"size_range": "size",
"thickness_range": "thickness",
"radius_range": "radius",
"slope_range": "slope",
"distance_range": "distance",
"step_range": "step",
"count_range": "count",
"base_range": "base",
"coordinates_range": "coordinates",
}
arg_name_file_map = {
"non_shape_names": "non_shape_names",
"block_types_file": "block_types",
"mob_file": "mob_names",
}
child_key_map = {"BUILD": ["schematic", "reference_object"], "DESTROY": ["reference_object"]}
def add_new_similar_action(action_text, previous_action, name_2, curr_action, curr_index):
"""Append curr_action's action dict to previous_action's action_sequenceself.
curr_index is index of current action dict in action action_sequence"""
span = find_span(action_text, name_2)
action_type = curr_action["action_type"]
child_key = child_key_map[action_type]
child_key_name = None
for key in child_key:
if key in curr_action:
child_key_name = key
new_action = {child_key_name: {"has_name": span}, "action_type": action_type}
previous_action["action_sequence"].insert(curr_index + 1, new_action)
return previous_action
def fix_composite_in_dict(action_text, action_dict):
"""Find if action_dict has a schematic / reference_object that has two entitites
in it, if so, split them and create two different action dicts for each."""
action_description = [x.split() for x in action_text]
name_1, name_2 = None, None
sent_index = 0
if "action_sequence" in action_dict:
for i, curr_action in enumerate(action_dict["action_sequence"]):
action_type = curr_action["action_type"]
if action_type not in child_key_map:
continue
child_key = child_key_map[action_type]
for key in child_key:
if key in curr_action and "has_name" in curr_action[key]:
sent_index, indices = curr_action[key]["has_name"]
curr_sentence = action_text[sent_index]
curr_name = " ".join(curr_sentence.split()[indices[0] : indices[1] + 1])
if "__&&__" in curr_name:
# extract the two names
name_1, name_2 = curr_name.split("__&&__")
# fix the generated sentence
joining_word = random.choice([" and ", " and then "])
action_text[sent_index] = joining_word.join(curr_sentence.split("__&&__"))
# update the sentence split
action_description = [x.split() for x in action_text]
# fix this name's span
span = find_span(action_description, name_1)
curr_action[key]["has_name"] = span
# now add another action with the second name
action_dict = add_new_similar_action(
action_description, action_dict, name_2, curr_action, i
)
return action_dict
return action_dict
def fix_spans(d, prev_sentence_len):
"""This function updates the spans in d and shifts them by a value equal
to prev_sentence_len"""
for key, val in d.items():
if type(val) == list:
if type(val[0]) is int:
sent_index, span = val
index_1, index_2 = span
d[key] = [sent_index, [index_1 + prev_sentence_len, index_2 + prev_sentence_len]]
elif type(val[0]) is dict:
for v in val:
if type(v) is dict:
fix_spans(v, prev_sentence_len)
elif type(val) == dict:
fix_spans(val, prev_sentence_len)
return d
def combine_dicts(dict_1, dict_2, prev_sentence_len):
""" This function appends the 'action_sequence' of dict_2 to dict_1
after updating spans in dict_2 with length of sentence before it"""
dict_2 = fix_spans(dict_2, prev_sentence_len)
for action in dict_2["action_sequence"]:
dict_1["action_sequence"].append(action)
return dict_1
def create_composite_action(action_1, action_2):
"""This function takes in two actions, combines their texts together and
combines their dicts"""
text_1, text_2 = action_1.generate_description(), action_2.generate_description()
dict_1, dict_2 = action_1.to_dict(), action_2.to_dict()
# in case there are compostite schematics in either actions, expand action_sequence
# to accomodate them
dict_1 = fix_composite_in_dict(text_1, dict_1)
dict_2 = fix_composite_in_dict(text_2, dict_2)
# combine the sentences together
prev_text = text_1[0] + random.choice([" and ", " and then "])
composite_text = prev_text + text_2[0]
prev_action_length = len(prev_text.split())
# combine the dicts together
composite_dict = combine_dicts(dict_1, dict_2, prev_action_length)
return [composite_text], composite_dict
def generate_actions(n, action_type=None, template_attributes={}, composite=False):
""" Generate action tree and language based on action type """
texts = []
dicts = []
for _ in range(n):
# pick an action name
action_name = (
random.choice(action_type)
if type(action_type) is list
else action_type_map[action_type]
)
composite_flag = None
# if None, no preference mentioned, pick True at random
if composite is None:
composite_flag = True if random.random() < 0.3 else False
else:
# assign preference (True or False)
composite_flag = composite
# if composite flag is True, generate composite action
if composite_flag and action_name in human_give_command_actions:
template_attributes["dialogue_len"] = 1
# check how to optimize this call
action_1 = Action.generate(action_type=action_name, template_attr=template_attributes)
# pick another from human_give_command_actions
possible_choices = human_give_command_actions
next_action = random.choice(possible_choices)
action_2 = Action.generate(action_type=next_action, template_attr=template_attributes)
action_text, action_dict = create_composite_action(action_1, action_2)
elif composite_flag == False:
template_attributes["no_inbuilt_composites"] = True
action_1 = Action.generate(action_type=action_name, template_attr=template_attributes)
action_text = action_1.generate_description()
action_dict = action_1.to_dict()
action_dict = fix_composite_in_dict(action_text, action_dict)
else:
action_1 = Action.generate(action_type=action_name, template_attr=template_attributes)
action_text = action_1.generate_description()
action_dict = action_1.to_dict()
action_dict = fix_composite_in_dict(action_text, action_dict)
# else generate composite action at random
texts.append(action_text)
dicts.append(action_dict)
return texts, dicts
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-n", type=int, default=100)
parser.add_argument("--seed", "-s", type=int, default=0)
parser.add_argument("--chats_file", "-chats", type=str, default="noop_dataset.txt")
parser.add_argument("--action_type", default=Action.CHOICES)
parser.add_argument(
"--composite_action",
action="store_true",
help="this flag tells the script to create composite actions only",
)
parser.add_argument(
"--no_composite_actions",
action="store_true",
help="this flag tells the script to create no composite actions",
)
parser.add_argument(
"--length_range", nargs="+", default=None, help="Low and High for range of length"
)
parser.add_argument(
"--width_range", nargs="+", default=None, help="Low and High for range of width"
)
parser.add_argument(
"--depth_range", nargs="+", default=None, help="Low and High for range of depth"
)
parser.add_argument(
"--height_range", nargs="+", default=None, help="Low and High for range of height"
)
parser.add_argument(
"--size_range", nargs="+", default=None, help="Low and High for range of size"
)
parser.add_argument(
"--thickness_range", nargs="+", default=None, help="Low and High for range of thickness"
)
parser.add_argument(
"--radius_range", nargs="+", default=None, help="Low and High for range of radius"
)
parser.add_argument(
"--base_range", nargs="+", default=None, help="Low and High for range of base"
)
parser.add_argument(
"--slope_range", nargs="+", default=None, help="Low and High for range of slope"
)
parser.add_argument(
"--distance_range", nargs="+", default=None, help="Low and High for range of distance"
)
parser.add_argument(
"--step_range", nargs="+", default=None, help="Low and High for range of steps"
)
parser.add_argument(
"--coordinates_range",
nargs="+",
default=None,
help="Low and High for range of coordinates",
)
parser.add_argument(
"--count_range",
nargs="+",
default=None,
help="Low and High for range of count / repetitions",
)
parser.add_argument(
"--non_shape_names",
type=str,
default=None,
help="The file containing names of supported schematics (non standard shapes)",
)
parser.add_argument(
"--mob_file", type=str, default=None, help="The file containing names of supported mobs"
)
parser.add_argument(
"--block_types_file",
type=str,
default=None,
help="The file containing supported block objects",
)
args = parser.parse_args()
# load file containing negative examples of chats
try:
f = open(args.chats_file)
chats = [line.strip() for line in f]
f.close()
Noop.CHATS += [
x
for x in chats
if x
not in [
"good job",
"cool",
"that is really cool",
"that is awesome",
"awesome",
"that is amazing",
"that looks good",
"you did well",
"great",
"good",
"nice",
"that is wrong",
"that was wrong",
"that was completely wrong",
"not that",
"that looks horrible",
"that is not what i asked",
"that is not what i told you to do",
"that is not what i asked for",
"not what i told you to do",
"you failed",
"failure",
"fail",
"not what i asked for",
"where are you",
"tell me where you are",
"i do n't see you",
"i ca n't find you",
"are you still around",
"what are you doing",
"now what are you building",
"tell me what are you doing",
"what is your task",
"tell me your task",
"what are you up to",
"stop",
"wait",
"where are you going",
"what is this",
"come here",
"mine",
"what is that thing",
"come back",
"go back",
"what is that",
"keep going",
"tower",
"follow me",
"do n't do that",
"do n't move",
"hold on",
"this is pretty",
"continue",
"can you follow me",
"move",
"this is nice",
"this is sharp",
"this is very big",
"keep digging",
"circle",
"that is sharp",
"it looks nice",
]
]
except:
print("chats file not found")
random.seed(args.seed)
template_attributes = {}
arg_dict = args.__dict__
for key in arg_dict:
if arg_dict[key]:
# Assign numeric ranges
if key in arg_numeric_range_map:
low, high = [int(x) for x in arg_dict[key]]
template_attributes[arg_numeric_range_map[key]] = range(low, high)
# Assign names of schematic and reference objects
elif key in arg_name_file_map:
with open(arg_dict[key]) as f:
template_attributes[arg_name_file_map[key]] = [
line.strip() for line in f.readlines()
]
composite_flag = None
# assign composite_flag if user explcitly mentioned to create / avoid them
# else pick True at random inside generate_actions()
if args.composite_action:
composite_flag = True
if args.no_composite_actions:
composite_flag = False
for text, d in zip(
*generate_actions(
args.n,
args.action_type,
template_attributes=template_attributes,
composite=composite_flag,
)
):
for sentence in text:
print(sentence)
print(json.dumps(d))
print()
| craftassist-master | python/base_agent/ttad/generation_dialogues/generate_dialogue.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains utility functions used for the generation pipeline.
"""
import random
import re
ABERRANT_PLURAL_MAP = {
"appendix": "appendices",
"barracks": "barracks",
"cactus": "cacti",
"child": "children",
"criterion": "criteria",
"deer": "deer",
"echo": "echoes",
"elf": "elves",
"embargo": "embargoes",
"focus": "foci",
"fungus": "fungi",
"goose": "geese",
"hero": "heroes",
"hoof": "hooves",
"index": "indices",
"knife": "knives",
"leaf": "leaves",
"life": "lives",
"man": "men",
"mouse": "mice",
"nucleus": "nuclei",
"person": "people",
"phenomenon": "phenomena",
"potato": "potatoes",
"self": "selves",
"syllabus": "syllabi",
"tomato": "tomatoes",
"torpedo": "torpedoes",
"veto": "vetoes",
"woman": "women",
}
VOWELS = set("aeiou")
# A class for flagging when a value is updated.
class Arguments(dict):
values_updated = False
def __setitem__(self, item, value):
self.values_updated = True
super(Arguments, self).__setitem__(item, value)
def pick_random(prob=0.5):
"""Return True if given prob > random"""
if random.random() < prob:
return True
return False
def prepend_a_an(name):
"""Add a/an to a name"""
if name[0] in ["a", "e", "i", "o", "u"]:
return "an " + name
else:
return "a " + name
def make_plural(word):
"""Make plural of a given lowercase word word.
# Taken from : http://code.activestate.com/recipes/
577781-pluralize-word-convert-singular-word-to-its-plural/
"""
if not word:
return ""
plural = ABERRANT_PLURAL_MAP.get(word)
if plural:
return plural
root = word
try:
if word[-1] == "y" and word[-2] not in VOWELS:
root = word[:-1]
suffix = "ies"
elif word[-1] == "s":
if word[-2] in VOWELS:
if word[-3:] == "ius":
root = word[:-2]
suffix = "i"
else:
root = word[:-1]
suffix = "ses"
else:
suffix = "es"
elif word[-2:] in ("ch", "sh"):
suffix = "es"
elif word[-1] in ("x", "h"):
suffix = "es"
else:
suffix = "s"
except IndexError:
suffix = "s"
plural = root + suffix
return plural
def to_snake_case(word, case="lower"):
"""convert a given word to snake case"""
s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", word)
snake_case = re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1)
if case == "upper":
return snake_case.upper()
return snake_case.lower()
def update_dict_with_span(action_dict, split, arg_types, args):
"""Update the given action_dict with spans for certain keys"""
for arg_type, arg in zip(arg_types, args):
arg_dict = arg.to_dict()
for key, val in arg_dict.items():
if (key.startswith("has_")) or (key == "Coordinates"):
arg_dict[key] = find_span(split, val)
action_dict.update({to_snake_case(arg_type.__name__): arg_dict})
return action_dict
def values_of_nested_dict(d):
"""Return all values of a nested dictionary"""
for v in d.values():
if isinstance(v, dict):
yield from values_of_nested_dict(v)
else:
yield v
def variants(sublist, int_list=False):
"""Find all supported variants of items in the sublist"""
result = []
result.append(sublist)
if int_list:
if len(sublist) == 3:
result.append([sublist[0], ",", sublist[1], ",", sublist[2]])
result.append([sublist[0], "x", sublist[1], "x", sublist[2]])
result.append([sublist[0], "by", sublist[1], "by", sublist[2]])
result.append(["(", sublist[0], sublist[1], sublist[2], ")"])
result.append(["(", sublist[0], ",", sublist[1], ",", sublist[2], ")"])
elif len(sublist) == 2:
result.append([sublist[0], ",", sublist[1]])
result.append([sublist[0], "x", sublist[1]])
result.append([sublist[0], "by", sublist[1]])
result.append(["(", sublist[0], sublist[1], ")"])
result.append(["(", sublist[0], ",", sublist[1], ")"])
return result
def find_sub_list(sublist, full_list, int_list=False):
"""Find start and end indices of sublist in full_list."""
sublist = [str(x) for x in sublist]
sublist_len = len(sublist)
# find all start indices for the first word in the text
indices = []
for i, e in enumerate(full_list):
if e == sublist[0]:
indices.append(i)
for index in indices:
start_idx = index
end_idx = index + sublist_len
if full_list[index - 1] == "(":
start_idx = index - 1
# if ( a , b , c )
if full_list[index + 1] == ",":
end_idx = start_idx + sublist_len + 4
else:
# ( a b c)
end_idx = start_idx + sublist_len + 2
# if text : a , b , c
# or a x b x c
# or a by b by c
elif (index + 1 < len(full_list)) and full_list[index + 1] in [",", "x", "by"]:
if sublist_len == 3:
end_idx = start_idx + sublist_len + 2
elif sublist_len == 2:
end_idx = start_idx + sublist_len + 1
# whole sublist has to fit, except when it is coordinates.
# coordinates can have different formats returned by variants().
if full_list[start_idx:end_idx] in variants(sublist, int_list):
return start_idx, end_idx - 1
return None
def find_span(input_list, val):
"""Find span of val in input_list"""
int_list = True
if type(val) == int:
val = str(val)
if type(val) == str:
if len(val.split()) > 1:
val = val.split()
int_list = False
found_index = 0
for i, sentence_split in enumerate(input_list):
if type(val) in [list, tuple]:
result = find_sub_list(val, sentence_split, int_list)
if result:
found_index = i
start, end = result
elif val in sentence_split:
found_index = i
start = sentence_split.index(val)
end = start
return [len(input_list) - found_index - 1, [start, end]]
def flatten_dict(d):
"""Flatten out a nested dictionary"""
def expand(key, value):
if isinstance(value, dict):
return [(k, v) for k, v in flatten_dict(value).items()]
else:
return [(key, value)]
items = [item for k, v in d.items() for item in expand(k, v)]
return dict(items)
def int_to_words(num):
"""Given an int32 number, print it in words in English.
Taken from: https://stackoverflow.com/a/32640407
"""
d = {
0: "zero",
1: "one",
2: "two",
3: "three",
4: "four",
5: "five",
6: "six",
7: "seven",
8: "eight",
9: "nine",
10: "ten",
11: "eleven",
12: "twelve",
13: "thirteen",
14: "fourteen",
15: "fifteen",
16: "sixteen",
17: "seventeen",
18: "eighteen",
19: "nineteen",
20: "twenty",
30: "thirty",
40: "forty",
50: "fifty",
60: "sixty",
70: "seventy",
80: "eighty",
90: "ninety",
}
k = 1000
m = k * 1000
b = m * 1000
t = b * 1000
assert 0 <= num
if num < 20:
return d[num]
if num < 100:
if num % 10 == 0:
return d[num]
else:
return d[num // 10 * 10] + " " + d[num % 10]
if num < k:
if num % 100 == 0:
return d[num // 100] + " hundred"
else:
return d[num // 100] + " hundred and " + int_to_words(num % 100)
if num < m:
if num % k == 0:
return int_to_words(num // k) + " thousand"
else:
return int_to_words(num // k) + " thousand " + int_to_words(num % k)
if num < b:
if (num % m) == 0:
return int_to_words(num // m) + " million"
else:
return int_to_words(num // m) + " million " + int_to_words(num % m)
if num < t:
if (num % b) == 0:
return int_to_words(num // b) + " billion"
else:
return int_to_words(num // b) + " billion " + int_to_words(num % b)
if num % t == 0:
return int_to_words(num // t) + " trillion"
else:
return int_to_words(num // t) + " trillion " + int_to_words(num % t)
raise AssertionError("Number is too large: %s" % str(num))
| craftassist-master | python/base_agent/ttad/generation_dialogues/generate_utils.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated with Undo command.
"""
import random
from .template_object import *
#####################
### UNDO TEMPLATES ##
#####################
class ActionBuild(TemplateObject):
"""This template object repesents that the target action is Build."""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index=templ_index)
if "Undo" in template_names:
phrases = [
"what you just built",
"what you made",
"the build action",
"the construction",
"what you built",
]
elif "Stop" in template_names:
phrases = ["building", "constructing", "completing"]
elif "Dont" in template_names:
phrases = [
"build anymore",
"build any more copies",
"build anything",
"make anything",
"construct anything",
"copy anything",
]
elif "Resume" in template_names:
phrases = ["building", "copying", "making copies"]
self.words = random.choice(phrases)
self.node.target_action_type = self.words
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self.words
class ActionDestroy(TemplateObject):
"""This template object repesents that the target action is Destroy."""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index=templ_index)
if "Undo" in template_names:
phrases = ["what you destroyed", "the destruction", "the destroy action"]
elif "Stop" in template_names:
phrases = ["destroying", "excavating", "destructing"]
elif "Dont" in template_names:
phrases = ["destroy anything", "destroy", "do the destroy action"]
elif "Resume" in template_names:
phrases = ["destroying", "excavating"]
self.words = random.choice(phrases)
self.node.target_action_type = self.words
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self.words
class ActionFill(TemplateObject):
"""This template object repesents that the target action is Fill."""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index=templ_index)
if "Undo" in template_names:
phrases = [
"what you just filled",
"filling",
"the fill action",
"the filling action",
"filling that",
"filling the hole",
]
elif "Stop" in template_names:
phrases = ["filling", "filling holes"]
elif "Dont" in template_names:
phrases = ["fill", "do the fill action"]
elif "Resume" in template_names:
phrases = ["filling"]
self.words = random.choice(phrases)
self.node.target_action_type = self.words
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self.words
# NOTE(kavya): this should become a delete for undo tag. And How about for resume and stop ?
class ActionTag(TemplateObject):
"""This template object repesents that the target action is Tag."""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index=templ_index)
if "Stop" in template_names:
command = random.choice(["tagging", "the tag action", "labeling"])
elif "Dont" in template_names:
command = random.choice(
["tag", "tag anything", "do any tagging", "do any labeling", "label anything"]
)
elif "Resume" in template_names:
command = random.choice(["tagging", "labeling"])
else:
phrases = [
"undo what you tagged",
"undo the tagging",
"undo the tag",
"undo the tag action",
"reset the tag action",
"forget I tagged that",
"forget that tag",
]
phrase = random.choice(phrases)
prefix = random.choice(["", random.choice(["can you", "please", "can you please"])])
command = (" ".join([prefix, phrase])).strip()
self.words = command
self.node.target_action_type = self.words
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self.words
class ActionDig(TemplateObject):
"""This template object repesents that the target action is Dig."""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index=templ_index)
if "Undo" in template_names:
phrases = ["what you dug", "the digging", "the hole", "the dig action", "digging"]
elif "Stop" in template_names:
phrases = ["digging"]
elif "Dont" in template_names:
phrases = ["dig", "dig anything"]
elif "Resume" in template_names:
phrases = ["digging"]
self.words = random.choice(phrases)
self.node.target_action_type = self.words
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self.words
class ActionMove(TemplateObject):
"""This template object repesents that the target action is Move."""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index=templ_index)
if "Stop" in template_names:
phrases = ["walking", "moving"]
elif "Dont" in template_names:
phrases = ["walk", "move"]
elif "Resume" in template_names:
phrases = ["moving", "walking"]
self.words = random.choice(phrases)
self.node.target_action_type = self.words
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self.words
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/undo_commands.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated with BlockObjects.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
from .location import *
#############################
### BLOCKOBJECT TEMPLATES ###
#############################
# TODO: refactor this function.
def define_block_object_type(
template_obj,
template_obj_name,
index,
reference_type=None,
block_obj_name=PointedObject,
templ_index=0,
):
template = get_template_names(template_obj, templ_index)
previous_template = None
if templ_index - 1 >= 0:
previous_template = get_template_names(template_obj, templ_index - 1)
if (
(
any(
x
in [
"Dig",
"Fill",
"FreebuildLocation",
"Copy",
"Build",
"BuildSingle",
"Stack",
"Place",
"Surround",
]
for x in template
)
or (
previous_template
and any(
x
in [
"Fill",
"FreebuildLocation",
"Copy",
"Build",
"BuildSingle",
"Stack",
"Place",
"Surround",
]
for x in previous_template
)
)
)
and (
(index - 1 >= 0)
and (
template[index - 1]
in ["RelativeDirectionTemplate", "Around", "Surround", "Between"]
)
)
) or (any(x in ["Move", "Stand", "Down"] for x in template)):
if (
"Between" in template
and type(template_obj.node._location_args["location_type"]) is list
):
template_obj.node._location_args["location_type"].append(BlockObject)
template_obj.node._location_args["bo_coref_resolve"].append(reference_type)
else:
template_obj.node._location_args["location_type"] = [BlockObject]
template_obj.node._location_args["bo_coref_resolve"] = [reference_type]
else:
template_obj.node._block_obj_args["block_object_type"] = block_obj_name # at SpeakerLook
if reference_type:
template_obj.node._block_obj_args["coref_type"] = reference_type
# If this is the last template object, no children
# If followed by is/looks like, no child
# If followed by a location, no child
location_template_names = [loc.__name__ for loc in LOCATION_TEMPLATES]
if (
(template[-1] == template_obj_name)
or (
any(
x
in [
"BlockObjectThat",
"BlockObjectCoref",
"BlockObjectThese",
"BlockObjectThose",
"BlockObjectThis",
"BlockObjectIt",
]
for x in template
)
)
or (template[index + 1] in ["NTimes", "ForMe", "TagDesc", "TagName"])
or (
(
index + 1 < len(template)
and (template[index + 1] in ["Is", "Looks", "With"] + location_template_names)
)
)
):
template_obj.node._block_obj_args["no_child"] = True
class BlockObjectCoref(TemplateObject):
"""This template object represents a BlockObject where the Speaker is pointing.
("this")"""
def add_generate_args(self, index=0, templ_index=0):
self._words = random.choice(
[
"what you built",
"what you just built",
"what you built just now",
"what you made",
"what you constructed just now",
]
)
define_block_object_type(
self,
"BlockObject",
index,
reference_type="yes", # self._words,
block_obj_name=None,
templ_index=templ_index,
)
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self._words
class BlockObjectThis(TemplateObject):
"""This template object represents a BlockObject that can be a coreference.
("this")"""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
self._coref_val = "yes" # "this"
if any(x in ["RepeatAll", "RepeatCount"] for x in template_names):
self._coref_val = random.choice(["these", "those"])
define_block_object_type(
self, "BlockObjectThis", index, reference_type=self._coref_val, templ_index=templ_index
)
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self._coref_val
class BlockObjectThese(TemplateObject):
"""This template object represents a BlockObject that can be a coreference
("these")"""
def add_generate_args(self, index=0, templ_index=0):
# "these"
define_block_object_type(
self, "BlockObjectThese", index, reference_type="yes", templ_index=templ_index
)
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "these"
class BlockObjectThat(TemplateObject):
"""This template object represents a BlockObject that can be a coreference
("that")"""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
self._word = "that"
if any(x in ["RepeatCountLocation", "RepeatAllLocation"] for x in template_names):
self._word = random.choice(["these", "those"])
elif index + 1 < len(template_names) and template_names[index + 1] == "RepeatCount":
self._word = random.choice(["these", "those"])
self._coref_val = "yes" # self._word
define_block_object_type(
self, "BlockObjectThat", index, reference_type=self._coref_val, templ_index=templ_index
)
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
template_names = get_template_names(self, templ_index)
if index + 1 < len(template_names):
if template_names[index + 1] == "RepeatAllLocation":
self._word = " ".join([random.choice(["each of", "all of"]), self._word])
elif template_names[index + 1] == "RepeatCountLocation":
if "object_prefix" in description:
count = description["object_prefix"]
elif (
"block_object" in description
and "object_prefix" in description["block_object"]
):
count = description["block_object"]["object_prefix"]
self._word = " ".join([count, "of", self._word])
return self._word
class BlockObjectIt(TemplateObject):
"""This template object represents a BlockObject that can be a coreference.
("it")"""
def add_generate_args(self, index=0, templ_index=0):
# "it"
define_block_object_type(
self, "BlockObjectIt", index, reference_type="yes", templ_index=templ_index
)
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "it"
class BlockObjectThose(TemplateObject):
"""This template object represents a BlockObject that can be a coreference.
("those")"""
def add_generate_args(self, index=0, templ_index=0):
# "those"
define_block_object_type(
self, "BlockObjectThose", index, reference_type="yes", templ_index=templ_index
)
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "those"
class AbstractDescription(TemplateObject):
"""This template object represents abstract description of a block object
like: 'object', 'thing' etc"""
def add_generate_args(self, index=0, templ_index=0):
all_names = get_template_names(self, templ_index)
if templ_index - 1 >= 0:
prev_template_names = get_template_names(self, templ_index - 1)
if ("RepeatCount" in all_names) or ("All" in all_names):
# plural
if self.node._block_obj_args["block_object_attributes"]:
self.node._block_obj_args["block_object_attributes"].append("objects")
else:
self.node._block_obj_args["block_object_attributes"] = ["objects"]
else:
if self.node._block_obj_args["block_object_attributes"]:
self.node._block_obj_args["block_object_attributes"].append("object")
else:
self.node._block_obj_args["block_object_attributes"] = ["object"]
if "HumanReplace" in all_names:
if any(
x
in [
"BlockObjectThis",
"BlockObjectThat",
"BlockObjectIt",
"BlockObjectThose",
"BlockObjectThese",
]
for x in prev_template_names
):
# unset the coref resolve if it was set in previous command
if self.node._block_obj_args["coref_type"]:
self.node._block_obj_args["coref_type"] = None
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
word = description["object"]
prev_template_names = None
if templ_index - 1 >= 0:
prev_template_names = get_template_names(self, templ_index - 1)
if prev_template_names and "RepeatCount" in prev_template_names:
word = make_plural(word)
return word
class ConcreteDescription(TemplateObject):
"""This template object represents concrete description / name of a block object"""
def add_generate_args(self, index=0, templ_index=0):
all_names = get_template_names(self, templ_index)
if templ_index - 1 >= 0:
prev_template_names = get_template_names(self, templ_index - 1)
if ("RepeatCount" in all_names) or ("All" in all_names):
# plural
if self.node._block_obj_args["block_object_attributes"]:
self.node._block_obj_args["block_object_attributes"].append("names")
else:
self.node._block_obj_args["block_object_attributes"] = ["names"]
else:
if self.node._block_obj_args["block_object_attributes"]:
self.node._block_obj_args["block_object_attributes"].append("name")
else:
self.node._block_obj_args["block_object_attributes"] = ["name"]
if "HumanReplace" in all_names:
if any(
x
in [
"BlockObjectThis",
"BlockObjectThat",
"BlockObjectIt",
"BlockObjectThose",
"BlockObjectThese",
]
for x in prev_template_names
):
# unset the coref resolve if it was set in previous command
if self.node._block_obj_args["coref_type"]:
self.node._block_obj_args["coref_type"] = None
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
word = description["name"]
node_template = get_template_names(self, templ_index)
if node_template[index - 1] == "Copy":
word = random.choice([word, prepend_a_an(word)])
if "AskIs" in node_template and index == len(node_template) - 1:
word = prepend_a_an(word)
return word
class Colour(TemplateObject):
"""This template object ensures that the blockobject has a colour and is used
to separate out the attributes, one at a time."""
def add_generate_args(self, index=0, templ_index=0):
all_names = get_template_names(self, templ_index)
if templ_index - 1 >= 0:
prev_template_names = get_template_names(self, templ_index - 1)
if "HumanReplace" in all_names:
if any(
x
in [
"BlockObjectThis",
"BlockObjectThat",
"BlockObjectIt",
"BlockObjectThose",
"BlockObjectThese",
]
for x in prev_template_names
):
# unset the coref resolve if it was set in previous command
if self.node._block_obj_args["coref_type"]:
self.node._block_obj_args["coref_type"] = None
self.node._block_obj_args["block_object_type"] = Object
if self.node._block_obj_args["block_object_attributes"]:
self.node._block_obj_args["block_object_attributes"].append("colour")
else:
self.node._block_obj_args["block_object_attributes"] = ["colour"]
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
word = description["colour"]
return word
class Size(TemplateObject):
"""This template object ensures that the blockobject has a size and is used
to separate out the attributes, one at a time."""
def add_generate_args(self, index=0, templ_index=0):
all_names = get_template_names(self, templ_index)
if templ_index - 1 >= 0:
prev_template_names = get_template_names(self, templ_index - 1)
if "HumanReplace" in all_names:
if any(
x
in [
"BlockObjectThis",
"BlockObjectThat",
"BlockObjectIt",
"BlockObjectThose",
"BlockObjectThese",
]
for x in prev_template_names
):
# unset the coref resolve if it was set in previous command
if self.node._block_obj_args["coref_type"]:
self.node._block_obj_args["coref_type"] = None
self.node._block_obj_args["block_object_type"] = Object
if self.node._block_obj_args["block_object_attributes"]:
self.node._block_obj_args["block_object_attributes"].append("size")
else:
self.node._block_obj_args["block_object_attributes"] = ["size"]
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
word = description["size"]
return word
class BlockObjectLocation(TemplateObject):
"""This template object ensures that the blockobject has a location."""
def add_generate_args(self, index=0, templ_index=0):
curr_template_names = get_template_names(self, templ_index)
if templ_index - 1 >= 0:
prev_template_names = get_template_names(self, templ_index - 1)
# For Answer action, make child None and location specific
if curr_template_names[1] in ["What", "WhatSee", "AskIs", "AskSize"]:
self.node._block_obj_args["block_object_location"] = random.choice([BlockObject, Mob])
self.node._block_obj_args["no_child"] = True
elif "HumanReplace" in curr_template_names:
if any(
x
in [
"What",
"AskSize",
"AskColour",
"AskIs",
"Copy",
"Destroy",
"TagDesc",
"TagName",
]
for x in prev_template_names
):
self.node._block_obj_args["block_object_location"] = random.choice(
[BlockObject, Mob]
)
self.node._block_obj_args["no_child"] = True
# if BO type was set to Pointed Object, reset it
if any(
x
in [
"BlockObjectThis",
"BlockObjectThat",
"BlockObjectIt",
"BlockObjectThose",
"BlockObjectThese",
]
for x in prev_template_names
):
# unset the coref resolve if it was set in previous command
if self.node._block_obj_args["coref_type"]:
self.node._block_obj_args["coref_type"] = None
self.node._block_obj_args["block_object_type"] = Object
else:
# pick any random location
self.node._block_obj_args["block_object_location"] = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
word = description["location"]
return word
BLOCKOBJECT_TEMPLATES = [
BlockObjectIt,
AbstractDescription,
ConcreteDescription,
Colour,
Size,
BlockObjectLocation,
BlockObjectThat,
BlockObjectThis,
BlockObjectThese,
BlockObjectCoref,
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/block_object.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated with the Mob tree component.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
#####################
### MOB TEMPLATES ###
#####################
def set_mob_location(template_obj, location):
template_obj.node._mob_args["mob_location"] = location
# Note: this is for "this pig", no coref resolution needed
class MobThis(TemplateObject):
"""This template object represents 'this' mob"""
def add_generate_args(self, index=0, templ_index=0):
set_mob_location(self, SpeakerLook)
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "this"
# Note: this is for "that pig", no coref resolution needed
class MobThat(TemplateObject):
"""This template object represents 'that' mob"""
def add_generate_args(self, index=0, templ_index=0):
set_mob_location(self, SpeakerLook)
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "that"
class MobLocation(TemplateObject):
"""This template object ensures that Mob has a location"""
def add_generate_args(self, index=0, templ_index=0):
set_mob_location(self, "ANY")
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
word = description["location"]
return word
class MobName(TemplateObject):
"""This template object sets the argument type to be a Mob"""
def add_generate_args(self, index=0, templ_index=0):
self.node._arg_type = Mob
def generate_description(self, arg_index=0, index=0, templ_index=0):
template_name = get_template_names(self, templ_index)
description = self.node.args[arg_index].generate_description()
if any(x in ["RepeatAll", "RepeatCount"] for x in template_name) and (
"mob_prefix" in description
):
return " ".join([description["mob_prefix"], description["mob"]])
elif "Spawn" in template_name:
mob_name = description["mob"]
# append a/an randomly: "Spawn pig" / "Spawn a pig"
return random.choice([mob_name, prepend_a_an(mob_name)])
return description["mob"]
MOB_TEMPLATES = [MobThis, MobThat, MobLocation, MobName]
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/mob.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated specifically with the
Answer action.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
########################
### ANSWER TEMPLATES ###
########################
class What(TemplateObject):
'''This template object represents questions of type "what .."'''
def add_generate_args(self, index=0, templ_index=0):
self.node.answer_type = "TAG"
self.node.tag_name = "has_name"
self.node._filters_args["mem_type"] = "REFERENCE_OBJECT"
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["what", "what do you think"])
return phrase
class WhatSee(TemplateObject):
'''This template object represents questions of type: "what do you see at.."'''
def add_generate_args(self, index=0, templ_index=0):
self.node.answer_type = "TAG"
self.node.tag_name = "has_name"
self.node._filters_args["mem_type"] = "REFERENCE_OBJECT"
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["what do you see", "what do you observe"])
return phrase
class AskSize(TemplateObject):
'''This template object repesents questions of type: "what size is.."'''
def add_generate_args(self, index=0, templ_index=0):
self.node.answer_type = "TAG"
self.node.tag_name = "has_size"
self.node._filters_args["mem_type"] = "REFERENCE_OBJECT"
def generate_description(self, arg_index=0, index=0, templ_index=0):
size_options = random.choice(
["what size is", "what size do you think is", "what is the size of"]
)
phrase = random.choice([size_options])
return phrase
class AskColour(TemplateObject):
'''This template object repesents questions of type: "what colour is.."'''
def add_generate_args(self, index=0, templ_index=0):
self.node.answer_type = "TAG"
self.node.tag_name = "has_colour"
self.node._filters_args["mem_type"] = "REFERENCE_OBJECT"
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(
[
"what colour is",
"what colour do you think is",
"what is the colour of",
"what color is",
"what color do you think is",
"what is the color of",
]
)
return phrase
class AskIs(TemplateObject):
'''This template object repesents questions of type: "is .."'''
def add_generate_args(self, index=0, templ_index=0):
self.node.answer_type = "EXISTS"
self.node._filters_args["mem_type"] = "REFERENCE_OBJECT"
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["is"])
return phrase
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/answer.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated with repeats and stop
conditions.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
################################
### STOP CONDITION TEMPLATES ###
################################
"""Assign the repeat_val to the tree"""
def assign_repeat_key(template_obj, repeat_val, templ_index=0):
template_names = get_template_names(template_obj, templ_index)
if any(x in ["Build", "BuildSingle", "Stack", "Place"] for x in template_names):
template_obj.node._location_args["repeat_key"] = repeat_val
elif any(x in ["Dig", "Fill"] for x in template_names):
template_obj.node._location_args["repeat_key"] = repeat_val
elif any(x in ["Destroy", "Freebuild"] for x in template_names):
template_obj.node._block_obj_args["block_object_location"] = random.choice(
[BlockObject, Mob]
)
template_obj.node._block_obj_args["repeat_location"] = repeat_val
elif "Tag" in template_names:
if "MobName" in template_names:
template_obj.node._mob_args["mob_location"] = random.choice([BlockObject, Mob])
template_obj.node._mob_args["repeat_location"] = repeat_val
else:
template_obj.node._block_obj_args["block_object_location"] = random.choice(
[BlockObject, Mob]
)
template_obj.node._block_obj_args["repeat_location"] = repeat_val
class RepeatAllLocation(TemplateObject):
"""This template object repesents all / every / each for blockobject / mob used
as a reference for location.
eg: explode the disk on top of all the creepers"""
def add_generate_args(self, index=0, templ_index=0):
assign_repeat_key(self, "ALL", templ_index=templ_index)
class RepeatCountLocation(TemplateObject):
"""This template object repesents a count for blockobject / mob used
as a reference for location.
eg: Make a hole below 5 houses"""
def add_generate_args(self, index=0, templ_index=0):
assign_repeat_key(self, "FOR", templ_index=templ_index)
class RepeatCount(TemplateObject):
"""This template object repesents a count for blockobject / mob / schematic
eg: Make 5 holes there"""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
if any(x in ["Build", "Stack", "Place"] for x in template_names):
self.node._schematics_args["repeat_key"] = "FOR"
elif any(x in ["Dig", "Fill"] for x in template_names):
count = random.choice(self.template_attr.get("count", range(2, 15)))
self.node._repeat_args["repeat_key"] = "FOR"
self.node._repeat_args["repeat_count"] = random.choice(
[str(count), int_to_words(count), "a few", "some"]
)
elif any(x in ["Destroy", "Freebuild"] for x in template_names):
self.node._block_obj_args["repeat_key"] = "FOR"
elif "Copy" in template_names:
self.node._block_obj_args["repeat_key"] = "FOR"
self.node._block_obj_args["no_child"] = True
elif "Tag" in template_names:
if "MobName" in template_names:
self.node._mob_args["repeat_key"] = "FOR"
else:
self.node._block_obj_args["repeat_key"] = "FOR"
self.node._block_obj_args["no_child"] = True
elif "Spawn" in template_names:
self.node._mob_args["repeat_key"] = "FOR"
def generate_description(self, arg_index=0, index=0, templ_index=0):
if len(self.node.args) > 0:
description = self.node.args[arg_index].generate_description()
if "object_prefix" in description:
return description["object_prefix"]
template_names = get_template_names(self, templ_index)
if ("Dig" in template_names) or ("Fill" in template_names):
return self.node._repeat_args["repeat_count"]
return None
class Around(TemplateObject):
"""This TemplateObject populates the repeat_dir as "Around" """
def add_generate_args(self, index=0, templ_index=0):
self.node._schematics_args["repeat_dir"] = "AROUND"
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "around"
class Surround(TemplateObject):
"""This TemplateObject populates the repeat_dir as "SURROUND" """
def add_generate_args(self, index=0, templ_index=0):
self.node._schematics_args["repeat_key"] = "ALL"
self.node._schematics_args["repeat_dir"] = "SURROUND"
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "surround"
class RepeatAll(TemplateObject):
"""This template object repesents "All" for blockobject / mob / schematic
eg: Tag every house as brown"""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
template_len = len(template_names) - 1
# only for destroy everything.
if (template_len == 2) and ("DestroySingle" in template_names):
self.node._block_obj_args["repeat_no_child"] = True
if "Build" in template_names:
self.node._schematics_args["repeat_key"] = "ALL"
elif any(x in ["Destroy", "Freebuild", "DestroySingle"] for x in template_names):
self.node._block_obj_args["repeat_key"] = "ALL"
elif "Copy" in template_names:
self.node._block_obj_args["repeat_key"] = "ALL"
self.node._block_obj_args["no_child"] = True
elif "Fill" in template_names:
self.node._repeat_args["repeat_key"] = "ALL"
elif "Tag" in template_names:
if "MobName" in template_names:
self.node._mob_args["repeat_key"] = "ALL"
else:
self.node._block_obj_args["repeat_key"] = "ALL"
self.node._block_obj_args["no_child"] = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
if ("Copy" in template_names) and (len(self.node.args) > 0):
description = self.node.args[arg_index].generate_description()
if "object_prefix" in description:
return description["object_prefix"]
if "Fill" in template_names:
return random.choice(["all", "all the"])
return None
class ConditionTypeNever(TemplateObject):
"""This template object repesents the condition type "Never" for the Stop Condition
i.e. infinite loops.
eg: Follow me"""
def add_generate_args(self, index=0, templ_index=0):
self.node._condition_args["condition_type"] = "NEVER"
class ConditionTypeAdjacentBlockType(TemplateObject):
"""This template object repesents the condition type "adjacent to block type"
for Stop Condition i.e. stop when you are adjacent to a certain block type.
eg: Dig until you hit bedrock"""
def add_generate_args(self, index=0, templ_index=0):
self.node._condition_args["condition_type"] = "ADJACENT_TO_BLOCK_TYPE"
self.node._condition_args["block_type"] = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
block_type = description["block_type"]
template_names = get_template_names(self, templ_index)
prefixes = ["until you see", "until you reach", "until you find", "down to", "for"]
if "DownTo" in template_names:
prefixes = [""]
elif template_names[1] == "Dig": # some Move templates also have this
prefixes.append("until you hit")
prefix = random.choice(prefixes)
phrase = " ".join([prefix, block_type]).strip()
return phrase
CONDIITON_TEMPLATES = [ConditionTypeNever, ConditionTypeAdjacentBlockType]
REPEAT_KEY_TEMPLATES = [RepeatCount, RepeatAll]
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/repeat_and_condition.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated with Fill action.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
from .dig import *
#####################
## FILL TEMPLATES ###
#####################
class FillShape(TemplateObject):
"""This template object repesents the shape/ thing that needs to be filled."""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
phrase = random.choice(dig_shapes)
if any(x in ["RepeatCount", "RepeatAll"] for x in template_names):
phrase = make_plural(random.choice(dig_shapes))
self.node.reference_object["has_name"] = phrase
self._phrase = phrase
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self._phrase
# Note: this is for "fill that mine" , no coref resolution needed
class FillObjectThis(TemplateObject):
"""This template object repesents that the thing to be filled is where the speaker
is looking."""
def add_generate_args(self, index=0, templ_index=0):
self.node.reference_object["contains_coreference"] = "yes"
phrases = ["this", "that"]
template_names = get_template_names(self, templ_index)
if any(x in ["RepeatCount", "RepeatAll"] for x in template_names):
phrases = ["these", "those"]
self._word = random.choice(phrases)
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self._word
class FillBlockType(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node.has_block_type = random.choice(
self.template_attr.get("block_types", BLOCK_TYPES)
)
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self.node.has_block_type
class UseFill(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["use", "fill using", "fill with"])
return phrase
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/fill.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains common template objects used across different templates.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
#######################
## DANCE TEMPLATES ##
#######################
"""
Fly
Jump
Hop
Dance
Dance clockwise (#4 with repeat_dir)
Dance in a loop
"""
class Fly(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
all_names = get_template_names(self, templ_index)
command = ["fly", "fly"]
if index + 1 < len(all_names) and all_names[index + 1] == "ConditionTypeNever":
command = random.choice(
[["flying", "keep flying"], ["fly", "fly until I tell you to stop"]]
)
self.node.dance_type_name = command[0]
self.node._dance_text = command[1]
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = self.node._dance_text
prefix = random.choice(["", random.choice(["", "can you", "please", "can you please"])])
new_command = (" ".join([prefix, command])).strip()
return new_command
class Jump(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
all_names = get_template_names(self, templ_index)
command = ["jump", "jump"]
if index + 1 < len(all_names) and all_names[index + 1] == "ConditionTypeNever":
command = random.choice(
[["jumping", "keep jumping"], ["jump", "jump until I tell you to stop"]]
)
self._dance_text = command[1]
self.node.dance_type_name = command[0]
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = self._dance_text
prefix = random.choice(["", random.choice(["", "can you", "please", "can you please"])])
new_command = " ".join([prefix, command]).strip()
return new_command
class Walk(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node.dance_pattern = "MOVE_AROUND"
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(["move", "walk", "go"])
prefix = random.choice(["", random.choice(["", "can you", "please", "can you please"])])
new_command = (" ".join([prefix, command])).strip()
return new_command
class Hop(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
all_names = get_template_names(self, templ_index)
command = ["hop", "hop"]
if index + 1 < len(all_names) and all_names[index + 1] == "ConditionTypeNever":
command = random.choice(
[["hopping", "keep hopping"], ["hop", "hop until I tell you to stop"]]
)
self.node.dance_type_name = command[0]
self.node._dance_text = command[1]
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = self.node._dance_text
prefix = random.choice(["", random.choice(["", "can you", "please", "can you please"])])
new_command = (" ".join([prefix, command])).strip()
return new_command
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/dance.py |
# fmt: off
from .action_names import *
from .answer import *
from .block_object import *
from .common import *
from .dig import *
from .fill import *
from .location import *
from .mob import *
from .schematics import *
from .special_shape_commands import *
from .repeat_and_condition import *
from .string_output import *
from .tag import *
from .template_object import *
from .undo_commands import *
from .dialogue_generic import *
from .dialogue_human_bot import *
from .dance import *
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/__init__.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains generic template objects associated with Dilogue.
"""
from generate_utils import *
from tree_components import *
from .template_object import *
class Human(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return None # "human:"
class HumanReplace(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._replace = True
if self.node._no_children:
self.node._no_children = False
def generate_description(self, arg_index=0, index=0, templ_index=0):
return None # "human:"
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/dialogue_generic.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects that generate only strings.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
################################
### GENERIC TEXT TEMPLATES ###
################################
"""The template objects under this section contribute only to the text /
description and do not alter the arguments of the parent node"""
class MadeOutOf(TemplateObject):
def generate_description(self, arg_index, index, templ_index=0):
if index == 0:
return "out of"
phrase = random.choice(["out of", "from", "using", "of", "with"])
return phrase
class OnGround(TemplateObject):
def generate_description(self, arg_index, index=0, templ_index=0):
return "on the ground"
class All(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["all", "all the"])
return phrase
class Every(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["every", "each"])
return phrase
class The(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "the"
class To(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "to"
class LocationWord(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
word = random.choice(["loc", "location", "loc:", "location:"])
return word
class Where(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "where"
class Is(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
if index + 1 < len(template_names):
if template_names[index + 1] == "TagName":
return random.choice(["is", "looks like"])
elif template_names[index + 1] == "TagDesc":
return random.choice(["is", "looks"])
return "is"
class SurroundWith(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return random.choice(["with", "using"])
class With(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(["with", "as"])
return command
class Blocks(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["blocks", "block"])
return phrase
class Squares(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["blocks", "squares", "block", "square", "tiles", "tile"])
return phrase
class Wide(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = "wide"
return phrase
class Long(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = "long"
return phrase
class High(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = "high"
return phrase
class Deep(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = "deep"
return phrase
class InARow(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["in a row", "next to each other"])
return phrase
class And(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = "and"
return phrase
class Under(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "under"
class Times(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "times"
class Everything(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "everything"
class DownTo(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "down to"
class Find(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["find me", "find"])
return phrase
class Up(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "up"
class ForMe(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["for me", ""])
return phrase
class OfDimensionsPhrase(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
all_names = get_template_names(self, templ_index)
phrases = ["of size", "of dimension", "of dimensions"]
if "RepeatCount" in all_names:
phrases.append("that are")
else:
phrases.append("that is")
return random.choice(phrases)
class Please(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["please", ""])
return phrase
class One(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
previous_template = get_template_names(self, templ_index - 1)
phrase_list = ["one"]
if any(x in ["RepeatCount", "RepeatAll"] for x in previous_template):
phrase_list = ["ones"]
phrase = random.choice(phrase_list)
return phrase
class Thing(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["thing", "structure"])
return phrase
class Using(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["using", "with"])
return phrase
class Dont(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "do n't"
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/string_output.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated with the Location tree component.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
##########################
### LOCATION TEMPLATES ###
##########################
class MoveHere(TemplateObject):
"""This template object repesents the intent to move "here" and sets the location."""
def add_generate_args(self, index=0, templ_index=0):
self.node._location_args["location_type"] = SpeakerPos
def generate_description(self, arg_index=0, index=0, templ_index=0):
node_template = get_template_names(self, templ_index)
if node_template[-1] == "MoveHere":
phrase = random.choice(
[
"come back to me",
"move back to me",
"come to me",
"walk to me",
"come to where I am",
"move back to where I am",
"move to where I am",
"come back to where I am",
]
)
# For infinite loop
elif node_template[-1] == "ConditionTypeNever":
phrase = random.choice(
[
"follow me",
"keep following me",
"follow me around",
"keep walking with me",
"can you follow me",
"please follow me",
"can you please follow me",
]
)
return phrase
class MoveHereCoref(TemplateObject):
"""This template object repesents location to be where the speaker is looking."""
def add_generate_args(self, index=0, templ_index=0):
self._word = random.choice(
[
"come here",
"get over here",
"come back here",
"come back over here",
"get over here",
"move back here",
"walk back here",
]
)
self.node._location_args["location_type"] = None
self.node._location_args["coref_resolve"] = "yes" # self._word.split()[-1]
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self._word
class Stand(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._location_args["relative_direction"] = True
self.node._location_args["relative_direction_value"] = "UP"
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["stand on", "go on top of", "go stand on top of"])
template = get_template_names(self, templ_index)
if template[-1] not in ["BlockObjectThis", "BlockObjectThat", "ThereTemplateCoref"]:
phrase = " ".join([phrase, random.choice(["", "the"])]).strip()
return phrase
class Down(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._location_args["relative_direction"] = True
self.node._location_args["relative_direction_value"] = "DOWN"
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["get down from", "come down from"])
template = get_template_names(self, templ_index)
if template[-1] not in ["BlockObjectThis", "BlockObjectThat", "ThereTemplateCoref"]:
phrase = " ".join([phrase, random.choice(["", "the"])]).strip()
return phrase
class LocationBlockObjectTemplate(TemplateObject):
"""This template object sets the location to be a reference to a blockobject"""
def add_generate_args(self, index=0, templ_index=0):
if (
type(self.node._location_args["location_type"]) is list
and self.node._location_args["location_type"][0] != BlockObject
):
self.node._location_args["location_type"].append(BlockObject)
else:
self.node._location_args["location_type"] = [BlockObject]
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
return description["block_object"]
class AroundString(TemplateObject):
"""This template object is used for the dance action and sets the direction
of dance: CLOCKWISE / ANTICLOCKWISE"""
def add_generate_args(self, index=0, templ_index=0):
self.node._location_args["relative_direction"] = True
self.node._location_args["relative_direction_value"] = random.choice(
["CLOCKWISE", "ANTICLOCKWISE"]
)
def generate_description(self, arg_index=0, index=0, templ_index=0):
template = get_template_names(self, templ_index)
if "HumanReplace" in template:
return self.node._location_args["relative_direction_value"].lower()
phrase = random.choice(["around"])
return phrase
class Between(TemplateObject):
'''This template object represents relative direction "Between"'''
def add_generate_args(self, index=0, templ_index=0):
self.node._location_args["relative_direction"] = True
self.node._location_args["relative_direction_value"] = "BETWEEN"
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
return description["relative_direction"]
class RelativeDirectionTemplate(TemplateObject):
"""This template object repesents that the location is relative to something."""
def add_generate_args(self, index=0, templ_index=0):
template = get_template_names(self, templ_index)
self.node._location_args["relative_direction"] = True
if index + 1 < len(template):
self.node._location_args["additional_direction"] = []
if template[index + 1] == "LocationBlockObjectTemplate":
self.node._location_args["additional_direction"].extend(
["INSIDE", "OUTSIDE", "BETWEEN"]
)
if template[index + 1] in ["LocationBlockObjectTemplate", "LocationMobTemplate"]:
self.node._location_args["additional_direction"].append("NEAR")
if "BETWEEN" not in self.node._location_args["additional_direction"]:
self.node._location_args["additional_direction"].append("BETWEEN")
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
return description["relative_direction"]
class ClimbDirectionTemplate(TemplateObject):
"""This template object repesents that the location is on top of something."""
def add_generate_args(self, index=0, templ_index=0):
self.node._location_args["relative_direction"] = True
self.node._location_args["relative_direction_value"] = "UP"
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
return description["relative_direction"]
class CoordinatesTemplate(TemplateObject):
"""This template object repesents that the location is absolute coordinates."""
def add_generate_args(self, index=0, templ_index=0):
self.node._location_args["location_type"] = Coordinates
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
coordinates_list = " ".join((description["coordinates"].split())[2:])
return coordinates_list
class LocationMobTemplate(TemplateObject):
"""This template object repesents that location is a reference to a Mob."""
def add_generate_args(self, index=0, templ_index=0):
node_template = get_template_names(self, templ_index)
# handle "that pig"
if index >= 1 and node_template[index - 1] == "ThisTemplate":
if type(self.node._location_args["location_type"]) is list:
self.node._location_args["location_type"].append("SpeakerLookMob")
else:
self.node._location_args["location_type"] = ["SpeakerLookMob"]
else:
if type(self.node._location_args["location_type"]) is list and (
self.node._location_args["location_type"][0] != Mob
):
self.node._location_args["location_type"].append(Mob)
else:
self.node._location_args["location_type"] = [Mob]
def generate_description(self, arg_index=0, index=0, templ_index=0):
node_template = get_template_names(self, templ_index)
description = self.node.args[arg_index].generate_description()
mob_desc = description["mob"]
# drop "the" from "follow that the pig"
if ("mob_prefix" in mob_desc and index >= 1) and (
(node_template[index - 1] == "ThisTemplate") or ("BlockObjectThat" in node_template)
):
mob_desc = mob_desc.pop("mob_prefix")
return description["mob"]
class HereTemplate(TemplateObject):
"""This template object repesents location as where the speaker is."""
def add_generate_args(self, index=0, templ_index=0):
self.node._location_args["location_type"] = SpeakerPos
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["where I am", "where I am standing"])
return phrase
class HereTemplateCoref(TemplateObject):
"""This template object repesents location to be where the speaker is looking."""
def add_generate_args(self, index=0, templ_index=0):
self._word = random.choice(["here", "over here"])
self.node._location_args["location_type"] = None
self.node._location_args["coref_resolve"] = "yes" # self._word.split()[-1]
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self._word
class ThereTemplate(TemplateObject):
"""This template object repesents location to be where the speaker is looking."""
def add_generate_args(self, index=0, templ_index=0):
self._word = random.choice(["where I am looking"])
self.node._location_args["location_type"] = SpeakerLook
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self._word
class ThereTemplateCoref(TemplateObject):
"""This template object repesents location to be where the speaker is looking."""
def add_generate_args(self, index=0, templ_index=0):
self._word = random.choice(["there", "over there"])
self.node._location_args["location_type"] = None
self.node._location_args["coref_resolve"] = "yes" # self._word.split()[-1]
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self._word
class YouTemplate(TemplateObject):
"""This template object repesents location to be where the agent is."""
def add_generate_args(self, index=0, templ_index=0):
self.node._location_args["location_type"] = AgentPos
def generate_description(self, arg_index=0, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
if "Dig" in template_names and "Under" in template_names:
return "you"
return random.choice(["where you are", "where you are standing"])
# NOTE: this is used for SpeakerLookMob type location, doesn't need coref resolution
class ThisTemplate(TemplateObject):
"""This template object repesents location to be where the agent is."""
def add_generate_args(self, index=0, templ_index=0):
self.node._location_args["location_type"] = SpeakerLook
def generate_description(self, arg_index=0, index=0, templ_index=0):
return random.choice(["this", "that"])
class StepsTemplate(TemplateObject):
"""This template object repesents that the location involves taking few "steps"."""
def add_generate_args(self, index=0, templ_index=0):
self.node._location_args["steps"] = True
template_name = get_template_names(self, templ_index)
if (index + 1 < len(template_name)) and (
template_name[index + 1] in ["ConditionCount", "NTimes"]
):
self.node._location_args["location_type"] = False
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
return description["steps"]
# The following templates generate only text in the context of
# Location templates.
class At(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
return "at"
class ALittle(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["a little", "a bit"])
return phrase
LOCATION_TEMPLATES = [
LocationBlockObjectTemplate,
RelativeDirectionTemplate,
CoordinatesTemplate,
LocationMobTemplate,
HereTemplate,
ThereTemplate,
ThereTemplateCoref,
YouTemplate,
ThisTemplate,
StepsTemplate,
At,
ALittle,
Between,
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/location.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated with Dig action.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
#####################
### DIG TEMPLATES ###
#####################
dig_shapes = ["hole", "cave", "mine", "tunnel"]
"""This template object picks the shape of what will be dug"""
class DigSomeShape(TemplateObject):
def __init__(self, node, template_attr):
shape_type = DigShapeAny if pick_random(0.8) else DigShapeHole
self._child = shape_type(node=node, template_attr=template_attr)
def add_generate_args(self, index=0, templ_index=0):
self._child.add_generate_args(index=index, templ_index=templ_index)
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self._child.generate_description(arg_index=arg_index, index=index)
"""This template object represents specific shapes. Meant to generate direct
commands like : make a hole , dig a mine"""
class DigShapeHole(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self._phrase = None
this_phrase = None
template_name = get_template_names(self, templ_index)
plural = False
phrase = random.choice(dig_shapes)
this_phrase = phrase
if "RepeatCount" in template_name:
phrase = make_plural(random.choice(dig_shapes))
this_phrase = phrase
plural = True
if not plural and (template_name[index - 1] not in ["DigDimensions", "DigAbstractSize"]):
this_phrase = phrase
phrase = random.choice([phrase, prepend_a_an(phrase)])
self.node.schematic["has_name"] = this_phrase
self._phrase = phrase
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self._phrase
"""This template object covers a variety of dig shape types and is more general
than DigShapeHole. It can also lead to generations like: 'dig down until you hit bedrock'
"""
class DigShapeAny(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self._phrase = None
template_name = get_template_names(self, templ_index=0)
this_phrase = None
if "RepeatCount" in template_name:
phrase = make_plural(random.choice(dig_shapes))
this_phrase = phrase
elif "DownTo" in template_name:
if pick_random():
this_phrase = random.choice(dig_shapes + ["grass"])
phrase = this_phrase
else:
this_phrase = random.choice(dig_shapes)
phrase = "a " + this_phrase
elif template_name[index - 1] in ["DigDimensions", "DigAbstractSize"]:
phrase = random.choice(dig_shapes)
this_phrase = phrase
elif index + 1 < len(template_name) and template_name[index + 1] == "NumBlocks":
if pick_random():
this_phrase = random.choice(dig_shapes + ["under ground", "grass"])
phrase = this_phrase
else:
this_phrase = random.choice(dig_shapes)
phrase = "a " + this_phrase
else:
if pick_random():
this_phrase = random.choice(
dig_shapes
+ ["ground", "into ground", "under ground", "under grass", "grass", "down"]
)
phrase = this_phrase
else:
this_phrase = random.choice(dig_shapes)
phrase = "a " + this_phrase
self.node.schematic["has_name"] = this_phrase
self._phrase = phrase
def generate_description(self, arg_index=0, index=0, previous_text=None, templ_index=0):
return self._phrase
"""This template object assigns the dimensions: length, width and depth for
what needs to be dug."""
class DigDimensions(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node.schematic["has_length"] = random.choice(
self.template_attr.get("length", range(2, 15))
)
width_val = None
if pick_random():
width_val = random.choice(self.template_attr.get("width", range(15, 30)))
if width_val:
self.node.schematic["has_width"] = width_val
depth_val = None
if pick_random():
depth_val = random.choice(self.template_attr.get("width", range(30, 45)))
if depth_val:
self.node.schematic["has_depth"] = depth_val
def generate_description(self, arg_index=0, index=0, templ_index=0):
template_name = get_template_names(self, templ_index)
sizes = [self.node.schematic["has_length"]]
if "has_width" in self.node.schematic:
sizes.append(self.node.schematic["has_width"])
if "has_depth" in self.node.schematic:
sizes.append(self.node.schematic["has_depth"])
out_size = random.choice([" x ".join(map(str, sizes)), " by ".join(map(str, sizes))])
if ("RepeatCount" in template_name) or ("OfDimensions" in template_name):
return out_size
return "a " + out_size
"""This template object assigns an abstract size for the shape that needs
to be dug."""
class DigAbstractSize(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self._size_description = random.choice(
ABSTRACT_SIZE + ["deep", "very deep", "really deep"]
)
self.node.schematic["has_size"] = self._size_description
def generate_description(self, arg_index=0, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
if "RepeatCount" in template_names:
return self._size_description
phrase = random.choice([self._size_description, prepend_a_an(self._size_description)])
return phrase
DIG_SHAPE_TEMPLATES = [DigSomeShape, DigShapeHole, DigShapeAny, DigDimensions, DigAbstractSize]
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/dig.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated directly with Action names.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
class Dance(TemplateObject):
"""This template object repesents a single word 'Dance' command.
eg: dance / dance around"""
def add_generate_args(self, index=0, templ_index=0):
template = get_template_names(self, templ_index)
template_len = len(template) - 1
if template_len == 1:
self.node._no_children = True
single_commands = [
["dance", "dance"],
["dance", "do a dance"],
["dance", "show me a dance"],
]
all_names = get_template_names(self, templ_index)
template_len = len(all_names) - 1
if template_len == 2 and (all_names[-1] == "ConditionTypeNever"):
single_commands = [
["dancing", "keep dancing"],
["dance", "dance forever"],
["dance", "dance until I tell you to stop"],
]
command = random.choice(single_commands)
self.node.dance_type_name = command[0]
self.node._dance_text = command[1]
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = self.node._dance_text
prefix = random.choice(["", random.choice(["can you", "please", "can you please"])])
new_command = (" ".join([prefix, command])).strip()
return new_command
class Move(TemplateObject):
"""This template object repesents the 'Move' command"""
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(["move", "go", "come", "walk"])
all_names = get_template_names(self, templ_index)
# If next argument is "Next", 'go next to X'
if all_names[1] == "Next" or ("Between" in all_names):
command = "go"
# for follow ups on a previous move command
if "HumanReplace" in all_names:
return None
# Infinite loop
if "ConditionTypeNever" in all_names and any(
x in ["LocationMobTemplate", "BlockObjectIt", "BlockObjectThat"] for x in all_names
):
command = random.choice(["follow", "catch", "keep following"])
elif "ClimbDirectionTemplate" in all_names:
command = random.choice(["climb"])
else:
# for away, use 'move'
description = self.node.args[0].generate_description()
if "relative_direction" in description:
if all_names[-1] != "ConditionTypeAdjacentBlockType":
if "away" in description["relative_direction"]:
command = "move"
else:
command = random.choice(["keep moving", "keep walking", "walk"])
elif "StepsTemplate" in all_names: # move X steps
command = random.choice(["move", "walk"])
prefix = random.choice(["", random.choice(["", "can you", "please", "can you please"])])
new_command = (" ".join([prefix, command])).strip()
return new_command
class MoveSingle(TemplateObject):
"""This template object repesents a single word 'Move' command.
eg: move / move somewhere"""
def add_generate_args(self, index=0, templ_index=0):
template = get_template_names(self, templ_index)
template_len = len(template) - 1
if template[0] == "Human" and template_len == 1:
self.node._no_children = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
single_commands = ["move", "walk"]
template = get_template_names(self, templ_index)
template_len = len(template) - 1
if template[0] == "Human" and template_len == 1:
enhancements = ["anywhere", "somewhere", "around"]
new_commands = []
for comm in enhancements:
for command in single_commands:
new_commands.append(" ".join([command, comm]))
single_commands.extend(new_commands)
elif template_len == 2 and (template[-1] == "ConditionTypeNever"):
single_commands = ["keep walking", "keep moving"]
command = random.choice(single_commands)
prefix = random.choice(["", random.choice(["can you", "please", "can you please"])])
new_command = (" ".join([prefix, command])).strip()
return new_command
### BUILD ###
class Build(TemplateObject):
"""This template object represents the 'Build' command"""
def generate_description(self, arg_index=0, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
if "HumanReplace" in template_names:
return None
command_list = [
"build",
"make",
"construct",
"assemble",
"create",
"rebuild",
"install",
"place",
"put",
]
replace_flag = True if "HumanReplace" in template_names else False
if not replace_flag:
command_list.extend(["build me", "make me"])
command = random.choice(command_list)
if not replace_flag:
prefix = random.choice(
["", random.choice(["", "can you", "please", "can you please"])]
)
if command in ["build me", "make me"]:
prefix = random.choice(
["", random.choice(["", "can you", "please", "can you please"])]
)
new_command = (
random.choice([(" ".join([prefix, command])).strip(), "we need"])
if not replace_flag
else command
)
return new_command
class BuildSingle(TemplateObject):
"""This template object represents single word (no arguments) 'Build' command"""
def add_generate_args(self, index=0, templ_index=0):
self.node._no_children = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(
[
"build",
"make",
"construct",
"assemble",
"create",
"build something",
"build me something",
"make something",
"make something for me",
"make me something",
"construct something",
"assemble something",
"create something",
"build anything",
"build me anything",
"make anything",
"make me anything",
"construct anything",
"assemble anything",
"create anything",
"build something you know",
"build me something you know",
"make something you know",
"make me something you know",
"construct something you know",
"assemble something you know",
"create something you know",
"build anything you know",
"make anything you know",
"construct anything you know",
"assemble anything you know",
"create anything you know",
"build stuff",
"build me stuff",
"make stuff",
"create stuff",
"install something",
"install stuff",
"install something for me please",
]
)
prefix = random.choice(["", random.choice(["", "can you", "please", "can you please"])])
new_command = (" ".join([prefix, command])).strip()
return new_command
### DIG ###
class Dig(TemplateObject):
"""This template object repesents the Dig command"""
def generate_description(self, arg_index=0, index=0, templ_index=0):
template = self.node.template[templ_index]
template_names = get_template_names(self, templ_index)
command = random.choice(["dig", "mine", "clear"])
if (
"DigSomeShape" in template_names
and type(template[template_names.index("DigSomeShape")]._child).__name__
== "DigShapeHole"
):
command = random.choice(["make", "build"])
prefix = random.choice(
["", random.choice(["", "can you", "please", "can you please", "let 's", "help me"])]
)
new_command = (" ".join([prefix, command])).strip()
return new_command
class DigSingle(TemplateObject):
"""This template object repesents single word Dig command with no arguments"""
def add_generate_args(self, index=0, templ_index=0):
self.node._no_children = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(
[
"dig",
"mine",
"dig something",
"mine something",
"dig anything",
"mine anything",
"dig stuff",
"make a hole",
]
)
prefix = random.choice(
["", random.choice(["", "can you", "please", "can you please", "help me"])]
)
new_command = (" ".join([prefix, command])).strip()
return new_command
### FREEBUILD ###
class Freebuild(TemplateObject):
"""This template object repesents a Freebuild command"""
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(
[
"complete",
"can you please complete",
"please complete",
"can you complete",
"finish building",
]
)
return command
class FreebuildLocation(TemplateObject):
"""This template object repesents a Freebuild command with only Location"""
def add_generate_args(self, index=0, templ_index=0):
self.node._only_location = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(
[
"help me build something",
"help me make something",
"can you help me build something",
"can you help me make something",
"can you please help me build something",
"help me make something",
"help me make",
"help me build",
"build something with me",
"make something with me",
"let 's build something together",
"let 's build something",
]
)
return command
### DESTROY ###
class Destroy(TemplateObject):
"""This template object repesents the Destroy/ Destroy command"""
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(
[
"destroy",
"destroy",
"remove",
"destruct",
"knock down",
"explode",
"blow up",
"tear down",
"dismantle",
"cut down",
"chop",
"clear",
"chop down",
]
)
prefix = random.choice(
["", random.choice(["can you", "please", "can you please", "let 's", "help me"])]
)
new_command = random.choice([(" ".join([prefix, command])).strip(), "i do n't want"])
return new_command
class DestroySingle(TemplateObject):
"""This template object repesents single word Destroy command with no arguments"""
def add_generate_args(self, index=0, templ_index=0):
template = get_template_names(self, templ_index)
template_len = len(template) - 1
if template_len == 1:
self.node._no_children = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
single_commands = ["destroy", "remove", "destruct", "knock down", "explode", "dismantle"]
template = get_template_names(self, templ_index)
template_len = len(template) - 1
if template_len == 1:
enhancements = ["something", "anything"]
new_commands = []
for comm in enhancements:
for command in single_commands:
new_commands.append(" ".join([command, comm]))
single_commands.extend(new_commands)
elif template_len == 2 and template[-1] == "RepeatAll":
single_commands.extend(["clear", "chop down"])
enhancements = [
"everything",
"everything around",
"everything until I ask you to stop",
"everything until I tell you to stop",
]
new_commands = []
for comm in enhancements:
for command in single_commands:
new_commands.append(" ".join([command, comm]))
new_commands.extend(["clear area", "clear the whole area"])
single_commands = new_commands
command = random.choice(single_commands)
prefix = random.choice(
["", random.choice(["can you", "please", "can you please", "help me"])]
)
new_command = (" ".join([prefix, command])).strip()
return new_command
### SPAWN ###
class Spawn(TemplateObject):
"""This template object repesents the Spawn command."""
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["spawn", "create", "produce", "generate"])
prefix_choice = ["can you", "please", "can you please", "help me"]
prefix = random.choice(["", random.choice(prefix_choice)])
command = (" ".join([prefix, phrase])).strip()
return command
### FILL ###
class Fill(TemplateObject):
"""This template object repesents the Fill command"""
def generate_description(self, arg_index=0, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
phrases = ["fill", "cover"]
if "Up" not in template_names:
phrases.extend(["fill up", "cover up"])
phrase = random.choice(phrases)
prefix = random.choice(
["", random.choice(["can you", "please", "can you please", "help me"])]
)
command = (" ".join([prefix, phrase])).strip()
return command
### UNDO ###
class Undo(TemplateObject):
"""This template object repesents the Undo / revert action """
def add_generate_args(self, index=0, templ_index=0):
template = get_template_names(self, templ_index)
template_len = len(template) - 1
if template_len == 1:
self.node._no_children = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrases = ["undo", "revert"]
template = get_template_names(self, templ_index)
template_len = len(template) - 1
if template_len == 1:
phrases.extend(
["undo what you just did", "undo last action", "revert last action", "undo that"]
)
phrase = random.choice(phrases)
prefix = random.choice(
["", random.choice(["can you", "please", "can you please", "help me"])]
)
command = (" ".join([prefix, phrase])).strip()
return command
### STOP ###
class StopSingle(TemplateObject):
"""This template object repesents that the action that needs to be undone is
Build."""
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrases = [
"stop",
"hold on",
"wait",
"pause",
"stop doing that",
"stop doing what you are doing",
"stop what you are doing",
"do n't do that",
"stop task",
]
return random.choice(phrases)
class Stop(TemplateObject):
"""This template object repesents that the action that needs to be undone is
Build."""
def generate_description(self, arg_index=0, index=0, templ_index=0):
return random.choice(["stop", "stay"])
### RESUME ###
class ResumeSingle(TemplateObject):
"""This template object repesents that the action that needs to be undone is
Build."""
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrases = [
"resume",
"continue",
"restart",
"start again",
"keep going on",
"keep going",
"keep doing that",
"keep doing what you were doing",
"continue doing that",
"continue doing what you were doing",
"continue what you were doing",
"go back to doing what you were doing",
"go back to what you were doing",
]
return random.choice(phrases)
class Resume(TemplateObject):
"""This template object repesents that the action that needs to be undone is
Build."""
def generate_description(self, arg_index=0, index=0, templ_index=0):
return random.choice(["resume", "keep", "continue"])
### COPY ###
"""This template object represents the Copy action."""
class Copy(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
replace_flag = True if "HumanReplace" in template_names else False
if any(x in ["RepeatAll", "RepeatCount"] for x in template_names):
command = random.choice(
[
"make copies of",
"make me copies of",
"create copies of",
"copy",
"replicate",
"reproduce",
"emulate",
"make another of",
]
)
else:
template_names = get_template_names(self, templ_index)
command_list = ["copy", "replicate", "reproduce", "emulate"]
if not replace_flag:
command_list.extend(
[
"make a copy of",
"make me a copy of",
"create a copy of",
"make copy of",
"make another one of",
"build me another one of",
]
)
command = random.choice(command_list)
if not replace_flag:
prefix = random.choice(
["", random.choice(["", "can you", "please", "can you please", "help me"])]
)
new_command = (
random.choice([(" ".join([prefix, command])).strip()]) if not replace_flag else command
)
return new_command
class CopyMultiple(TemplateObject):
"""This template object represents the Copy action where mutiple copies need to be
made."""
def add_generate_args(self, index=0, templ_index=0):
num_copies = random.choice(self.template_attr.get("count", range(1, 101)))
self.num_copies = random.choice(
[str(num_copies), int_to_words(num_copies), "a few", "some"]
)
self.node._repeat_args["repeat_key"] = "FOR"
self.node._repeat_args["repeat_count"] = self.num_copies
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(
[
"make {} copies of",
"make me {} copies of",
"create {} copies of",
"make {} of",
"make me {} of",
"create {} of",
]
).format(self.num_copies)
prefix = random.choice(
["", random.choice(["", "can you", "please", "can you please", "help me"])]
)
new_command = (" ".join([prefix, command])).strip()
return new_command
"""This template object represents a single word Copy action with no arguments."""
class CopySingle(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._no_children = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(
[
"copy",
"make a copy",
"make me a copy",
"create a copy",
"copy something",
"make a copy of something",
"create a copy of something",
"copy anything",
"make a copy of anything",
"create a copy of anything",
]
)
prefix = random.choice(
["", random.choice(["", "can you", "please", "can you please", "help me"])]
)
new_command = (" ".join([prefix, command])).strip()
return new_command
### TAG ###
"""This template object represents the Tag action."""
class Tag(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(["tag", "label", "name"])
prefix = random.choice(
["", random.choice(["", "can you", "please", "can you please", "let 's", "help me"])]
)
new_command = (" ".join([prefix, command])).strip()
return new_command
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/action_names.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains common template objects used across different templates.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
#######################
## COMMON TEMPLATES ##
#######################
"""This template object represents the phrase: do X n times """
class NTimes(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
num_copies = random.choice(self.template_attr.get("count", range(1, 101)))
self.num_copies = random.choice([str(num_copies), int_to_words(num_copies)])
self.node._repeat_args["repeat_key"] = "FOR"
self.node._repeat_args["repeat_count"] = self.num_copies
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(["{} times"]).format(self.num_copies)
return command
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/common.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated with special shape commands
like : Wall, Stack, Place etc
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
##################################
## SPECIAL COMMANDS FOR SHAPES ###
##################################
class Wall(TemplateObject):
"""These template objects represent Schematics of type Shape that have an additional
'has_shape_' key in their dictionary.
This is mostly because the description of these doesn't occur in the
surface form to compute spans."""
def add_generate_args(self, index=0, templ_index=0):
self.node._schematics_args["schematic_type"] = RectangleShape
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
word = description["word"]
template_names = get_template_names(self, templ_index)
previous_template_name = template_names[index - 1]
# with a 0.5 probability, return with a/an
if previous_template_name == "Build":
if pick_random():
return prepend_a_an(word)
return word
class Stack(TemplateObject):
"""Rectanguloid with a height n"""
def add_generate_args(self, index=0, templ_index=0):
self.node._schematics_args["schematic_type"] = Shape
self.node._schematics_args["repeat_dir"] = "UP"
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(["stack", "put up"])
prefix = random.choice(
["", random.choice(["can you", "please", "can you please", "let 's", "help me"])]
)
new_command = (" ".join([prefix, command])).strip()
return new_command
class Place(TemplateObject):
"""Rectangualoid with a width n"""
def add_generate_args(self, index=0, templ_index=0):
self.node._schematics_args["schematic_type"] = Shape
self.node._schematics_args["repeat_dir"] = "RIGHT"
def generate_description(self, arg_index=0, index=0, templ_index=0):
command = random.choice(["place", "put"])
prefix = random.choice(
["", random.choice(["can you", "please", "can you please", "let 's", "help me"])]
)
new_command = (" ".join([prefix, command])).strip()
return new_command
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/special_shape_commands.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated with Schematics.
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
###########################
### SCHEMATIC TEMPLATES ###
###########################
class UsingBlockType(TemplateObject):
"""This template ensures that the final generation has an attribute : block_type."""
def add_generate_args(self, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
if any(x in ["BuildSingle", "Use"] for x in template_names):
self.node._schematics_args["only_block_type"] = True
if (
"Use" in template_names
and self.node._schematics_args["schematic_type"] is not None
):
self.node._schematics_args["only_block_type"] = False
self.node._schematics_args["block_type"] = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
block_type = description["block_type"]
template_name = get_template_names(self, templ_index)
previous_template_name = template_name[index - 1]
if previous_template_name == "Build":
return prepend_a_an(block_type)
return block_type
class AndBuild(TemplateObject):
"""This TemplateObject represents that there are two schematics that need to be built"""
def add_generate_args(self, index=0, templ_index=0):
self.node._schematics_args["multiple_schematics"] = True
class DescribingWord(TemplateObject):
"""This template object repesents the word / name of a schematic."""
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
word = description["word"]
template_names = get_template_names(self, templ_index)
previous_template_name = template_names[index - 1]
# with a 0.5 probability, return with a/an
if previous_template_name == "Build":
if pick_random():
return prepend_a_an(word)
return word
class NumBlocks(TemplateObject):
"""This template object represents a number of blocks and can be used to assign
height, width, depth etc."""
def add_generate_args(self, index=0, templ_index=0):
height = random.choice(self.template_attr.get("height", range(1, 12)))
self.num = int_to_words(height) if pick_random() else height
action_node = self.node
previous_template_name = type(action_node.template[templ_index][1]).__name__
if previous_template_name == "Dig":
dim_template = type(action_node.template[templ_index][index + 2]).__name__
if dim_template == "Wide":
action_node.schematic["has_width"] = self.num
elif dim_template == "Long":
action_node.schematic["has_length"] = self.num
elif dim_template == "Deep":
action_node.schematic["has_depth"] = self.num
elif previous_template_name == "Build":
dim_template = type(action_node.template[templ_index][index + 2]).__name__
node_attr = self.node._schematics_args["schematic_attributes"]
if dim_template == "High":
if node_attr:
node_attr["height"] = self.num
else:
self.node._schematics_args["schematic_attributes"] = {"height": self.num}
if dim_template == "Long":
if node_attr:
node_attr["length"] = self.num
else:
self.node._schematics_args["schematic_attributes"] = {"length": self.num}
def generate_description(self, arg_index=0, index=0, templ_index=0):
template_names = get_template_names(self, templ_index)
if template_names[index - 1] == "Build":
return "a " + str(self.num)
return str(self.num)
"""This template object represents an A by B dimension of a Schematic.
Eg: The 2 x 4 in "Build a 2 x 4 wall" """
class SchematicsDimensions(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._schematics_args["schematic_attributes"] = True
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
template_names = get_template_names(self, templ_index)
dimensions = None
multi_size_attr = None
# shape_attributes isn't supported for CategoryObject Schematics
# extract dimensions from the dict
if "shape_attributes" in description:
shape_attributes = description["shape_attributes"]
for attr in shape_attributes:
if "size" in attr:
size = attr.split("size")[1].strip() # extract '3 x 4' from 'of size 3 x 4'
if ("x" in size) or ("by" in size):
# if already formatted
multi_size_attr = attr
dimensions = size
else:
# else construct dimensions
sizes = size.split()
if len(sizes) > 1:
sizes = random.choice([" x ".join(sizes), " by ".join(sizes)])
multi_size_attr = attr
dimensions = sizes
if multi_size_attr:
shape_attributes.remove(multi_size_attr)
if dimensions and ("RepeatCount" not in template_names):
dimensions = "a " + dimensions # a 3 x 4 cube
return dimensions
return ""
"""This template object forces the Schematics to have explicit
attributes / dimensions"""
class WithAttributes(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._schematics_args["schematic_attributes"] = True
def generate_description(self, arg_index, index, templ_index=0):
description = self.node.args[arg_index].generate_description()
# shape_attributes isn't supported for CategoryObject Schematics
if "shape_attributes" in description:
shape_attributes = description["shape_attributes"]
return shape_attributes
return ""
"""This template object adds an abstract 'size' to Schematics"""
class SchematicSize(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._schematics_args["abstract_size"] = True
def generate_description(self, arg_index, index, templ_index=0):
description = self.node.args[arg_index].generate_description()
size = description["size"]
template = get_template_names(self, templ_index)
previous_template_name = template[index - 1]
# For Build: Build a huge archway / Build huge archway
if previous_template_name == "Build":
if pick_random():
return prepend_a_an(size)
return size
"""This template object adds an abstract 'color' to Schematics"""
class SchematicColour(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._schematics_args["colour"] = True
def generate_description(self, arg_index, index, templ_index=0):
description = self.node.args[arg_index].generate_description()
colour = description["colour"]
template = get_template_names(self, templ_index)
previous_template_name = template[index - 1]
# For Build: Build a red archway / Build red archway
if previous_template_name == "Build":
if pick_random():
return prepend_a_an(colour)
return colour
"""This template object represents one word shapes for Build commands.
'dome' -> Build dome"""
class BuildShape(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self._shape_type = random.choice(SCHEMATIC_TYPES)
self.node._schematics_args["schematic_type"] = self._shape_type
def generate_description(self, arg_index=0, index=0, templ_index=0):
description = self.node.args[arg_index].generate_description()
word = description["word"]
return word
class Use(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._no_children = False
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(["use", "make using", "build using", "do the construction using"])
return phrase
SCHEMATICS_TEMPLATES = [
UsingBlockType,
DescribingWord,
SchematicsDimensions,
WithAttributes,
NumBlocks,
SchematicSize,
SchematicColour,
BuildShape,
Use,
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/schematics.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated with human-bot dialogues.
"""
from generate_utils import *
from tree_components import *
from .template_object import *
action_reference_object_map = {
"BUILD": "building",
"DESTROY": "destroying",
"SPAWN": "spawning",
"MOVE": "following",
"DIG": "digging",
"FILL": "filling",
}
class QueryBotCurrentAction(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._filters_args["temporal"] = "CURRENT"
self.node._filters_args["mem_type"] = "ACTION"
self.node.answer_type = "TAG"
self.node.tag_name = "action_name"
def generate_description(self, arg_index=0, index=0, templ_index=0):
question = random.choice(
[
"what are you doing",
"tell me what are you doing",
"what is your task",
"tell me your task",
"what are you up to",
]
)
return question
class QueryBot(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
curr_template = get_template_names(self, templ_index)
if "MoveTarget" in curr_template:
question = random.choice(["where are you", "tell me where you are"])
elif "See" in curr_template:
question = random.choice(
[
"what is",
"what are the labels associated with",
"what are the categories of",
"tell me the properties of",
]
)
elif "CurrentLocation" in curr_template:
question = random.choice(
[
"where are you",
"tell me where you are",
"i do n't see you",
"i ca n't find you",
"are you still around",
]
)
else:
question = random.choice(["what are you", "now what are you", "tell me what you are"])
return question
class CurrentLocation(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._filters_args["temporal"] = "CURRENT"
self.node._filters_args["mem_type"] = "AGENT"
self.node.answer_type = "TAG"
self.node.tag_name = "location"
class ActionReferenceObjectName(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._filters_args["temporal"] = "CURRENT"
self.node._filters_args["mem_type"] = "ACTION"
self.node._filters_args["action_type"] = random.choice(
list(action_reference_object_map.keys())
)
self.node.answer_type = "TAG"
self.node.tag_name = "action_reference_object_name"
def generate_description(self, arg_index=0, index=0, templ_index=0):
question = action_reference_object_map[self.node._filters_args["action_type"]]
return question
class MoveTarget(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._filters_args["temporal"] = "CURRENT"
self.node._filters_args["mem_type"] = "ACTION"
self.node.answer_type = "TAG"
self.node.tag_name = "move_target"
def generate_description(self, arg_index=0, index=0, templ_index=0):
question = random.choice(["heading", "off to", "going", "walking to", "heading over to"])
self.node._action_name = question
return question
class HumanReward(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._upsert_args["memory_type"] = "REWARD"
class PosReward(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._upsert_args["reward_value"] = "POSITIVE"
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(
[
"good job",
"cool",
"that is really cool",
"that is awesome",
"awesome",
"that is amazing",
"that looks good",
"you did well",
"great",
"good",
"nice",
]
)
return phrase
class NegReward(TemplateObject):
def add_generate_args(self, index=0, templ_index=0):
self.node._upsert_args["reward_value"] = "NEGATIVE"
def generate_description(self, arg_index=0, index=0, templ_index=0):
phrase = random.choice(
[
"that is wrong",
"that was wrong",
"that was completely wrong",
"not that",
"that looks horrible",
"that is not what i asked",
"that is not what i told you to do",
"that is not what i asked for",
"not what i told you to do",
"you failed",
"failure",
"fail",
"not what i asked for",
]
)
return phrase
class BotThank(TemplateObject):
def generate_description(self, arg_index=0, index=0, templ_index=0):
reply = random.choice(["Thanks for letting me know."])
return reply
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/dialogue_human_bot.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file defines the TemplateObject class and other data structures used across
template objects.
"""
from generate_utils import *
from tree_components import *
SCHEMATIC_TYPES = [
RectanguloidShape,
HollowRectanguloidShape,
CubeShape,
HollowCubeShape,
SphereShape,
HollowSphereShape,
PyramidShape,
RectangleShape,
SquareShape,
TriangleShape,
CircleShape,
DiskShape,
EllipsoidShape,
DomeShape,
ArchShape,
TowerShape,
CategoryObject,
]
TAG_ADJECTIVES = [
"round",
"bright",
"crooked",
"steep",
"blurry",
"deep",
"flat",
"large",
"tall",
"broad",
"fuzzy",
"long",
"narrow",
"sleek",
"sharp",
"curved",
"wide",
"nice",
"pretty",
]
TAG_NAMES = (
[
"box",
"rectanguloid",
"cube",
"empty box",
"hollow box",
"hollow rectanguloid",
"cube",
"empty cube",
"hollow cube",
"ball",
"sphere",
"dome",
"empty sphere",
"empty ball",
"hollow ball",
"spherical shell",
"hollow sphere",
"pyramid",
"rectangle",
"square",
"triangle",
"circle",
"disk",
"ellipsoid",
"dome",
"arch",
"tower",
"wall",
]
+ MOBS
+ SUBCOMPONENT_LABELS
)
class TemplateObject:
def __init__(self, node, template_attr):
self.node = node
self.template_attr = template_attr
def generate_description(self, arg_index=0, index=0, templ_index=0):
return
def get_template_names(obj, templ_index=0):
return [type(temp_obj).__name__ for temp_obj in obj.node.template[templ_index]]
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/template_object.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
This file contains template objects associated with the Tag action
"""
import random
from generate_utils import *
from tree_components import *
from .template_object import *
#####################
### TAG TEMPLATES ###
#####################
tag_map = {"colour": COLOURS, "size": ABSTRACT_SIZE, "tag": TAG_ADJECTIVES}
class TagDesc(TemplateObject):
"""This template object has tags that can be used as adjectives.
eg : this red shape is bright.
"""
def add_generate_args(self, index=0, templ_index=0):
self.node._upsert_args["memory_type"] = "TRIPLE"
tag_name = random.choice(list(tag_map.keys()))
tag = random.choice(tag_map[tag_name])
# set the has_tag_name as the tag
self.node._upsert_args["has_" + tag_name] = tag
self._tag = tag
def generate_description(self, arg_index=0, index=0, templ_index=0):
return self._tag
class TagName(TemplateObject):
"""This template object repesents the name of a tag.
eg: spider or big spider"""
def add_generate_args(self, index=0, templ_index=0):
self.node._upsert_args["memory_type"] = "TRIPLE"
ALL_TAGS = ABSTRACT_SIZE + COLOURS + TAG_ADJECTIVES
names_desc = [" ".join([desc, name]) for name in TAG_NAMES for desc in ALL_TAGS]
names = random.choice([TAG_NAMES + names_desc])
self._tag = random.choice(names)
# add has_tag key
self.node._upsert_args["has_tag"] = self._tag
def generate_description(self, arg_index=0, index=0, templ_index=0):
return prepend_a_an(self._tag)
| craftassist-master | python/base_agent/ttad/generation_dialogues/template_objects/tag.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
Actions:
- GetMemory (filters, answer_type)
- PutMemory (filters, info_type)
Top-Level = {
"dialogue_type": {
`action_type`: {Action}
}
}
e.g. {
"get_memory" : {
"filters" : {
"type" : "action",
"temporal" : "current"
}
}
}
Action = {
{arg_type}: {arg_dict} # e.g. Move dict = {"Location": {Location}}
}
"""
from .action_node import *
from tree_components import *
class GetMemory(ActionNode):
"""The BotCurrentAction
__init__(): Pick a template from move_templates.py.
generate(): Instantiate the template_objects in the template that populate the
child arguments for classes in ARG_TYPES.
For example: the template objects populate values of
'location_type','relative_direction' etc. for Location
_generate_description(): Generates the text description using the template ojects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("GetMemory", template, template_attr=template_attr)
self._is_dialogue = True
@classmethod
def generate(cls, template=None, template_attr={}):
get_mem_obj = GetMemory(template, template_attr)
template = get_mem_obj.template
get_mem_obj.ARG_TYPES = []
get_mem_obj._no_children = False # no ARG_TYPE if _no_children is True
get_mem_obj._block_obj_args = Arguments(
{
"block_object_type": Object,
"block_object_attributes": None,
"block_object_location": False,
"no_child": False,
"repeat_key": None,
"repeat_location": None,
"coref_type": None,
}
)
get_mem_obj._location_args = Arguments(
{
"location_type": "ANY",
"relative_direction": False,
"steps": None,
"repeat_key": None,
}
)
get_mem_obj._filters_args = Arguments(
{
"temporal": None,
"mem_type": None,
"action_type": None,
"block_object_attr": get_mem_obj._block_obj_args,
"location_attr": get_mem_obj._location_args,
}
)
get_mem_obj.answer_type = None
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
# Append the ARG_TYPE object with arguments, to generate the action tree
get_mem_obj.args = []
if get_mem_obj._no_children:
return get_mem_obj
if (
get_mem_obj._filters_args.values_updated
or get_mem_obj._block_obj_args.values_updated
or get_mem_obj._location_args.values_updated
):
if get_mem_obj._block_obj_args.values_updated:
get_mem_obj._filters_args["bo_updated"] = True
if get_mem_obj._location_args.values_updated:
get_mem_obj._filters_args["location_updated"] = True
get_mem_obj.ARG_TYPES.append(Filters)
get_mem_obj.args.append(Filters(**get_mem_obj._filters_args))
return get_mem_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
for i, key in enumerate(templ):
# get the text from template object
item = key.generate_description(arg_index=0, index=i, templ_index=j)
if not item:
continue
# flatten nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class PutMemory(ActionNode):
"""The BotCurrentAction
__init__(): Pick a template from move_templates.py.
generate(): Instantiate the template_objects in the template that populate the
child arguments for classes in ARG_TYPES.
For example: the template objects populate values of
'location_type','relative_direction' etc. for Location
_generate_description(): Generates the text description using the template ojects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("PutMemory", template, template_attr=template_attr)
self._is_dialogue = True
@classmethod
def generate(cls, template=None, template_attr={}):
put_mem_obj = PutMemory(template, template_attr)
template = put_mem_obj.template
put_mem_obj.ARG_TYPES = []
put_mem_obj._no_children = False # no ARG_TYPE if _no_children is True
put_mem_obj._arg_type = BlockObject
put_mem_obj._block_obj_args = Arguments(
{
"block_object_type": Object,
"block_object_attributes": None,
"block_object_location": False,
"no_child": False,
"repeat_key": None,
"repeat_location": None,
"coref_type": None,
}
)
put_mem_obj._mob_args = Arguments(
{"mob_location": None, "repeat_key": None, "repeat_location": None}
)
put_mem_obj._filters_args = Arguments(
{
"temporal": None,
"mem_type": None,
"action_type": None,
"block_object_attr": put_mem_obj._block_obj_args,
"mob_attr": put_mem_obj._mob_args,
}
)
put_mem_obj._upsert_args = Arguments(
{
"memory_type": None,
"reward_value": None,
"has_tag": None,
"has_size": None,
"has_colour": None,
}
)
put_mem_obj.info_type = None
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
# Append the ARG_TYPE object with arguments, to generate the action tree
put_mem_obj.args = []
if put_mem_obj._no_children:
return put_mem_obj
if put_mem_obj._arg_type == Mob:
put_mem_obj._filters_args["mob_updated"] = True
elif put_mem_obj._block_obj_args.values_updated:
put_mem_obj._filters_args["bo_updated"] = True
put_mem_obj.ARG_TYPES.append(Filters)
put_mem_obj.args.append(Filters(**put_mem_obj._filters_args))
if put_mem_obj._upsert_args.values_updated:
put_mem_obj.ARG_TYPES.append(Upsert)
put_mem_obj.args.append(Upsert(**put_mem_obj._upsert_args))
return put_mem_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
for i, key in enumerate(templ):
# get the text from template object
item = key.generate_description(arg_index=0, index=i, templ_index=j)
if not item:
continue
# flatten nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
| craftassist-master | python/base_agent/ttad/generation_dialogues/generate_data/human_bot_dialogue.py |
# fmt: off
from .action_node import *
from .human_human_dialogue import *
from .human_bot_dialogue import *
| craftassist-master | python/base_agent/ttad/generation_dialogues/generate_data/__init__.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
Actions:
- Move (optional<Location>, optional<StopCondition>, optional<Repeat>)
- Build (optional<Schematic>, optional<Location>, optional<Repeat>)
- Destroy (optional<BlockObject>)
- Dig (optional<has_length>, optional<has_width>, optional<has_depth>,
optional<has_size>, optional<Location>, optional<StopCondition>,
optional<Repeat>)
- Copy (optional<BlockObject>, optional<Location>, optional<Repeat>)
- Undo (optional<target_action_type>)
- Fill (optional<Location>, optional<Repeat>)
- Spawn (Mob, optional<Repeat>)
- Freebuild (optional<BlockObject>, optional<Location>)
- Stop ()
- Resume ()
- Noop ()
Top-Level = {
"dialogue_type": {
"action_name" : {Action}
}
}
e.g. {
"human_give_command": {
"Move" : {"Location": {Location}}
}
}
Action = {
{arg_type}: {arg_dict} # e.g. Move dict = {"Location": {Location}}
}
"""
from collections import OrderedDict
from .action_node import *
from generate_utils import *
from template_objects import (
LOCATION_TEMPLATES,
CONDIITON_TEMPLATES,
REPEAT_KEY_TEMPLATES,
BLOCKOBJECT_TEMPLATES,
)
from tree_components import Location, Schematic, BlockObject, Object, Mob, StopCondition, Repeat
############
## ACTION ##
############
class Move(ActionNode):
"""The Move action is used to move/ walk to a certain location. The action
needs a Location to move to.
__init__(): Pick a template from move_templates.py.
generate(): Instantiate the template_objects in the template that populate the
child arguments for classes in ARG_TYPES.
For example: the template objects populate values of
'location_type','relative_direction' etc. for Location
_generate_description(): Generates the text description using the template ojects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("Move", template, template_attr=template_attr)
@classmethod
def generate(cls, template=None, template_attr={}):
move_obj = Move(template, template_attr)
template = move_obj.template
move_obj.ARG_TYPES = []
move_obj._no_children = False # no ARG_TYPE if _no_children is True
move_obj._location_args = Arguments(
{
"location_type": "ANY",
"relative_direction": False,
"steps": None,
"coref_resolve": None,
"relative_direction_value": None,
"bo_coref_resolve": None,
"template_attr": template_attr,
}
)
move_obj._condition_args = Arguments({"condition_type": None, "block_type": None})
# the number of repetitions for Action if any
move_obj._repeat_args = Arguments(
{"repeat_key": None, "repeat_count": None, "repeat_dir": None}
)
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
# Append the ARG_TYPE object with arguments, to generate the action tree
move_obj.args = []
if move_obj._no_children:
return move_obj
move_obj.ARG_TYPES.append(Location)
move_obj.args.append(Location(**move_obj._location_args))
# StopCondition is optional, only add if the default arguments were changed.
if move_obj._condition_args.values_updated:
move_obj.ARG_TYPES.append(StopCondition)
move_obj.args.append(StopCondition(**move_obj._condition_args))
# Repeat is optional, only add if default values were updated
if move_obj._repeat_args.values_updated:
move_obj.ARG_TYPES.append(Repeat)
move_obj.args.append(Repeat(**move_obj._repeat_args))
return move_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
for i, key in enumerate(templ):
key_type = type(key)
arg_index = 0
# arg_index 1 for StopCondition
if (key_type in CONDIITON_TEMPLATES) and (len(self.args) > 1):
arg_index = 1
# get the text from template object
item = key.generate_description(arg_index=arg_index, index=i, templ_index=j)
if not item:
continue
# flatten nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Build(ActionNode):
"""The Build action is used to build something. The action needs a Schematic
and maybe a Location to build something.
__init__(): Pick a template from build_templates.py.
generate(): Instantiate the template_objects in the template that populate the
child arguments for classes in ARG_TYPES.
For example: the template objects populate values of
'location_type','relative_direction' etc. for Location
_generate_description(): Generates the text description using the template ojects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("Build", template, template_attr=template_attr)
@classmethod
def generate(cls, template=None, template_attr={}):
build_obj = Build(template, template_attr)
template = build_obj.template
build_obj.ARG_TYPES = []
build_obj._no_children = False # no ARG_TYPE if _no_children is True
build_obj._schematics_args = Arguments(
{
"only_block_type": False,
"block_type": False,
"schematic_attributes": False,
"schematic_type": None,
"abstract_size": None,
"colour": None,
"repeat_key": None,
"repeat_dir": None,
"template_attr": template_attr,
"multiple_schematics": False,
}
)
build_obj._location_args = Arguments(
{
"location_type": "ANY",
"relative_direction": False,
"steps": None,
"repeat_key": None,
"coref_resolve": None,
"template_attr": template_attr,
}
)
# the number of repetitions for Action if any
build_obj._repeat_args = Arguments(
{"repeat_key": None, "repeat_count": None, "repeat_dir": None}
)
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
# Append the ARG_TYPE object with arguments, to generate the action tree
build_obj.args = []
if build_obj._schematics_args.values_updated or not build_obj._no_children:
build_obj.ARG_TYPES.append(Schematic)
build_obj.args.append(Schematic(**build_obj._schematics_args))
# Location is optional, only add if the default arguments were changed.
if build_obj._location_args.values_updated:
build_obj.ARG_TYPES.append(Location)
build_obj.args.append(Location(**build_obj._location_args))
# Repeat is optional, only add if default values were updated
if build_obj._repeat_args.values_updated:
build_obj.ARG_TYPES.append(Repeat)
build_obj.args.append(Repeat(**build_obj._repeat_args))
return build_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
for i, key in enumerate(templ):
item = None
key_type = type(key)
arg_index = 0
# arg_index 1 for Location
if ((key_type in LOCATION_TEMPLATES) or (key_type in BLOCKOBJECT_TEMPLATES)) and (
len(self.args) > 1
):
arg_index = 1
item = key.generate_description(arg_index=arg_index, index=i, templ_index=j)
if not item:
continue
# flatten nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
# shape_attributes can be a list
elif type(item) == list:
result.extend(item)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Copy(ActionNode):
"""The Copy action is used to make a copy of something. The action is just the
Build action with a BlockObject and maybe a Location to make the copy at.
__init__(): Pick a template from copy_templates.py.
generate(): Instantiate the template_objects in the template that populate the
child arguments for classes in ARG_TYPES.
For example: the template objects populate values of
'location_type','relative_direction' etc. for Location
_generate_description(): Generates the text description using the template ojects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("Copy", template, template_attr=template_attr)
def generate(template=None, template_attr={}):
copy_obj = Copy(template, template_attr)
template = copy_obj.template
copy_obj.ARG_TYPES = []
copy_obj._no_children = False # no ARG_TYPE if _no_children is True
copy_obj._block_obj_args = Arguments(
{
"block_object_type": Object,
"block_object_attributes": None,
"block_object_location": False,
"no_child": False,
"repeat_key": None,
"repeat_location": None,
"coref_type": None,
"template_attr": template_attr,
}
)
copy_obj._location_args = Arguments(
{
"location_type": "ANY",
"relative_direction": False,
"steps": None,
"repeat_key": None,
"template_attr": template_attr,
}
)
# the number of repetitions for Action if any
copy_obj._repeat_args = Arguments(
{"repeat_key": None, "repeat_count": None, "repeat_dir": None}
)
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
# Append the ARG_TYPE object with arguments, to generate the action tree
copy_obj.args = []
if copy_obj._no_children:
return copy_obj
if copy_obj._block_obj_args.values_updated:
copy_obj.ARG_TYPES.append(BlockObject)
copy_obj.args.append(BlockObject(**copy_obj._block_obj_args))
# Location is optional, only add if the default arguments were changed.
if copy_obj._location_args.values_updated:
copy_obj.ARG_TYPES.append(Location)
copy_obj.args.append(Location(**copy_obj._location_args))
# Repeat is optional, only add if default values were updated
if copy_obj._repeat_args.values_updated:
copy_obj.ARG_TYPES.append(Repeat)
copy_obj.args.append(Repeat(**copy_obj._repeat_args))
return copy_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
for i, key in enumerate(templ):
item = None
key_type = type(key)
arg_index = 0
# check template_objects.py for the list of template objects
if key_type in LOCATION_TEMPLATES:
if BlockObject in self.ARG_TYPES:
arg_index = 1
elif key_type in REPEAT_KEY_TEMPLATES:
if Repeat in self.ARG_TYPES:
if BlockObject in self.ARG_TYPES:
if Location in self.ARG_TYPES:
arg_index = 2
else:
arg_index = 1
item = key.generate_description(arg_index=arg_index, index=i, templ_index=j)
if not item:
continue
# flatten nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Dig(ActionNode):
"""The Dig action is used to dig something. The action needs a length, width
and depth and maybe a Location to dig something at.
__init__(): Pick a template from dig_templates.py.
generate(): Instantiate the template_objects in the template that populate the
child arguments for classes in ARG_TYPES.
For example: the template objects populate values of
'location_type','relative_direction' etc. for Location
_generate_description(): Generates the text description using the template ojects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__(template_key="Dig", template=template, template_attr=template_attr)
def generate(template=None, template_attr={}):
dig_obj = Dig(template, template_attr)
template = dig_obj.template
dig_obj.ARG_TYPES = []
dig_obj._no_children = False # no ARG_TYPE if _no_children is True
dig_obj.schematic = {}
dig_obj._location_args = Arguments(
{
"location_type": "ANY",
"relative_direction": False,
"steps": None,
"repeat_key": None,
"coref_resolve": None,
"template_attr": template_attr,
}
)
dig_obj._condition_args = Arguments({"condition_type": None, "block_type": None})
# the number of repetitions for Action if any
dig_obj._repeat_args = Arguments(
{"repeat_key": None, "repeat_count": None, "repeat_dir": None}
)
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
# Append the ARG_TYPE object with arguments, to generate the action tree
dig_obj.args = []
if dig_obj._no_children:
return dig_obj
# Location is optional, only add if the default arguments were changed.
if dig_obj._location_args.values_updated:
dig_obj.ARG_TYPES.append(Location)
dig_obj.args.append(Location(**dig_obj._location_args))
# StopCondition is optional, only add if the default arguments were changed.
if dig_obj._condition_args.values_updated:
dig_obj.ARG_TYPES.append(StopCondition)
dig_obj.args.append(StopCondition(**dig_obj._condition_args))
# Repeat is optional, only add if default values were updated
if dig_obj._repeat_args.values_updated:
dig_obj.ARG_TYPES.append(Repeat)
dig_obj.args.append(Repeat(**dig_obj._repeat_args))
return dig_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
for i, key in enumerate(templ):
item = None
key_type = type(key)
arg_index = 0
# arg_index 1 for StopCondition
if key_type in CONDIITON_TEMPLATES and Location in self.ARG_TYPES:
arg_index = 1
item = key.generate_description(arg_index=arg_index, index=i, templ_index=j)
if not item:
continue
# flatten nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Destroy(ActionNode):
"""The Destroy action is used to destroy something. The action needs a
BlockObject to destroy.
__init__(): Pick a template from destroy_templates.py.
generate(): Instantiate the template_objects in the template that populate the
child arguments for classes in ARG_TYPES.
For example: the template objects populate values of
'block_object_type','block_object_attributes' etc. for BlockObject
_generate_description(): Generates the text description using the template objects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("Destroy", template, template_attr=template_attr)
def generate(template=None, template_attr={}):
destroy_obj = Destroy(template, template_attr)
template = destroy_obj.template
destroy_obj.ARG_TYPES = []
destroy_obj._no_children = False # no ARG_TYPE if _no_children is True
destroy_obj._block_obj_args = Arguments(
{
"block_object_type": Object,
"block_object_attributes": [],
"block_object_location": False,
"no_child": False,
"repeat_key": None,
"repeat_no_child": None,
"repeat_location": None,
"coref_type": None,
"template_attr": template_attr,
}
)
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
# Append the ARG_TYPE object with arguments, to generate the action tree
destroy_obj.args = []
if destroy_obj._no_children:
return destroy_obj
if destroy_obj._block_obj_args.values_updated:
destroy_obj.ARG_TYPES.append(BlockObject)
destroy_obj.args.append(BlockObject(**destroy_obj._block_obj_args))
return destroy_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
for key in templ:
key_type = type(key)
arg_index = 0
if key_type in CONDIITON_TEMPLATES and (len(self.args) > 1):
arg_index = 1
item = key.generate_description(arg_index=arg_index, templ_index=j)
if not item:
continue
# flatten if nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Undo(ActionNode):
"""Undo action is used to revert an action/ last action.
__init__(): Pick a template from undo_templates.py.
generate(): Instantiates the template_objects in the template.
_generate_description(): Generates the text description using the template ojects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("Undo", template, template_attr=template_attr)
def generate(template=None, template_attr={}):
undo_obj = Undo(template, template_attr)
template = undo_obj.template
undo_obj.ARG_TYPES = []
undo_obj._no_children = False # no ARG_TYPE if _no_children is True
undo_obj.target_action_type = None # name of action to be undone
undo_obj.args = []
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
return undo_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
arg_index = 0
for i, key in enumerate(templ):
item = None
item = key.generate_description(arg_index=arg_index, index=i, templ_index=j)
if not item:
continue
# flatten nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Fill(ActionNode):
"""Fill action is used to fill up holes. This action may have
an optional location.
__init__(): Pick a template from fill_templates.py.
generate(): Instantiate the template_objects in the template that populate the
child arguments for classes in ARG_TYPES.
For example: the template objects populate values of
'location_type','relative_direction' etc. for Location
_generate_description(): Generates the text description using the template ojects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("Fill", template, template_attr=template_attr)
def generate(template=None, template_attr={}):
fill_obj = Fill(template, template_attr)
template = fill_obj.template
fill_obj.ARG_TYPES = []
fill_obj._no_children = False # no ARG_TYPE if _no_children is True
fill_obj.has_block_type = None
fill_obj.reference_object = {}
fill_obj._location_args = Arguments(
{
"location_type": "ANY",
"relative_direction": False,
"steps": None,
"coref_resolve": None,
"template_attr": template_attr,
}
)
# the number of repetitions for Action if any
fill_obj._repeat_args = Arguments(
{"repeat_key": None, "repeat_count": None, "repeat_dir": None}
)
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
# Append the ARG_TYPE object with arguments, to generate the action tree
fill_obj.args = []
if fill_obj._no_children:
return fill_obj
# Location is optional, only add if the default arguments were changed.
if fill_obj._location_args.values_updated:
fill_obj.ARG_TYPES.append(Location)
fill_obj.args.append(Location(**fill_obj._location_args))
# Repeat is optional, only add if default values were updated
if fill_obj._repeat_args.values_updated:
fill_obj.ARG_TYPES.append(Repeat)
fill_obj.args.append(Repeat(**fill_obj._repeat_args))
return fill_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
arg_index = 0
for i, key in enumerate(templ):
item = None
item = key.generate_description(arg_index=arg_index, index=i, templ_index=j)
if not item:
continue
# flatten nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Spawn(ActionNode):
"""The Spawn action spawns a mob in the environment. The class needs a Mob to spawn.
__init__(): Picks a template from templates.py.
generate(): Instantiate the template_objects in the template that populate the
child arguments for classes in ARG_TYPES.
For example: the template objects populate values of 'mob_location',
'repeat_location' etc for Mob
_generate_description(): Generates the text description using the template ojects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("Spawn", template, template_attr=template_attr)
def generate(template=None, template_attr={}):
spawn_obj = Spawn(template, template_attr)
template = spawn_obj.template
spawn_obj.ARG_TYPES = [Mob]
spawn_obj._mob_args = Arguments(
{
"mob_location": None,
"repeat_key": None,
"repeat_location": None,
"template_attr": template_attr,
}
)
# the number of repetitions for Action if any
spawn_obj._repeat_args = Arguments(
{"repeat_key": None, "repeat_count": None, "repeat_dir": None}
)
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
# Append the ARG_TYPE object with arguments, to generate the action tree
spawn_obj.args = [Mob(**spawn_obj._mob_args)]
# Repeat is optional, only add if default values were updated
if spawn_obj._repeat_args.values_updated:
spawn_obj.ARG_TYPES.append(Repeat)
spawn_obj.args.append(Repeat(**spawn_obj._repeat_args))
return spawn_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
for key in templ:
# get the text form from template object.
item = key.generate_description(arg_index=0, templ_index=j)
if not item:
continue
# Flatten if nested dict.
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Freebuild(ActionNode):
"""The Freebuild action uses the model to finish a block object that is half finished.
The action takes a BlockObject.
__init__(): Picks a template from freebuild_templates.py.
generate(): Instantiate the template_objects in the template that populate the
child arguments for classes in ARG_TYPES.
For example: the template objects populate values of 'block_object_type',
'block_object_attributes' etc for BlockObject
_generate_description(): Generates the text description using the template ojects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("Freebuild", template, template_attr=template_attr)
def generate(template=None, template_attr={}):
freebuild_obj = Freebuild(template, template_attr)
template = freebuild_obj.template
freebuild_obj.ARG_TYPES = []
freebuild_obj._no_children = False
freebuild_obj._only_location = False # If the object only has location
freebuild_obj._block_obj_args = Arguments(
{
"block_object_type": Object,
"block_object_attributes": [],
"block_object_location": False,
"no_child": False,
"repeat_key": None,
"repeat_no_child": None,
"repeat_location": None,
"coref_type": None,
"template_attr": template_attr,
}
)
freebuild_obj._location_args = Arguments(
{
"location_type": "ANY",
"relative_direction": False,
"steps": None,
"coref_resolve": None,
"template_attr": template_attr,
}
)
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
# Append the ARG_TYPE object with arguments, to generate the action tree
freebuild_obj.args = []
if not freebuild_obj._only_location:
freebuild_obj.ARG_TYPES.append(BlockObject)
freebuild_obj.args.append(BlockObject(**freebuild_obj._block_obj_args))
# Location is optional, only add if the default arguments were changed.
if freebuild_obj._location_args.values_updated:
freebuild_obj.ARG_TYPES.append(Location)
freebuild_obj.args.append(Location(**freebuild_obj._location_args))
return freebuild_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
for key in templ:
arg_index = 0
item = key.generate_description(arg_index=arg_index, templ_index=j)
if not item:
continue
# flatten if nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Dance(ActionNode):
"""The Dance action represents dancing/ moving in a defined way.
The action takes an optional Location.
__init__(): Picks a template from dance_templates.py.
generate(): Instantiate the template_objects in the template that populate the
child arguments for classes in ARG_TYPES.
For example: the template objects populate values of 'location_type',
'relative_direction' etc for Location
_generate_description(): Generates the text description using the template ojects.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("Dance", template, template_attr=template_attr)
def generate(template=None, template_attr={}):
dance_obj = Dance(template, template_attr)
template = dance_obj.template
dance_obj.ARG_TYPES = []
dance_obj._no_children = False # no ARG_TYPE if _no_children is True
dance_obj._location_args = Arguments(
{
"location_type": "ANY",
"relative_direction": False,
"steps": None,
"coref_resolve": None,
"relative_direction_value": None,
"template_attr": template_attr,
}
)
dance_obj._condition_args = Arguments({"condition_type": None, "block_type": None})
# the number of repetitions for Action if any
dance_obj._repeat_args = Arguments(
{"repeat_key": None, "repeat_count": None, "repeat_dir": None}
)
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
# Append the ARG_TYPE object with arguments, to generate the action tree
dance_obj.args = []
if dance_obj._no_children:
return dance_obj
if dance_obj._location_args.values_updated:
dance_obj.ARG_TYPES.append(Location)
dance_obj.args.append(Location(**dance_obj._location_args))
# StopCondition is optional, only add if the default arguments were changed.
if dance_obj._condition_args.values_updated:
dance_obj.ARG_TYPES.append(StopCondition)
dance_obj.args.append(StopCondition(**dance_obj._condition_args))
# Repeat is optional, only add if default values were updated
if dance_obj._repeat_args.values_updated:
dance_obj.ARG_TYPES.append(Repeat)
dance_obj.args.append(Repeat(**dance_obj._repeat_args))
return dance_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
for i, key in enumerate(templ):
key_type = type(key)
arg_index = 0
# arg_index 1 for StopCondition
if (key_type in CONDIITON_TEMPLATES) and (len(self.args) > 1):
arg_index = 1
# get the text from template object
item = key.generate_description(arg_index=arg_index, index=i, templ_index=j)
if not item:
continue
# flatten nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Stop(ActionNode):
"""Stop action takes no arguments, and only has a description.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("Stop", template, template_attr=template_attr)
def generate(template=None, template_attr={}):
stop_obj = Stop(template, template_attr)
template = stop_obj.template
stop_obj.ARG_TYPES = []
stop_obj._no_children = False # no ARG_TYPE if _no_children is True
stop_obj.target_action_type = None # name of action to be undone
stop_obj.args = []
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
return stop_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
arg_index = 0
for i, key in enumerate(templ):
item = None
item = key.generate_description(arg_index=arg_index, index=i, templ_index=j)
if not item:
continue
# flatten nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Resume(ActionNode):
"""Resume action takes no arguments and only has a description.
"""
def __init__(self, template=None, template_attr={}):
super().__init__("Resume", template, template_attr=template_attr)
def generate(template=None, template_attr={}):
resume_obj = Resume(template, template_attr)
template = resume_obj.template
resume_obj.ARG_TYPES = []
resume_obj._no_children = False # no ARG_TYPE if _no_children is True
resume_obj.target_action_type = None # name of action to be undone
resume_obj.args = []
# change default arguments for ARG_TYPE classes using the template_objects.
for j, templ in enumerate(template):
for i, t in enumerate(templ):
if type(t) != str:
if callable(getattr(t, "add_generate_args", None)):
t.add_generate_args(index=i, templ_index=j)
return resume_obj
def _generate_description(self):
"""get the text form from template object"""
generations = []
for j, templ in enumerate(self.template):
result = []
arg_index = 0
for i, key in enumerate(templ):
item = None
item = key.generate_description(arg_index=arg_index, index=i, templ_index=j)
if not item:
continue
# flatten nested dict
if type(item) in [OrderedDict, dict]:
val_list = list(values_of_nested_dict(item))
result.extend(val_list)
else:
result.append(item)
generations.append(" ".join(result))
return generations
class Noop(ActionNode):
"""Incoming messages which do not correspond to any action are mapped to Noop.
"""
CHATS = ["hello there", "how are you", "great"]
def __init__(self, template_attr={}):
super().__init__("Noop", template_attr=template_attr)
self._is_dialogue = True
def _generate_description(self):
self._word = random.choice(self.CHATS)
return [self._word] # ["human: " + self._word]
| craftassist-master | python/base_agent/ttad/generation_dialogues/generate_data/human_human_dialogue.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import random
from generate_utils import *
from templates.templates import get_template
class ActionNode:
"""This class is an Action Node that represents the "Action" in the action_tree.
A node can have a list of child nodes (ARG_TYPES) or a list of node types, it can be.
(CHOICES).
generate() : is responsible for initializing the ARG_TYPES and CHOICES.
generate_description() : Generates the natural language description.
to_dict() : Generates the action tree recursively using the children.
"""
ARG_TYPES = None # a list of child node types that need to be generated
CHOICES = None # a list of node types that can be substituted for this node
def __init__(self, template_key, template=None, template_attr={}):
self.args = None # populated by self.generate()
self.description = None # populated by self.generate_description()
if template_key != "Noop":
self.template = get_template(template_key, self, template, template_attr)
self._dialogue_type = "human_give_command"
self._replace = None
self._is_dialogue = False
self._d = {}
def generate_description(self):
if self.description is None:
self.description = self._generate_description()
return self.description
@classmethod
def generate(cls, action_type=None, template_attr={}):
if cls.ARG_TYPES:
x = cls(template_attr=template_attr)
x.args = []
for arg in cls.ARG_TYPES:
x.args.append(arg.generate())
return x
if cls.CHOICES:
c = random.choice(action_type) if type(action_type) is list else action_type
return c.generate(template_attr=template_attr)
return cls(template_attr=template_attr)
def __repr__(self):
if self.args:
return "<{} ({})>".format(type(self).__name__, ", ".join(map(str, self.args)))
else:
return "<{}>".format(type(self).__name__)
def to_dict(self):
"""Generates the action dictionary for the sentence"""
action_dict = {}
action_description_split = [x.split() for x in self.description]
if self.args:
# update the tree recursively.
for arg_type, arg in zip(self.ARG_TYPES, self.args):
# Update the action_description for children to compute spans later
arg._action_description = action_description_split
arg_name = arg_type.__name__
key = to_snake_case(arg_name) # key name in dictionary is snake case
# BlockObject and Mob are "reference_object" in the tree
if arg_name in ["BlockObject", "Mob"]:
key = "reference_object"
action_dict.update({key: arg.to_dict()})
def substitute_with_spans(action_description_split, d):
new_d = {}
for k, v in d.items():
if k.startswith("has"):
new_d[k] = find_span(action_description_split, v)
else:
new_d[k] = v
return new_d
# Prune out unnecessary keys from the tree
for attr, val in self.__dict__.items():
if (
not attr.startswith("_")
and val not in (None, "", {})
and attr not in ["args", "description", "template", "ARG_TYPES"]
):
action_dict[attr] = val
# for schematic key in Dig and reference_object in Fill
if attr in ["schematic", "reference_object"]:
updated_val = substitute_with_spans(action_description_split, val)
action_dict[attr] = updated_val
# Spans for keys : 'has_*' and repeat_count
if (attr.startswith("has_")) or (
attr in ["repeat_count", "dance_type_name", "target_action_type"]
):
span = find_span(action_description_split, val)
action_dict[attr] = span
if attr == "dance_type_name":
action_dict["dance_type"] = {attr: action_dict[attr]}
action_dict.pop(attr)
action_name = type(self).__name__
# For single word commands, add a blank block_object for Copy's tree
if (action_name == "Copy") and ("reference_object" not in action_dict):
action_dict["reference_object"] = {}
# Copy is represented as a 'Build' action in the tree
if action_name == "Copy":
action_name = "Build"
# Assign dialogue_type for classes that are dialogues
if self._is_dialogue:
self._dialogue_type = action_name
# Assign replace key
if self._replace:
action_dict["replace"] = True
self._d["dialogue_type"] = to_snake_case(self._dialogue_type, case="upper")
# put action as a key for all actions
if self._dialogue_type in ["human_give_command"]:
action_dict["action_type"] = to_snake_case(action_name, case="upper")
# move location inside reference_object for Fill action
if action_name == "Fill":
if "location" in action_dict:
if "reference_object" not in action_dict:
action_dict["reference_object"] = {}
action_dict["reference_object"]["location"] = action_dict["location"]
action_dict.pop("location")
# fix reference object at action level
if "reference_object" in action_dict:
new_dict = {}
val = action_dict["reference_object"]
if "repeat" in val:
new_dict["repeat"] = val["repeat"]
val.pop("repeat")
if "special_reference" in val:
new_dict["special_reference"] = val["special_reference"]
val.pop("special_reference")
new_dict["filters"] = val
action_dict["reference_object"] = new_dict
if "action_sequence" in self._d:
self._d["action_sequence"].append(action_dict)
else:
self._d["action_sequence"] = [action_dict]
else:
self._d.update(action_dict)
return self._d
| craftassist-master | python/base_agent/ttad/generation_dialogues/generate_data/action_node.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
'''
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Undo templates are written for an action name and represents the intent
for the action: Undo. This action represents reverting something that has been
done before.
Examples:
[Human, Undo]
- undo last action
- undo what you just did
[Human, Undo, UndoActionBuild]
- undo what you just built
- undo the build action
'''
from template_objects import *
UNDO_TEMPLATES = [
[Human, Undo],
## Undo action name ##
[Human, Undo, ActionBuild],
[Human, Undo, ActionDestroy],
[Human, ActionTag],
[Human, Undo, ActionFill],
[Human, Undo, ActionDig]
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/undo_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
'''
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Stop templates are written for an action name and represents the intent
for the action: Stop. This action represents stopping an action
Examples:
[Human, StopSingle]
- Stop
- pause
[Human, Stop, ActionBuild]
- Stop building
'''
from template_objects import *
STOP_TEMPLATES = [
[Human, StopSingle],
## Stop action name ##
[Human, Stop, ActionBuild],
[Human, Stop, ActionDestroy],
[Human, Stop, ActionTag],
[Human, Stop, ActionFill],
[Human, Stop, ActionDig],
[Human, Stop, ActionMove],
## Dont do action ##
[Human, Dont, ActionBuild],
[Human, Dont, ActionDestroy],
[Human, Dont, ActionTag],
[Human, Dont, ActionFill],
[Human, Dont, ActionDig],
[Human, Dont, ActionMove],
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/stop_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
'''
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Spawn templates are written for a MobName and represent the intent
for the action: Spawn.
Examples:
[Human, Spawn, MobName]
- spawn a pig.
- spawn sheep
[Human, Spawn, RepeatCount, MobName]
- Spawn five pigs
- Spawn a few sheep
etc
'''
from template_objects import *
SPAWN_TEMPLATES = [
## Spawn mob ##
[Human, Spawn, MobName],
## Spawn mob on the ground ##
[Human, Spawn, MobName, OnGround],
## Spawn n mobs ##
[Human, Spawn, RepeatCount, MobName],
## Spawn mob n times ##
[Human, Spawn, MobName, NTimes]
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/spawn_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
'''
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Fill templates are written for a Location and represents the intent
for the action: Fill. This action intends to fill a hole or a negative shape
at a certain location.
Examples:
[Human, Fill, The, FillShape]
- fill the hole
- cover up the mine
[Human, Fill, The, FillShape, At, LocationWord, CoordinatesTemplate]
- fill up the hole at location: 2, 3, 4
- cover up the tunnel at: 2, 3, 4
'''
from template_objects import *
FILL_WITH_CORRECTION = [
## Single word command ##
[[Human, Fill],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill],
[HumanReplace, UseFill, FillBlockType]],
## Fill up the shape ##
[[Human, Fill, The, FillShape],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, The, FillShape, Up],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, The, FillShape],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, The, FillShape, Up],
[HumanReplace, UseFill, FillBlockType]],
## Fill shape X at location Y ##
[[Human, Fill, FillObjectThis, FillShape],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, The, FillShape, ThereTemplateCoref],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, The, FillShape, HereTemplate],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, The, FillShape, HereTemplateCoref],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, The, FillShape, YouTemplate],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, FillObjectThis, RepeatCount, FillShape],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, RepeatCount, FillShape, ThereTemplateCoref],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, RepeatCount, FillShape, HereTemplate],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, RepeatCount, FillShape, HereTemplateCoref],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, RepeatCount, FillShape, YouTemplate],
[HumanReplace, The, One, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, RepeatAll, FillShape, ThereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, RepeatAll, FillShape, HereTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, RepeatAll, FillShape, HereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Fill, RepeatAll, FillShape, YouTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
## Fill with X ##
[[Human, Fill, FillObjectThis, FillShape],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, The, FillShape, ThereTemplateCoref],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, The, FillShape, HereTemplate],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, The, FillShape, HereTemplateCoref],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, The, FillShape, YouTemplate],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, FillObjectThis, RepeatCount, FillShape],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, RepeatCount, FillShape, ThereTemplateCoref],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, RepeatCount, FillShape, HereTemplate],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, RepeatCount, FillShape, HereTemplateCoref],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, RepeatCount, FillShape, YouTemplate],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, RepeatAll, FillShape, ThereTemplateCoref],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, RepeatAll, FillShape, HereTemplate],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, RepeatAll, FillShape, HereTemplateCoref],
[HumanReplace, UseFill, FillBlockType]],
[[Human, Fill, RepeatAll, FillShape, YouTemplate],
[HumanReplace, UseFill, FillBlockType]],
## All rel_dir to BlockObject templates ##
## Single word command ##
[[Human, Fill],
[HumanReplace, RelativeDirectionTemplate, BlockObjectThat, Please]],
## Fill up the shape ##
[[Human, Fill, The, FillShape],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, The, FillShape, Up],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
## Fill shape X at location Y ##
[[Human, Fill, FillObjectThis, FillShape],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, The, FillShape, ThereTemplateCoref],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, The, FillShape, HereTemplate],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, The, FillShape, HereTemplateCoref],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, The, FillShape, YouTemplate],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, FillObjectThis, RepeatCount, FillShape],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, RepeatCount, FillShape, ThereTemplateCoref],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, RepeatCount, FillShape, HereTemplate],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, RepeatCount, FillShape, HereTemplateCoref],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, RepeatCount, FillShape, YouTemplate],
[HumanReplace, The, One, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, RepeatAll, FillShape, ThereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, RepeatAll, FillShape, HereTemplate],
[HumanReplace, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, RepeatAll, FillShape, HereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, BlockObjectThat, Please]],
[[Human, Fill, RepeatAll, FillShape, YouTemplate],
[HumanReplace, RelativeDirectionTemplate, BlockObjectThat, Please]],
]
FILL_TEMPLATES = [
## Single word command ##
[Human, Fill],
[Human, Fill, Using, FillBlockType],
## Fill up the shape ##
[Human, Fill, The, FillShape],
[Human, Fill, The, FillShape, Up],
[Human, Fill, The, FillShape, Using, FillBlockType],
[Human, Fill, The, FillShape, Up, Using, FillBlockType],
## Fill shape X at location Y ##
[Human, Fill, FillObjectThis, FillShape],
[Human, Fill, The, FillShape, At, LocationWord, CoordinatesTemplate],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Fill, The, FillShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Fill, The, FillShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Fill, The, FillShape, ThereTemplate],
[Human, Fill, The, FillShape, ThereTemplateCoref],
[Human, Fill, The, FillShape, HereTemplate],
[Human, Fill, The, FillShape, HereTemplateCoref],
[Human, Fill, The, FillShape, YouTemplate],
[Human, Fill, The, FillShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Fill, The, FillShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Fill, The, FillShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Fill, The, FillShape, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Fill, The, FillShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Fill, The, FillShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Fill, The, FillShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Fill, FillObjectThis, FillShape, Using, FillBlockType],
[Human, Fill, The, FillShape, At, LocationWord, CoordinatesTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, CoordinatesTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationMobTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, ThereTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, ThereTemplateCoref, Using, FillBlockType],
[Human, Fill, The, FillShape, HereTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, HereTemplateCoref, Using, FillBlockType],
[Human, Fill, The, FillShape, YouTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, ALittle, RelativeDirectionTemplate, YouTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, Using, FillBlockType],
[Human, Fill, The, FillShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate, Using, FillBlockType],
## Fill n holes ##
[Human, Fill, FillObjectThis, RepeatCount, FillShape],
[Human, Fill, RepeatCount, FillShape, At, LocationWord, CoordinatesTemplate],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Fill, RepeatCount, FillShape, ThereTemplate],
[Human, Fill, RepeatCount, FillShape, ThereTemplateCoref],
[Human, Fill, RepeatCount, FillShape, HereTemplate],
[Human, Fill, RepeatCount, FillShape, HereTemplateCoref],
[Human, Fill, RepeatCount, FillShape, YouTemplate],
[Human, Fill, RepeatCount, FillShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Fill, RepeatCount, FillShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Fill, RepeatCount, FillShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Fill, RepeatCount, FillShape, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Fill, RepeatCount, FillShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Fill, RepeatCount, FillShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Fill, RepeatCount, FillShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Fill, FillObjectThis, RepeatCount, FillShape, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, At, LocationWord, CoordinatesTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, CoordinatesTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationMobTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, ThereTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, ThereTemplateCoref, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, HereTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, HereTemplateCoref, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, YouTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, ALittle, RelativeDirectionTemplate, YouTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate, Using, FillBlockType],
## Fill a hole near every location X ##
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation, Using, FillBlockType],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation, Using, FillBlockType],
## Fill a hole near n locations X ##
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation, Using, FillBlockType],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation, Using, FillBlockType],
## Fill all holes ##
[Human, Fill, RepeatAll, FillShape, At, LocationWord, CoordinatesTemplate],
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Fill, RepeatAll, FillShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Fill, RepeatAll, FillShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Fill, RepeatAll, FillShape, ThereTemplate],
[Human, Fill, RepeatAll, FillShape],
[Human, Fill, RepeatAll, FillShape, ThereTemplateCoref],
[Human, Fill, RepeatAll, FillShape, HereTemplate],
[Human, Fill, RepeatAll, FillShape, HereTemplateCoref],
[Human, Fill, RepeatAll, FillShape, YouTemplate],
[Human, Fill, RepeatAll, FillShape, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Fill, RepeatAll, FillShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Fill, RepeatAll, FillShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Fill, RepeatAll, FillShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Fill, RepeatAll, FillShape, At, LocationWord, CoordinatesTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, CoordinatesTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, LocationMobTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, ThereTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, ThereTemplateCoref, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, HereTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, HereTemplateCoref, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, YouTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, ALittle, RelativeDirectionTemplate, YouTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate, Using, FillBlockType],
## Fill n holes near m locations X ##
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation, Using, FillBlockType],
## Fill all holes near n locations X ##
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation, Using, FillBlockType],
## Fill n holes near every location X ##
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation, Using, FillBlockType],
# ## All rel_dir to BlockObjectThat templates ##
[Human, Fill, The, FillShape, RelativeDirectionTemplate, BlockObjectThat],
[Human, Fill, The, FillShape, Between, BlockObjectThese],
[Human, Fill, The, FillShape, Between, BlockObjectThose],
[Human, Fill, The, FillShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Fill, The, FillShape, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, BlockObjectThat, Using, FillBlockType],
[Human, Fill, The, FillShape, Between, BlockObjectThese, Using, FillBlockType],
[Human, Fill, The, FillShape, Between, BlockObjectThose, Using, FillBlockType],
[Human, Fill, The, FillShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, Using, FillBlockType],
[Human, Fill, The, FillShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, Using, FillBlockType],
## Fill n holes ##
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, BlockObjectThat],
[Human, Fill, RepeatCount, FillShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Fill, RepeatCount, FillShape, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, BlockObjectThat, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, Using, FillBlockType],
[Human, Fill, RepeatCount, FillShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, Using, FillBlockType],
## Fill a hole near every location X ##
[Human, Fill, The, FillShape, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation, Using, FillBlockType],
## Fill a hole near n locations X ##
[Human, Fill, The, FillShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Fill, The, FillShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation, Using, FillBlockType],
## Fill all holes ##
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, BlockObjectThat],
[Human, Fill, RepeatAll, FillShape, Between, BlockObjectThese],
[Human, Fill, RepeatAll, FillShape, Between, BlockObjectThose],
[Human, Fill, RepeatAll, FillShape, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, BlockObjectThat, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, Between, BlockObjectThese, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, Between, BlockObjectThose, Using, FillBlockType],
[Human, Fill, RepeatAll, FillShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, Using, FillBlockType],
## Fill n holes near m locations X ##
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation, Using, FillBlockType],
## Fill all holes near n locations X ##
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Fill, RepeatAll, FillShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation, Using, FillBlockType],
## Fill n holes near every location X ##
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Fill, RepeatCount, FillShape, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation, Using, FillBlockType]
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/fill_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
'''
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Resume templates are written for an action name and represents the intent
for the action: Resume. This action represents resuming a given or last action.
Examples:
[Human, ResumeSingle]
- resume
- start again
[Human, Resume, ActionBuild]
- resume building
- continue the build action
'''
from template_objects import *
RESUME_TEMPLATES = [
[Human, ResumeSingle],
## Resume action name ##
[Human, Resume, ActionBuild],
[Human, Resume, ActionDestroy],
[Human, Resume, ActionTag],
[Human, Resume, ActionFill],
[Human, Resume, ActionDig],
[Human, Resume, ActionMove],
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/resume_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
'''
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Destroy templates are written only for BlockObject and represent the intent
for the action: Destroy. This action destroys a physical block object.
Examples:
[Human, Destroy, The, Colour, AbstractDescription, BlockObjectLocation]
- destroy the red structure to the left of that grey shape.
- destroy the blue thing at location: 2 , 3, 4
- remove the blue shape there
[Human, Destroy, BlockObjectThat, Size, Colour, AbstractDescription]
- remove that huge red structure
- dig that tiny blue thing
'''
from template_objects import *
DESTROY_WITH_CORRECTION = [
## Destroy this / that X ##
[[Human, Destroy, BlockObjectThat],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectThis],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectIt],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectThat, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectThis, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectThat, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectThis, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
## Destroy the X ##
[[Human, Destroy, The, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, The, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
## Destroy this / that colour X ##
[[Human, Destroy, BlockObjectThat, Colour, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectThis, Colour, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, The, Colour, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectThat, Colour, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectThis, Colour, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, The, Colour, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
# ## Destroy this / that size X ##
[[Human, Destroy, BlockObjectThat, Size, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectThis, Size, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, The, Size, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectThat, Size, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, BlockObjectThis, Size, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Destroy, The, Size, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
]
DESTROY_TEMPLATES = [
## Single word destroy commands ##
[Human, DestroySingle],
## Destroy everything ##
[Human, DestroySingle, RepeatAll],
## Destroy what you built ##
# NOTE: this is only in destroy right now, but can be extended.
[Human, Destroy, BlockObjectCoref],
## Destroy this / that X ##
[Human, Destroy, BlockObjectThat],
[Human, Destroy, BlockObjectThis],
[Human, Destroy, BlockObjectIt],
[Human, Destroy, BlockObjectThat, AbstractDescription],
[Human, Destroy, BlockObjectThis, AbstractDescription],
[Human, Destroy, BlockObjectThat, ConcreteDescription],
[Human, Destroy, BlockObjectThis, ConcreteDescription],
## Destroy the X ##
[Human, Destroy, The, AbstractDescription],
[Human, Destroy, The, ConcreteDescription],
[Human, Destroy, AbstractDescription],
[Human, Destroy, ConcreteDescription],
## Destroy the X at location Y ##
[Human, Destroy, The, AbstractDescription, BlockObjectLocation],
[Human, Destroy, The, ConcreteDescription, BlockObjectLocation],
## Destroy this / that colour X ##
[Human, Destroy, BlockObjectThat, Colour, AbstractDescription],
[Human, Destroy, BlockObjectThis, Colour, AbstractDescription],
[Human, Destroy, The, Colour, AbstractDescription],
[Human, Destroy, BlockObjectThat, Colour, ConcreteDescription],
[Human, Destroy, BlockObjectThis, Colour, ConcreteDescription],
[Human, Destroy, The, Colour, ConcreteDescription],
## Destroy this / that colour X ##
[Human, Destroy, BlockObjectThat, Size, AbstractDescription],
[Human, Destroy, BlockObjectThis, Size, AbstractDescription],
[Human, Destroy, The, Size, AbstractDescription],
[Human, Destroy, BlockObjectThat, Size, ConcreteDescription],
[Human, Destroy, BlockObjectThis, Size, ConcreteDescription],
[Human, Destroy, The, Size, ConcreteDescription],
## Destroy the size X at location Y ##
[Human, Destroy, The, Size, AbstractDescription, BlockObjectLocation],
[Human, Destroy, The, Size, ConcreteDescription, BlockObjectLocation],
## Destroy the colour X at location Y ##
[Human, Destroy, The, Colour, AbstractDescription, BlockObjectLocation],
[Human, Destroy, The, Colour, ConcreteDescription, BlockObjectLocation],
## Destroy the size colour X ##
[Human, Destroy, BlockObjectThat, Size, Colour, AbstractDescription],
[Human, Destroy, BlockObjectThis, Size, Colour, AbstractDescription],
[Human, Destroy, The, Size, Colour, AbstractDescription],
[Human, Destroy, BlockObjectThat, Size, Colour, ConcreteDescription],
[Human, Destroy, BlockObjectThis, Size, Colour, ConcreteDescription],
[Human, Destroy, The, Size, Colour, ConcreteDescription],
## Destroy the size colour X at location Y ##
[Human, Destroy, The, Size, Colour, AbstractDescription, BlockObjectLocation],
[Human, Destroy, The, Size, Colour, ConcreteDescription, BlockObjectLocation],
## Destroy num X ##
[Human, Destroy, RepeatCount, AbstractDescription],
[Human, Destroy, RepeatCount, ConcreteDescription],
## Destroy num colour X ##
[Human, Destroy, RepeatCount, Colour, AbstractDescription],
[Human, Destroy, RepeatCount, Colour, ConcreteDescription],
## Destroy num size X ##
[Human, Destroy, RepeatCount, Size, AbstractDescription],
[Human, Destroy, RepeatCount, Size, ConcreteDescription],
## Destroy num size colour X ##
[Human, Destroy, RepeatCount, Size, Colour, AbstractDescription],
[Human, Destroy, RepeatCount, Size, Colour, ConcreteDescription],
## Destroy num size X at location Y ##
[Human, Destroy, RepeatCount, Size, AbstractDescription, BlockObjectLocation],
[Human, Destroy, RepeatCount, Size, ConcreteDescription, BlockObjectLocation],
## Destroy num colour X at location Y ##
[Human, Destroy, RepeatCount, Colour, AbstractDescription, BlockObjectLocation],
[Human, Destroy, RepeatCount, Colour, ConcreteDescription, BlockObjectLocation],
## Destroy num size colour X at location Y ##
[Human, Destroy, RepeatCount, Size, Colour, AbstractDescription, BlockObjectLocation],
[Human, Destroy, RepeatCount, Size, Colour, ConcreteDescription, BlockObjectLocation],
### Destroy X at locations Y ###
[Human, Destroy, The, AbstractDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, The, ConcreteDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, The, Size, AbstractDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, The, Size, ConcreteDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, The, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, The, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, The, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, The, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation],
### Destroy num X at locations Y ###
[Human, Destroy, RepeatCount, AbstractDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, RepeatCount, ConcreteDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, RepeatCount, Size, AbstractDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, RepeatCount, Size, ConcreteDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, RepeatCount, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, RepeatCount, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, RepeatCount, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation],
[Human, Destroy, RepeatCount, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation],
### Destroy all X at location Y ###
[Human, Destroy, All, AbstractDescription, RepeatAll],
[Human, Destroy, Every, AbstractDescription, RepeatAll],
[Human, Destroy, All, ConcreteDescription, RepeatAll],
[Human, Destroy, Every, ConcreteDescription, RepeatAll],
[Human, Destroy, All, Colour, ConcreteDescription, RepeatAll],
[Human, Destroy, Every, Colour, ConcreteDescription, RepeatAll],
[Human, Destroy, All, Colour, AbstractDescription, RepeatAll],
[Human, Destroy, Every, Colour, AbstractDescription, RepeatAll],
[Human, Destroy, All, Size, AbstractDescription, RepeatAll],
[Human, Destroy, Every, Size, AbstractDescription, RepeatAll],
[Human, Destroy, All, Size, ConcreteDescription, RepeatAll],
[Human, Destroy, Every, Size, ConcreteDescription, RepeatAll],
[Human, Destroy, All, Size, AbstractDescription, BlockObjectLocation, RepeatAll],
[Human, Destroy, All, Size, ConcreteDescription, BlockObjectLocation, RepeatAll],
[Human, Destroy, Every, Size, AbstractDescription, BlockObjectLocation, RepeatAll],
[Human, Destroy, Every, Size, ConcreteDescription, BlockObjectLocation, RepeatAll],
[Human, Destroy, All, Colour, AbstractDescription, BlockObjectLocation, RepeatAll],
[Human, Destroy, All, Colour, ConcreteDescription, BlockObjectLocation, RepeatAll],
[Human, Destroy, Every, Colour, AbstractDescription, BlockObjectLocation, RepeatAll],
[Human, Destroy, Every, Colour, ConcreteDescription, BlockObjectLocation, RepeatAll],
[Human, Destroy, All, Size, Colour, AbstractDescription, RepeatAll],
[Human, Destroy, Every, Size, Colour, AbstractDescription, RepeatAll],
[Human, Destroy, All, Size, Colour, ConcreteDescription, RepeatAll],
[Human, Destroy, Every, Size, Colour, ConcreteDescription, RepeatAll],
[Human, Destroy, All, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAll],
[Human, Destroy, All, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAll],
[Human, Destroy, Every, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAll],
[Human, Destroy, Every, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAll],
## Destroy X at every location Y ##
[Human, Destroy, The, AbstractDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, The, ConcreteDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, The, Size, AbstractDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, The, Size, ConcreteDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, The, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, The, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, The, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, The, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation],
### Destroy all X at every location Y ###
[Human, Destroy, All, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, All, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, Every, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, Every, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, All, Size, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, All, Size, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, Every, Size, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, Every, Size, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, All, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, All, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, Every, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, Every, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, All, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, All, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, Every, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
[Human, Destroy, Every, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll],
### Destroy all X at locations Ys ###
[Human, Destroy, All, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, All, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, Every, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, Every, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, All, Size, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, All, Size, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, Every, Size, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, Every, Size, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, All, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, All, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, Every, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, Every, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, All, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, All, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, Every, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
[Human, Destroy, Every, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll],
### Destroy n X at every location Y ###
[Human, Destroy, RepeatCount, AbstractDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, RepeatCount, ConcreteDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, RepeatCount, Size, AbstractDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, RepeatCount, Size, ConcreteDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, RepeatCount, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, RepeatCount, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, RepeatCount, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation],
[Human, Destroy, RepeatCount, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation],
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/destroy_templates.py |
import os
import sys
sys.path.append(os.path.dirname(__file__))
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/__init__.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
"""This file picks a template for a given action, at random.
The templates use template_objects as their children to help construct a sentence
and the dictionary.
TemplateObject is defined in template_objects.py
Each template captures how to phrase the intent. The intent is defined by the action
type.
"""
import copy
import random
from template_objects import *
from build_templates import *
from move_templates import *
from dig_templates import *
from destroy_templates import *
from copy_templates import *
from undo_templates import *
from fill_templates import *
from spawn_templates import *
from freebuild_templates import *
from dance_templates import *
from get_memory_templates import *
from put_memory_templates import *
from stop_templates import *
from resume_templates import *
template_map = {
"Move": [MOVE_TEMPLATES, MOVE_WITH_CORRECTION],
"Build": [BUILD_TEMPLATES, BUILD_WITH_CORRECTION, BUILD_INBUILT_COMPOSITE],
"Destroy": [DESTROY_TEMPLATES, DESTROY_WITH_CORRECTION],
"Dig": [DIG_TEMPLATES, DIG_WITH_CORRECTION],
"Copy": [COPY_TEMPLATES, COPY_WITH_CORRECTION],
"Undo": [UNDO_TEMPLATES],
"Fill": [FILL_TEMPLATES, FILL_WITH_CORRECTION],
"Spawn": [SPAWN_TEMPLATES],
"Freebuild": [FREEBUILD_TEMPLATES, FREEBUILD_WITH_CORRECTION],
"Dance": [DANCE_TEMPLATES, DANCE_WITH_CORRECTION],
"GetMemory": [GET_MEMORY_TEMPLATES, ANSWER_WITH_CORRECTION],
"PutMemory": [PUT_MEMORY_TEMPLATES, TAG_WITH_CORRECTION],
"Stop": [STOP_TEMPLATES],
"Resume": [RESUME_TEMPLATES],
}
def get_template(template_key, node, template=None, template_attr={}):
"""Pick a random template, given the action."""
template_name = template_map[template_key] # this will be a list right now
if template_attr.get("dialogue_len", 0) == 1:
template_name = template_name[0]
elif template_attr.get("no_inbuilt_composites", False) == True and len(template_name) == 3:
templates = []
template_name = template_name[:2]
for template_type in template_name:
templates += template_type
template_name = templates
else:
templates = []
for template_type in template_name:
templates += template_type
template_name = templates
if template is None:
template = random.choice(template_name)
template = copy.deepcopy(template)
if not any(isinstance(i, list) for i in template):
template = [template]
for i, t in enumerate(template):
for j, templ in enumerate(t):
if type(templ) != str:
template[i][j] = templ(node=node, template_attr=template_attr)
return template
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
"""
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Build templates are written for Schematics and may have a Location,
and represent the intent for the action: Build.
This action builds a known Schematic (a shape or CategoryObject).
Examples:
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate]
- out of acacia build a cube at location 3, 2, 1
- out of acacia wood construct a cube of size 5 at location 5 6 7
- make a cube of size 10 at location ( 1 , 2, 3 )
[Human, Near, LocationMobTemplate, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType]
- near the spider build a dome of radius 4 using gravel.
- near the spider make a dome.
- near the spider assemble a dome using gravel.
"""
from template_objects import *
BUILD_INBUILT_COMPOSITE = [
[Human, Build, DescribingWord, AndBuild],
]
BUILD_WITH_CORRECTION = [
## Single word Build command ##
[[Human, BuildSingle],
[HumanReplace, Use, UsingBlockType]],
## Build at location X ##
[[Human, BuildSingle, At, LocationWord, CoordinatesTemplate],
[HumanReplace, Use, UsingBlockType]],
[[Human, BuildSingle, RelativeDirectionTemplate, CoordinatesTemplate],
[HumanReplace, Use, UsingBlockType]],
[[Human, BuildSingle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[HumanReplace, Use, UsingBlockType]],
[[Human, BuildSingle, RelativeDirectionTemplate, LocationMobTemplate],
[HumanReplace, Use, UsingBlockType]],
[[Human, BuildSingle, ThereTemplate],
[HumanReplace, Use, UsingBlockType]],
[[Human, BuildSingle, ThereTemplateCoref],
[HumanReplace, Use, UsingBlockType]],
[[Human, BuildSingle, HereTemplate],
[HumanReplace, Use, UsingBlockType]],
[[Human, BuildSingle, HereTemplateCoref],
[HumanReplace, Use, UsingBlockType]],
[[Human, BuildSingle, YouTemplate],
[HumanReplace, Use, UsingBlockType]],
## Build using block type X at location Y ##
[[Human, BuildSingle, MadeOutOf, UsingBlockType],
[HumanReplace, Build, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, BuildSingle, MadeOutOf, UsingBlockType, ThereTemplate],
[HumanReplace, Build, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, BuildSingle, MadeOutOf, UsingBlockType, ThereTemplateCoref],
[HumanReplace, Build, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, BuildSingle, MadeOutOf, UsingBlockType, HereTemplate],
[HumanReplace, Build, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, BuildSingle, MadeOutOf, UsingBlockType, HereTemplateCoref],
[HumanReplace, Build, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, BuildSingle, MadeOutOf, UsingBlockType, YouTemplate],
[HumanReplace, Build, RelativeDirectionTemplate, LocationMobTemplate]],
## Build at every location Y ##
[[Human, BuildSingle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[HumanReplace, Use, UsingBlockType]],
[[Human, BuildSingle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[HumanReplace, Use, UsingBlockType]],
## Build at n locations Y ##
[[Human, BuildSingle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[HumanReplace, Use, UsingBlockType]],
[[Human, BuildSingle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[HumanReplace, Use, UsingBlockType]],
## Stack N blocks at location Y ##
[[Human, Stack, RepeatCount, DescribingWord],
[HumanReplace, Use, UsingBlockType]],
[[Human, Stack, RepeatCount, DescribingWord],
[HumanReplace, Build, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Place, RepeatCount, DescribingWord, InARow],
[HumanReplace, Use, UsingBlockType]],
[[Human, Place, RepeatCount, DescribingWord, InARow],
[HumanReplace, Build, RelativeDirectionTemplate, LocationMobTemplate]],
## templates for rel_dir of BlockObjectThat ##
[[Human, BuildSingle, RelativeDirectionTemplate, BlockObjectThat],
[HumanReplace, Use, UsingBlockType]],
## Build using block type X at location Y ##
[[Human, BuildSingle, MadeOutOf, UsingBlockType],
[HumanReplace, Build, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, BuildSingle, MadeOutOf, UsingBlockType, ThereTemplate],
[HumanReplace, Build, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, BuildSingle, MadeOutOf, UsingBlockType, ThereTemplateCoref],
[HumanReplace, Build, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, BuildSingle, MadeOutOf, UsingBlockType, HereTemplate],
[HumanReplace, Build, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, BuildSingle, MadeOutOf, UsingBlockType, HereTemplateCoref],
[HumanReplace, Build, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, BuildSingle, MadeOutOf, UsingBlockType, YouTemplate],
[HumanReplace, Build, RelativeDirectionTemplate, BlockObjectThat]],
## Build at every location Y ##
[[Human, BuildSingle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[HumanReplace, Use, UsingBlockType]],
## Build at n locations Y ##
[[Human, BuildSingle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[HumanReplace, Use, UsingBlockType]],
## Stack N blocks at location Y ##
[[Human, Stack, RepeatCount, DescribingWord],
[HumanReplace, Build, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Place, RepeatCount, DescribingWord, InARow],
[HumanReplace, Build, RelativeDirectionTemplate, BlockObjectThat]],
]
BUILD_TEMPLATES = [
## Single word Build command ##
[Human, BuildSingle],
## Build at location X ##
[Human, BuildSingle, At, LocationWord, CoordinatesTemplate],
[Human, BuildSingle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, BuildSingle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, BuildSingle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, BuildSingle, ThereTemplate],
[Human, BuildSingle, ThereTemplateCoref],
[Human, BuildSingle, HereTemplateCoref],
[Human, BuildSingle, HereTemplate],
[Human, BuildSingle, YouTemplate],
## Build using block type X at location Y ##
[Human, BuildSingle, MadeOutOf, UsingBlockType],
[Human, BuildSingle, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate],
[Human, BuildSingle, MadeOutOf, UsingBlockType, ThereTemplate],
[Human, BuildSingle, MadeOutOf, UsingBlockType, ThereTemplateCoref],
[Human, BuildSingle, MadeOutOf, UsingBlockType, HereTemplate],
[Human, BuildSingle, MadeOutOf, UsingBlockType, HereTemplateCoref],
[Human, BuildSingle, MadeOutOf, UsingBlockType, YouTemplate],
## Build at every location Y ##
[Human, BuildSingle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, BuildSingle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Build at n locations Y ##
[Human, BuildSingle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, BuildSingle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
## Single word shape name for Build ##
[Human, BuildShape],
## Surround X with Y ##
[Human, Surround, LocationBlockObjectTemplate, SurroundWith, DescribingWord],
[Human, Surround, LocationMobTemplate, SurroundWith, DescribingWord],
[Human, Surround, BlockObjectThat, SurroundWith, DescribingWord],
## Stack N blocks at location Y ##
[Human, Stack, RepeatCount, DescribingWord],
[Human, Stack, RepeatCount, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Stack, RepeatCount, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Stack, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Stack, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Stack, RepeatCount, DescribingWord, ThereTemplate],
[Human, Stack, RepeatCount, DescribingWord, ThereTemplateCoref],
[Human, Stack, RepeatCount, DescribingWord, HereTemplateCoref],
[Human, Stack, RepeatCount, DescribingWord, HereTemplate],
[Human, Stack, RepeatCount, DescribingWord, YouTemplate],
[Human, Stack, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Stack, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Stack, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Stack, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Stack, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Stack, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Stack, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Stack N blocks at every location Y ##
[Human, Stack, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Stack, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Stack, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Stack, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Stack, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Stack, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Stack N blocks at M locations Y ##
[Human, Stack, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Stack, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Stack, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Stack, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Stack, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Stack, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
## Place N blocks in a row at location Y ##
[Human, Place, RepeatCount, DescribingWord, InARow],
[Human, Place, RepeatCount, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Place, RepeatCount, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Place, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Place, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Place, RepeatCount, DescribingWord, ThereTemplate],
[Human, Place, RepeatCount, DescribingWord, ThereTemplateCoref],
[Human, Place, RepeatCount, DescribingWord, HereTemplateCoref],
[Human, Place, RepeatCount, DescribingWord, HereTemplate],
[Human, Place, RepeatCount, DescribingWord, YouTemplate],
[Human, Place, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Place, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Place, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Place, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Place, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Place, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Place, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Place N blocks at every location Y ##
[Human, Place, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Place N blocks in a row at location Y ##
[Human, Place, RepeatCount, DescribingWord, InARow, At, LocationWord, CoordinatesTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, At, LocationWord, CoordinatesTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, ThereTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, ThereTemplateCoref],
[Human, Place, RepeatCount, DescribingWord, InARow, HereTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, HereTemplateCoref],
[Human, Place, RepeatCount, DescribingWord, InARow, YouTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Place N blocks in a row at every location Y ##
[Human, Place, RepeatCount, DescribingWord, InARow, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Build X out of Y with size ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
## Build N X out of Y with size ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
## Build n by m X with other size attributes like thickness etc ##
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes],
## Build wall X blocks long and Y blocks high ##
[Human, Build, Wall, NumBlocks, Squares, Long, And, NumBlocks, Squares, High],
[Human, Build, Wall, NumBlocks, Squares, High, And, NumBlocks, Squares, Long],
[Human, Build, Wall, NumBlocks, Squares, Long, NumBlocks, Squares, High],
[Human, Build, Wall, NumBlocks, Squares, High, NumBlocks, Squares, Long],
## Build N walls X blocks long and Y blocks high ##
[Human, Build, RepeatCount, Wall, NumBlocks, Squares, Long, And, NumBlocks, Squares, High],
[Human, Build, RepeatCount, Wall, NumBlocks, Squares, High, And, NumBlocks, Squares, Long],
[Human, Build, RepeatCount, Wall, NumBlocks, Squares, Long, NumBlocks, Squares, High],
[Human, Build, RepeatCount, Wall, NumBlocks, Squares, High, NumBlocks, Squares, Long],
## Build X blocks long and Y blocks high wall ##
[Human, Build, NumBlocks, Squares, Long, And, NumBlocks, Squares, High, Wall],
[Human, Build, NumBlocks, Squares, High, And, NumBlocks, Squares, Long, Wall],
[Human, Build, NumBlocks, Squares, Long, NumBlocks, Squares, High, Wall],
[Human, Build, NumBlocks, Squares, High, NumBlocks, Squares, Long, Wall],
## Build n by m X using block type Y with size attributes ##
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
## Build N n by m Xs using block type Y with size attributes ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
## Build X of size Y using block type Z ##
[Human, Build, UsingBlockType, DescribingWord, WithAttributes],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
## Build n by m of size Y using block type Z ##
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
## out of X build Y ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord],
[Human, MadeOutOf, UsingBlockType, Build, SchematicSize, DescribingWord],
## Build X out of block type Y ##
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType],
## Build n Xs with size Y out of block type Z ##
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
## Out of X build n Ys ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicSize, DescribingWord],
## Build N Xs out of Y ##
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType],
## Build X with size Y ##
[Human, Build, DescribingWord, WithAttributes],
[Human, Build, SchematicColour, DescribingWord, WithAttributes],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, Build, SchematicsDimensions, SchematicColour, DescribingWord, WithAttributes],
## Build X n times ###
[Human, Build, DescribingWord, NTimes],
[Human, Build, SchematicSize, DescribingWord, NTimes],
[Human, Build, SchematicColour, DescribingWord, NTimes],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, NTimes],
# Build size colour X ##
[Human, Build, DescribingWord],
[Human, Build, SchematicSize, DescribingWord],
[Human, Build, SchematicColour, DescribingWord],
[Human, Build, SchematicSize, SchematicColour, DescribingWord],
## Build a block type X Y ##
[Human, Build, UsingBlockType, DescribingWord],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord],
## Build N X of size Y ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, WithAttributes],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, Build, RepeatCount, SchematicsDimensions, SchematicColour, DescribingWord, WithAttributes],
## Build N X ##
[Human, Build, RepeatCount, DescribingWord],
[Human, Build, RepeatCount, SchematicSize, DescribingWord],
[Human, Build, RepeatCount, SchematicColour, DescribingWord],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord],
## Build N block type X Y ##
[Human, Build, RepeatCount, UsingBlockType, DescribingWord],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord],
## Out of X build Y with size Z at location A ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ThereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, HereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Out of X build Y with size Z at every location A ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Out of C build a by b X with size Y at location Z ##
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ThereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, HereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Out of C build a by b X with size Y at every location Z ##
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Out of X build N Ys with size Z at location A ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ThereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, HereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Out of X build N Ys with size Z at every location A ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Out of X build N a by b Ys with size Z at location A ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ThereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, HereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Out of X build N a by b Ys with size Z at every location A ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Out of X build Y at location Z ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicSize, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
## Build X of size Y at location Z ##
[Human, Build, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, SchematicColour, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, SchematicColour, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
## Build X at location Y ##
[Human, Build, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, SchematicSize, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, SchematicColour, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
## Out of X build N Ys at location Z ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicSize, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ThereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ThereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, HereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, HereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Out of X build Y at location Z ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ThereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ThereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, HereTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, HereTemplateCoref],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Out of X build Y at every location Z ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Build N Ys with size X at location Z ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, SchematicColour, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
## Build N Y with size X at every location Z ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Build X with size Y at every location Z ##
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Build X with size Y at location Z ##
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, WithAttributes, ThereTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ThereTemplate],
[Human, Build, DescribingWord, ThereTemplate],
[Human, Build, SchematicSize, DescribingWord, ThereTemplate],
[Human, Build, SchematicColour, DescribingWord, ThereTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ThereTemplate],
[Human, Build, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, Build, DescribingWord, ThereTemplateCoref],
[Human, Build, SchematicSize, DescribingWord, ThereTemplateCoref],
[Human, Build, SchematicColour, DescribingWord, ThereTemplateCoref],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ThereTemplateCoref],
[Human, Build, DescribingWord, WithAttributes, HereTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, HereTemplate],
[Human, Build, DescribingWord, HereTemplate],
[Human, Build, SchematicSize, DescribingWord, HereTemplate],
[Human, Build, SchematicColour, DescribingWord, HereTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, HereTemplate],
[Human, Build, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, Build, DescribingWord, HereTemplateCoref],
[Human, Build, SchematicSize, DescribingWord, HereTemplateCoref],
[Human, Build, SchematicColour, DescribingWord, HereTemplateCoref],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, HereTemplateCoref],
[Human, Build, DescribingWord, WithAttributes, YouTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, YouTemplate],
[Human, Build, DescribingWord, YouTemplate],
[Human, Build, SchematicSize, DescribingWord, YouTemplate],
[Human, Build, SchematicColour, DescribingWord, YouTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, YouTemplate],
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Build N X with size Y at location Z ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ThereTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ThereTemplate],
[Human, Build, RepeatCount, DescribingWord, ThereTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ThereTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ThereTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ThereTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, Build, RepeatCount, DescribingWord, ThereTemplateCoref],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ThereTemplateCoref],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ThereTemplateCoref],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ThereTemplateCoref],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, HereTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, HereTemplate],
[Human, Build, RepeatCount, DescribingWord, HereTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, HereTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, HereTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, HereTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, Build, RepeatCount, DescribingWord, HereTemplateCoref],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, HereTemplateCoref],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, HereTemplateCoref],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, HereTemplateCoref],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, YouTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, YouTemplate],
[Human, Build, RepeatCount, DescribingWord, YouTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, YouTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, YouTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, YouTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
## Build N X with size Y at every location Z ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## At location Y build X using block type A with size Z ##
[Human, At, LocationWord, CoordinatesTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, DescribingWord, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType],
[Human, At, LocationWord, CoordinatesTemplate, Build, DescribingWord],
[Human, At, LocationWord, CoordinatesTemplate, Build, SchematicSize, DescribingWord],
[Human, At, LocationWord, CoordinatesTemplate, Build, SchematicColour, DescribingWord],
[Human, At, LocationWord, CoordinatesTemplate, Build, SchematicSize, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicSize, DescribingWord],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicSize, SchematicColour, DescribingWord],
## At location X build Y Z with size A ##
[Human, At, LocationWord, CoordinatesTemplate, Build, UsingBlockType, DescribingWord, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, UsingBlockType, DescribingWord],
[Human, At, LocationWord, CoordinatesTemplate, Build, SchematicSize, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicSize, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicSize, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, SchematicSize, UsingBlockType, DescribingWord],
## At location Y build N Xs using block type A with size Z ##
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, DescribingWord, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, DescribingWord],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, SchematicSize, DescribingWord],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, SchematicColour, DescribingWord],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, DescribingWord],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord],
## At every location Y build N Xs out of Z with size A ##
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicColour, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicSize, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicColour, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicSize, SchematicColour, DescribingWord, RepeatAllLocation],
## At location X build Y out of Z with size A ##
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicSize, DescribingWord],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicSize, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, SchematicSize, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, SchematicSize, SchematicColour, DescribingWord],
## At location X build N Ys out of Z with size A ##
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, UsingBlockType, DescribingWord],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicSize, DescribingWord],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, SchematicSize, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord],
## At every location X build N Ys out of Z with size A ##
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicSize, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicColour, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RepeatAllLocation],
## At every location X build Y out of Z with size A ##
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicSize, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicColour, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicSize, SchematicColour, DescribingWord, RepeatAllLocation],
## Build X out of Y with size Z at location A ##
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, At, LocationWord, CoordinatesTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, At, LocationWord, CoordinatesTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ThereTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ThereTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ThereTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ThereTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ThereTemplateCoref],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ThereTemplateCoref],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ThereTemplateCoref],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ThereTemplateCoref],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, HereTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, HereTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, HereTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, HereTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, HereTemplateCoref],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, HereTemplateCoref],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, HereTemplateCoref],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, HereTemplateCoref],
## Build n Xs out of Y with size Z at location A ##
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ThereTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ThereTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ThereTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ThereTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ThereTemplateCoref],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ThereTemplateCoref],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ThereTemplateCoref],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ThereTemplateCoref],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, HereTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, HereTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, HereTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, HereTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, HereTemplateCoref],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, HereTemplateCoref],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, HereTemplateCoref],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, HereTemplateCoref],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, YouTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, YouTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, YouTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, YouTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
## Build n Xs out of Y with size Z at every location A ##
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Build X out of Y with size Z at every location A ##
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Build X out Y with size Z at location A ##
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, YouTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, YouTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, YouTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, YouTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
## build X Y with size Z at location A ##
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, UsingBlockType, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, UsingBlockType, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ThereTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ThereTemplate],
[Human, Build, UsingBlockType, DescribingWord, ThereTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ThereTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, Build, UsingBlockType, DescribingWord, ThereTemplateCoref],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ThereTemplateCoref],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, HereTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, HereTemplate],
[Human, Build, UsingBlockType, DescribingWord, HereTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, HereTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, Build, UsingBlockType, DescribingWord, HereTemplateCoref],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, HereTemplateCoref],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, YouTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, YouTemplate],
[Human, Build, UsingBlockType, DescribingWord, YouTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, YouTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
## At location A build N X Y with size Z ##
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord],
## At every location X build X Y with size Z ##
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, UsingBlockType, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicSize, UsingBlockType, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, UsingBlockType, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicSize, UsingBlockType, DescribingWord, RepeatAllLocation],
## At every location X build n X Ys with size Z ##
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RepeatAllLocation],
## Build N X Y with size Z at location A ##
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
## Build X Y with size Z at every location A ##
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
## Build N X Y with size Z at location A ##
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ThereTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ThereTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ThereTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ThereTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ThereTemplateCoref],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ThereTemplateCoref],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ThereTemplateCoref],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, HereTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, HereTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, HereTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, HereTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, HereTemplateCoref],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, HereTemplateCoref],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, HereTemplateCoref],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, YouTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, YouTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, YouTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, YouTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
## Build N X Y with size Z at every location A ##
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## At location X Build X with size Y out of Z ##
[Human, At, LocationWord, CoordinatesTemplate, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, At, LocationWord, CoordinatesTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
## At location X Build n Xs with size Y out of Z ##
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, At, LocationWord, CoordinatesTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, CoordinatesTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
## At every location X build n Xs with size Y out of Z ##
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatAllLocation],
## Build X with size Y out of Z at location A ##
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, At, LocationWord, CoordinatesTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ThereTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ThereTemplateCoref],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, HereTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, HereTemplateCoref],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, YouTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, At, LocationWord, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ThereTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ThereTemplateCoref],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, HereTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, HereTemplateCoref],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, YouTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
## Build n Xs with size Y out of Z at location A ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ThereTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ThereTemplateCoref],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, HereTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, HereTemplateCoref],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, YouTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, At, LocationWord, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ThereTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ThereTemplateCoref],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, HereTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, HereTemplateCoref],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, YouTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
## Build n Xs with size Y out of Z at every location A ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Build X with size Y out of Z at every location A ##
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
## Place N blocks at n locations X ##
[Human, Place, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
## Out of X build Y with size Z at M locations A (same templates as above with N locations) ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicColour, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicSize, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicColour, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicSize, SchematicColour, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicSize, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicColour, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicSize, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicColour, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicSize, SchematicColour, DescribingWord, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, UsingBlockType, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, UsingBlockType, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicSize, UsingBlockType, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, UsingBlockType, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, UsingBlockType, DescribingWord, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicSize, UsingBlockType, DescribingWord, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, RelativeDirectionTemplate, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
# Build N X Around Y ##
[Human, Build, RepeatCount, DescribingWord, Around, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, Around, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, Around, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Around, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, Around, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, Around, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, Around, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Around, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, Around, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, Around, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, Around, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Around, BlockObjectThat],
## Build Xs around Y ##
[Human, Build, RepeatAll, DescribingWord, Around, LocationBlockObjectTemplate],
[Human, Build, RepeatAll, DescribingWord, WithAttributes, Around, LocationBlockObjectTemplate],
[Human, Build, RepeatAll, DescribingWord, MadeOutOf, UsingBlockType, Around, LocationBlockObjectTemplate],
[Human, Build, RepeatAll, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Around, LocationBlockObjectTemplate],
[Human, Build, RepeatAll, DescribingWord, Around, LocationMobTemplate],
[Human, Build, RepeatAll, DescribingWord, WithAttributes, Around, LocationMobTemplate],
[Human, Build, RepeatAll, DescribingWord, MadeOutOf, UsingBlockType, Around, LocationMobTemplate],
[Human, Build, RepeatAll, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Around, LocationMobTemplate],
[Human, Build, RepeatAll, DescribingWord, Around, BlockObjectThat],
[Human, Build, RepeatAll, DescribingWord, WithAttributes, Around, BlockObjectThat],
[Human, Build, RepeatAll, DescribingWord, MadeOutOf, UsingBlockType, Around, BlockObjectThat],
[Human, Build, RepeatAll, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Around, BlockObjectThat],
## Templates for rel_dir of BlockObjectThat ##
[Human, BuildSingle, RelativeDirectionTemplate, BlockObjectThat],
[Human, BuildSingle, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat],
[Human, BuildSingle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
# Build at n locations Y ##
[Human, BuildSingle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Stack, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Stack, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Stack, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Stack N blocks at every location Y ##
[Human, Stack, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Stack, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Stack, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Stack N blocks at M locations Y ##
[Human, Stack, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Stack, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Stack, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
## Place N blocks in a row at location Y ##
[Human, Place, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Place, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Place, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Place N blocks at every location Y ##
[Human, Place, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Place N blocks in a row at location Y ##
[Human, Place, RepeatCount, DescribingWord, InARow, RelativeDirectionTemplate, BlockObjectThat],
[Human, Place, RepeatCount, DescribingWord, InARow, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Place, RepeatCount, DescribingWord, InARow, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Place N blocks in a row at every location Y ##
[Human, Place, RepeatCount, DescribingWord, InARow, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Out of X build Y with size Z at location A ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Out of X build Y with size Z at every location A ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Out of C build a by b X with size Y at location Z ##
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Out of C build a by b X with size Y at every location Z ##
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Out of X build N Ys with size Z at location A ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Out of X build N Ys with size Z at every location A ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Out of X build N a by b Ys with size Z at location A ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Out of X build N a by b Ys with size Z at every location A ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Out of X build Y at location Z ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
## Build X of size Y at location Z ##
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
## Build X at location Y ##
[Human, Build, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
## Out of X build N Ys at location Z ##
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Out of X build Y at location Z ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Out of X build Y at every location Z ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
## Build N Y with size X at every location Z ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Build X with size Y at every location Z ##
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Build X with size Y at location Z ##
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Build N X with size Y at location Z ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Build N X with size Y at every location Z ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## At location Y build X using block type A with size Z ##
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, DescribingWord, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, DescribingWord],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicSize, DescribingWord],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicSize, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicSize, UsingBlockType, DescribingWord],
## At location Y build N Xs using block type A with size Z ##
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, DescribingWord],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicSize, DescribingWord],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicColour, DescribingWord],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord],
## At every location Y build N Xs out of Z with size A ##
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicSize, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicColour, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicsDimensions, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, DescribingWord, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicSize, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicColour, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicSize, SchematicColour, DescribingWord, RepeatAllLocation],
## At location X build N Ys out of Z with size A ##
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Build n Xs out of Y with size Z at every location A ##
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Build X out of Y with size Z at every location A ##
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Build X out Y with size Z at location A ##
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## At location A build N X Y with size Z ##
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, UsingBlockType, DescribingWord],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord],
## At every location X build X Y with size Z ##
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, UsingBlockType, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicSize, UsingBlockType, DescribingWord, RepeatAllLocation],
## At every location X build n X Ys with size Z ##
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, UsingBlockType, DescribingWord, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Build X Y with size Z at every location A ##
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Build N X Y with size Z at location A ##
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## At location X Build X with size Y out of Z ##
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
## At location X Build n Xs with size Y out of Z ##
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
## At every location X build n Xs with size Y out of Z ##
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, RelativeDirectionTemplate, BlockObjectThat, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Build X with size Y out of Z at location A ##
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Build n Xs with size Y out of Z at location A ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Build n Xs with size Y out of Z at every location A ##
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Build X with size Y out of Z at every location A ##
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Place N blocks at n locations X ##
[Human, Place, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Place, RepeatCount, DescribingWord, InARow, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
## Out of X build Y with size Z at M locations A (same templates as above with N locations) ##
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
# Between templates
[Human, BuildSingle, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, BuildSingle, MadeOutOf, UsingBlockType, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Stack, RepeatCount, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Place, RepeatCount, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicColour, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicColour, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, StepsTemplate, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, UsingBlockType, DescribingWord, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, UsingBlockType, DescribingWord],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, SchematicSize, UsingBlockType, DescribingWord],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, DescribingWord, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, DescribingWord],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, SchematicSize, DescribingWord],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, SchematicColour, DescribingWord],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, SchematicSize, SchematicColour, DescribingWord],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, DescribingWord],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, SchematicColour, DescribingWord],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, UsingBlockType, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, UsingBlockType, DescribingWord],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, BuildSingle, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, BuildSingle, MadeOutOf, UsingBlockType, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Stack, RepeatCount, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Place, RepeatCount, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Place, RepeatCount, DescribingWord, InARow, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicSize, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicColour, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, RepeatCount, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, MadeOutOf, UsingBlockType, Build, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicSize, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicColour, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, DescribingWord, WithAttributes, StepsTemplate, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, StepsTemplate, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, DescribingWord, StepsTemplate, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicSize, DescribingWord, StepsTemplate, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicColour, DescribingWord, StepsTemplate, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicSize, SchematicColour, DescribingWord, StepsTemplate, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicColour, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, UsingBlockType, DescribingWord, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, UsingBlockType, DescribingWord],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, SchematicSize, UsingBlockType, DescribingWord],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, DescribingWord, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, DescribingWord, MadeOutOf, UsingBlockType],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, DescribingWord],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, SchematicSize, DescribingWord],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, SchematicColour, DescribingWord],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, SchematicSize, SchematicColour, DescribingWord],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, DescribingWord, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, DescribingWord],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, SchematicSize, DescribingWord],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, SchematicColour, DescribingWord],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, SchematicSize, SchematicColour, DescribingWord],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, DescribingWord, MadeOutOf, UsingBlockType, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, MadeOutOf, UsingBlockType, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, MadeOutOf, UsingBlockType, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, DescribingWord, MadeOutOf, UsingBlockType, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, UsingBlockType, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, UsingBlockType, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicSize, UsingBlockType, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, UsingBlockType, DescribingWord],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, UsingBlockType, DescribingWord, WithAttributes, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, UsingBlockType, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicSize, UsingBlockType, DescribingWord, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType],
[Human, Build, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Build, RepeatCount, SchematicsDimensions, DescribingWord, WithAttributes, MadeOutOf, UsingBlockType, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/build_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
'''
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Move templates are written with respect to a Location and represent the intent
for the action: Move. This action specifies the location to which the
agent is expected to move to.
Things to note:
- RelativeDirectionTemplate when not followed by something signifies that RelativeDirection
is with respect to the agent / person who you are speaking to.
Examples:
[Move, ALittle, RelativeDirectionTemplate]
- move a bit to your left.
- move a little to the right.
- walk a little to the front.
[Move, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate]
- walk 5 steps to the right of that grey thing
- move fifty two steps to the left of the orange structure
'''
from template_objects import *
MOVE_WITH_CORRECTION = [
# TODO: add between for BlockObjectThese and BlockObjectThose these as well
## Go there, to the rel_dir of the mob ##
[[Human, Move, ThereTemplate],
[HumanReplace, Move, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Move, ThereTemplate],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Move, ThereTemplate],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThis]],
[[Human, Move, ThereTemplateCoref],
[HumanReplace, Move, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Move, ThereTemplateCoref],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Move, ThereTemplateCoref],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThis]],
[[Human, MoveSingle],
[HumanReplace, Move, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, MoveSingle],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, MoveSingle],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThis]],
[[Human, MoveHere],
[HumanReplace, Move, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, MoveHere],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, MoveHere],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThis]],
[[Human, MoveHereCoref],
[HumanReplace, Move, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, MoveHereCoref],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, MoveHereCoref],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThis]],
[[Human, Move, RelativeDirectionTemplate],
[HumanReplace, Move, RelativeDirectionTemplate, ConditionTypeAdjacentBlockType]],
[[Human, Move, ALittle, RelativeDirectionTemplate],
[HumanReplace, Move, RelativeDirectionTemplate, ConditionTypeAdjacentBlockType]],
[[Human, Move, To, LocationBlockObjectTemplate],
[HumanReplace, Move, RelativeDirectionTemplate, LocationBlockObjectTemplate]],
[[Human, Move, To, BlockObjectThat],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Move, To, BlockObjectThis],
[HumanReplace, Move, RelativeDirectionTemplate, BlockObjectThis]],
[[Human, Move, To, LocationMobTemplate],
[HumanReplace, Move, RelativeDirectionTemplate, LocationMobTemplate]],
]
MOVE_TEMPLATES = [
## One word command for Move ##
[Human, MoveSingle],
# Move with Location ##
[Human, MoveHere],
[Human, MoveHereCoref],
[Human, MoveHere, ConditionTypeNever],
[Human, Move, ThereTemplate],
[Human, Move, ThereTemplateCoref],
[Human, Move, Between, BlockObjectThose],
[Human, Move, Between, BlockObjectThese],
[Human, Move, Between, BlockObjectThose, And, BlockObjectThese],
[Human, Move, Between, BlockObjectThis, And, BlockObjectThat],
[Human, Move, Between, LocationBlockObjectTemplate],
[Human, Move, Between, LocationMobTemplate],
[Human, Move, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Move, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Stand, LocationBlockObjectTemplate],
[Human, Stand, BlockObjectThat],
[Human, Stand, BlockObjectThis],
[Human, Stand, LocationMobTemplate],
[Human, Down, LocationBlockObjectTemplate],
[Human, Down, BlockObjectThat],
[Human, Down, BlockObjectThis],
[Human, Down, LocationMobTemplate],
[Human, Down, ThereTemplateCoref],
[Human, Move, RelativeDirectionTemplate],
[Human, Move, RelativeDirectionTemplate, BlockObjectThat],
[Human, Move, RelativeDirectionTemplate, BlockObjectThis],
[Human, Move, RelativeDirectionTemplate, StepsTemplate],
[Human, Move, RelativeDirectionTemplate, ConditionTypeAdjacentBlockType],
[Human, Move, RelativeDirectionTemplate, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Move, ALittle, RelativeDirectionTemplate],
[Human, Move, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Move, ALittle, RelativeDirectionTemplate, BlockObjectThis],
[Human, Move, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Move, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Move, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Move, To, CoordinatesTemplate],
[Human, Move, To, LocationWord, CoordinatesTemplate],
[Human, Move, Between, LocationBlockObjectTemplate],
[Human, Move, Between, LocationMobTemplate],
[Human, Move, To, LocationBlockObjectTemplate],
[Human, Move, To, LocationMobTemplate],
[Human, Move, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Move, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Move, RelativeDirectionTemplate, LocationMobTemplate],
## Other ways of saying Move ##
[Human, Find, LocationMobTemplate],
[Human, Move, To, Where, LocationMobTemplate, Is],
## Follow Mob ##
[Human, Move, LocationMobTemplate, ConditionTypeNever],
[Human, Move, BlockObjectIt, ConditionTypeNever],
[Human, Move, BlockObjectThat, ConditionTypeNever],
[Human, Move, ThisTemplate, LocationMobTemplate, ConditionTypeNever],
## Move n steps m times ##
[Human, Move, StepsTemplate, NTimes],
[Human, Move, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Move, StepsTemplate, RelativeDirectionTemplate, BlockObjectThis],
[Human, Move, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Move, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Move, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
## Climb to the top of X ##
[Human, Move, ClimbDirectionTemplate, LocationBlockObjectTemplate],
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/move_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
"""
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
PutMemory templates are written for filters and have an answer_type
They represent the action of writing to the memory using the filters.
Examples:
[[HumanMemory, HumanPosReward],
[Bot, BotThank]],
- human: good job
bot: thanks for letting me know
"""
from template_objects import *
TAG_WITH_CORRECTION = [
## Add location ##
## X is adjective ##
[[Human, BlockObjectThat, Is, TagDesc],
[HumanReplace, The, Size, Thing]],
[[Human, BlockObjectThat, Is, TagDesc],
[HumanReplace, The, Colour, Thing]],
[[Human, BlockObjectThat, Is, TagDesc],
[HumanReplace, The, Size, Colour, Thing]],
[[Human, BlockObjectThis, Is, TagDesc],
[HumanReplace, The, Size, Thing]],
[[Human, BlockObjectThis, Is, TagDesc],
[HumanReplace, The, Colour, Thing]],
[[Human, BlockObjectThis, Is, TagDesc],
[HumanReplace, The, Size, Colour, Thing]],
[[Human, BlockObjectIt, Is, TagDesc],
[HumanReplace, The, Size, Thing]],
[[Human, BlockObjectIt, Is, TagDesc],
[HumanReplace, The, Colour, Thing]],
[[Human, BlockObjectIt, Is, TagDesc],
[HumanReplace, The, Size, Colour, Thing]],
[[Human, Tag, BlockObjectThat, With, TagDesc],
[HumanReplace, The, Size, Thing]],
[[Human, Tag, BlockObjectThat, With, TagDesc],
[HumanReplace, The, Colour, Thing]],
[[Human, Tag, BlockObjectThat, With, TagDesc],
[HumanReplace, The, Size, Colour, Thing]],
[[Human, Tag, BlockObjectThis, With, TagDesc],
[HumanReplace, The, Size, Thing]],
[[Human, Tag, BlockObjectThis, With, TagDesc],
[HumanReplace, The, Colour, Thing]],
[[Human, Tag, BlockObjectThis, With, TagDesc],
[HumanReplace, The, Size, Colour, Thing]],
[[Human, Tag, BlockObjectIt, With, TagDesc],
[HumanReplace, The, Size, Thing]],
[[Human, Tag, BlockObjectIt, With, TagDesc],
[HumanReplace, The, Colour, Thing]],
[[Human, Tag, BlockObjectIt, With, TagDesc],
[HumanReplace, The, Size, Colour, Thing]],
# ## X is name ##
[[Human, BlockObjectThat, Is, TagName],
[HumanReplace, The, Size, Thing]],
[[Human, BlockObjectThat, Is, TagName],
[HumanReplace, The, Colour, Thing]],
[[Human, BlockObjectThat, Is, TagName],
[HumanReplace, The, Size, Colour, Thing]],
[[Human, BlockObjectThis, Is, TagName],
[HumanReplace, The, Size, Thing]],
[[Human, BlockObjectThis, Is, TagName],
[HumanReplace, The, Colour, Thing]],
[[Human, BlockObjectThis, Is, TagName],
[HumanReplace, The, Size, Colour, Thing]],
[[Human, BlockObjectIt, Is, TagName],
[HumanReplace, The, Size, Thing]],
[[Human, BlockObjectIt, Is, TagName],
[HumanReplace, The, Colour, Thing]],
[[Human, BlockObjectIt, Is, TagName],
[HumanReplace, The, Size, Colour, Thing]],
[[Human, BlockObjectThat, Is, TagDesc],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, BlockObjectThis, Is, TagDesc],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, BlockObjectIt, Is, TagDesc],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Tag, BlockObjectThat, With, TagDesc],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Tag, BlockObjectThis, With, TagDesc],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Tag, BlockObjectIt, With, TagDesc],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
## X is name ##
[[Human, BlockObjectThat, Is, TagName],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, BlockObjectThis, Is, TagName],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, BlockObjectIt, Is, TagName],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
]
TAG_TEMPLATES = [
# X is adjective ##
[Human, BlockObjectThat, Is, TagDesc],
[Human, BlockObjectThis, Is, TagDesc],
[Human, BlockObjectIt, Is, TagDesc],
[Human, Tag, BlockObjectThat, With, TagDesc],
[Human, Tag, BlockObjectThis, With, TagDesc],
[Human, Tag, BlockObjectIt, With, TagDesc],
## X is name ##
[Human, BlockObjectThat, Is, TagName],
[Human, BlockObjectThis, Is, TagName],
[Human, BlockObjectIt, Is, TagName],
## The X at Y is adjective ##
[Human, The, AbstractDescription, BlockObjectLocation, Is, TagDesc],
[Human, BlockObjectThat, AbstractDescription, Is, TagDesc],
[Human, BlockObjectThis, AbstractDescription, Is, TagDesc],
[Human, The, ConcreteDescription, BlockObjectLocation, Is, TagDesc],
[Human, BlockObjectThat, ConcreteDescription, Is, TagDesc],
[Human, BlockObjectThis, ConcreteDescription, Is, TagDesc],
## The size X is adjective ##
[Human, BlockObjectThat, Size, AbstractDescription, Is, TagDesc],
[Human, BlockObjectThis, Size, AbstractDescription, Is, TagDesc],
[Human, The, Size, AbstractDescription, BlockObjectLocation, Is, TagDesc],
[Human, BlockObjectThat, Size, ConcreteDescription, Is, TagDesc],
[Human, BlockObjectThis, Size, ConcreteDescription, Is, TagDesc],
[Human, The, Size, ConcreteDescription, BlockObjectLocation, Is, TagDesc],
## The colour X is adjective ##
[Human, BlockObjectThat, Colour, AbstractDescription, Is, TagDesc],
[Human, BlockObjectThis, Colour, AbstractDescription, Is, TagDesc],
[Human, The, Colour, AbstractDescription, BlockObjectLocation, Is, TagDesc],
[Human, BlockObjectThat, Colour, ConcreteDescription, Is, TagDesc],
[Human, BlockObjectThis, Colour, ConcreteDescription, Is, TagDesc],
[Human, The, Colour, ConcreteDescription, BlockObjectLocation, Is, TagDesc],
## The size colour X is adjective ##
[Human, BlockObjectThat, Size, Colour, AbstractDescription, Is, TagDesc],
[Human, BlockObjectThis, Size, Colour, AbstractDescription, Is, TagDesc],
[Human, The, Size, Colour, AbstractDescription, BlockObjectLocation, Is, TagDesc],
[Human, BlockObjectThat, Size, Colour, ConcreteDescription, Is, TagDesc],
[Human, BlockObjectThis, Size, Colour, ConcreteDescription, Is, TagDesc],
[Human, The, Size, Colour, ConcreteDescription, BlockObjectLocation, Is, TagDesc],
# Tag X with adjective ##
[Human, Tag, BlockObjectThat, AbstractDescription, With, TagDesc],
[Human, Tag, BlockObjectThis, AbstractDescription, With, TagDesc],
[Human, Tag,The, AbstractDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, BlockObjectThat, ConcreteDescription, With, TagDesc],
[Human, Tag, BlockObjectThis, ConcreteDescription, With, TagDesc],
[Human, Tag,The, ConcreteDescription, BlockObjectLocation, With, TagDesc],
## Tag size X with adjective ##
[Human, Tag, BlockObjectThat, Size, AbstractDescription, With, TagDesc],
[Human, Tag, BlockObjectThis, Size, AbstractDescription, With, TagDesc],
[Human, Tag, The, Size, AbstractDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, BlockObjectThat, Size, ConcreteDescription, With, TagDesc],
[Human, Tag, BlockObjectThis, Size, ConcreteDescription, With, TagDesc],
[Human, Tag, The, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc],
## Tag colour X with adjective ##
[Human, Tag, BlockObjectThat, Colour, AbstractDescription, With, TagDesc],
[Human, Tag, BlockObjectThis, Colour, AbstractDescription, With, TagDesc],
[Human, Tag, The, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, BlockObjectThat, Colour, ConcreteDescription, With, TagDesc],
[Human, Tag, BlockObjectThis, Colour, ConcreteDescription, With, TagDesc],
[Human, Tag, The, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc],
## Tag size colour X with adjective ##
[Human, Tag, BlockObjectThat, Size, Colour, AbstractDescription, With, TagDesc],
[Human, Tag, BlockObjectThis, Size, Colour, AbstractDescription, With, TagDesc],
[Human, Tag, The, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, BlockObjectThat, Size, Colour, ConcreteDescription, With, TagDesc],
[Human, Tag, BlockObjectThis, Size, Colour, ConcreteDescription, With, TagDesc],
[Human, Tag, The, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc],
## The mob is/ looks adjective ##
[Human, The, MobName, Is, TagDesc],
[Human, MobThis, MobName, Is, TagDesc],
[Human, MobThat, MobName, Is, TagDesc],
[Human, The, MobName, MobLocation, Is, TagDesc],
## Tag mob with adjective ##
[Human, Tag, The, MobName, With, TagDesc],
[Human, Tag, The, MobName, MobLocation, With, TagDesc],
[Human, Tag, MobThis, MobName, With, TagDesc],
[Human, Tag, MobThat, MobName, With, TagDesc],
## The X is/ looks like a name ##
[Human, The, AbstractDescription, BlockObjectLocation, Is, TagName],
[Human, BlockObjectThat, AbstractDescription, Is, TagName],
[Human, BlockObjectThis, AbstractDescription, Is, TagName],
[Human, The, ConcreteDescription, BlockObjectLocation, Is, TagName],
[Human, BlockObjectThat, ConcreteDescription, Is, TagName],
[Human, BlockObjectThis, ConcreteDescription, Is, TagName],
## The size X is/ looks like a name ##
[Human, BlockObjectThat, Size, AbstractDescription, Is, TagName],
[Human, BlockObjectThis, Size, AbstractDescription, Is, TagName],
[Human, The, Size, AbstractDescription, BlockObjectLocation, Is, TagName],
[Human, BlockObjectThat, Size, ConcreteDescription, Is, TagName],
[Human, BlockObjectThis, Size, ConcreteDescription, Is, TagName],
[Human, The, Size, ConcreteDescription, BlockObjectLocation, Is, TagName],
## The colour X is/ looks like a name ##
[Human, BlockObjectThat, Colour, AbstractDescription, Is, TagName],
[Human, BlockObjectThis, Colour, AbstractDescription, Is, TagName],
[Human, The, Colour, AbstractDescription, BlockObjectLocation, Is, TagName],
[Human, BlockObjectThat, Colour, ConcreteDescription, Is, TagName],
[Human, BlockObjectThis, Colour, ConcreteDescription, Is, TagName],
[Human, The, Colour, ConcreteDescription, BlockObjectLocation, Is, TagName],
## The size colour X is/ looks like a name ##
[Human, BlockObjectThat, Size, Colour, AbstractDescription, Is, TagName],
[Human, BlockObjectThis, Size, Colour, AbstractDescription, Is, TagName],
[Human, The, Size, Colour, AbstractDescription, BlockObjectLocation, Is, TagName],
[Human, BlockObjectThat, Size, Colour, ConcreteDescription, Is, TagName],
[Human, BlockObjectThis, Size, Colour, ConcreteDescription, Is, TagName],
[Human, The, Size, Colour, ConcreteDescription, BlockObjectLocation, Is, TagName],
## The mob is / looks like a name ##
[Human, The, MobName, Is, TagName],
[Human, MobThis, MobName, Is, TagName],
[Human, MobThat, MobName, Is, TagName],
[Human, The, MobName, MobLocation, Is, TagName],
### Tag all X as Y ###
[Human, Tag, Everything, With, TagDesc, RepeatAll],
[Human, Tag, All, AbstractDescription, With, TagDesc, RepeatAll],
[Human, Tag, All, ConcreteDescription, With, TagDesc, RepeatAll],
[Human, Tag, Every, AbstractDescription, With, TagDesc, RepeatAll],
[Human, Tag, Every, ConcreteDescription, With, TagDesc, RepeatAll],
[Human, Tag, All, Size, AbstractDescription, With, TagDesc, RepeatAll],
[Human, Tag, All, Size, ConcreteDescription, With, TagDesc, RepeatAll],
[Human, Tag, Every, Size, AbstractDescription, With, TagDesc, RepeatAll],
[Human, Tag, Every, Size, ConcreteDescription, With, TagDesc, RepeatAll],
[Human, Tag, All, Colour, AbstractDescription, With, TagDesc, RepeatAll],
[Human, Tag, All, Colour, ConcreteDescription, With, TagDesc, RepeatAll],
[Human, Tag, Every, Colour, AbstractDescription, With, TagDesc, RepeatAll],
[Human, Tag, Every, Colour, ConcreteDescription, With, TagDesc, RepeatAll],
[Human, Tag, All, Size, Colour, AbstractDescription, With, TagDesc, RepeatAll],
[Human, Tag, All, Size, Colour, ConcreteDescription, With, TagDesc, RepeatAll],
[Human, Tag, Every, Size, Colour, AbstractDescription, With, TagDesc, RepeatAll],
[Human, Tag, Every, Size, Colour, ConcreteDescription, With, TagDesc, RepeatAll],
[Human, Tag, MobName, With, TagDesc, RepeatAll],
### Tag all X at location Y as Z ###
[Human, Tag, Everything, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, All, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, Every, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, All, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, Every, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, All, Size, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, All, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, Every, Size, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, Every, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, All, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, All, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, Every, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, Every, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, All, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, All, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, Every, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, Every, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAll],
[Human, Tag, MobName, MobLocation, With, TagDesc, RepeatAll],
## Tag X at all Y as Z ##
[Human, Tag, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, Size, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, MobName, MobLocation, With, TagDesc, RepeatAllLocation],
## Tag all X at all Y as Z ##
[Human, Tag, All, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, All, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, All, Size, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, All, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, All, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, All, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, All, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, All, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, Every, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, Every, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, Every, Size, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, Every, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, Every, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, Every, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, Every, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, Every, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
[Human, Tag, MobName, MobLocation, With, TagDesc, RepeatAllLocation, RepeatAll],
### Tag num X as Y ###
[Human, Tag, RepeatCount, AbstractDescription, With, TagDesc],
[Human, Tag, RepeatCount, ConcreteDescription, With, TagDesc],
[Human, Tag, RepeatCount, Size, AbstractDescription, With, TagDesc],
[Human, Tag, RepeatCount, Size, ConcreteDescription, With, TagDesc],
[Human, Tag, RepeatCount, Colour, AbstractDescription, With, TagDesc],
[Human, Tag, RepeatCount, Colour, ConcreteDescription, With, TagDesc],
[Human, Tag, RepeatCount, Size, Colour, AbstractDescription, With, TagDesc],
[Human, Tag, RepeatCount, Size, Colour, ConcreteDescription, With, TagDesc],
[Human, Tag, RepeatCount, MobName, With, TagDesc],
## Tag num X at location Y as Z ##
[Human, Tag, RepeatCount, AbstractDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, RepeatCount, ConcreteDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, RepeatCount, Size, AbstractDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, RepeatCount, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, RepeatCount, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, RepeatCount, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, RepeatCount, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, RepeatCount, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc],
[Human, Tag, RepeatCount, MobName, MobLocation, With, TagDesc],
## Tag X at num Y as Z ##
[Human, Tag, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, Size, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, MobName, MobLocation, With, TagDesc, RepeatCountLocation],
## Tag num X at num Y as Z ##
[Human, Tag, RepeatCount, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, RepeatCount, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, RepeatCount, Size, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, RepeatCount, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, RepeatCount, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, RepeatCount, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, RepeatCount, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, RepeatCount, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation],
[Human, Tag, RepeatCount, MobName, MobLocation, With, TagDesc, RepeatCountLocation],
## Tag all X at num Y as Z ##
[Human, Tag, All, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, All, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, All, Size, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, All, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, All, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, All, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, All, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, All, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, Every, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, Every, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, Every, Size, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, Every, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, Every, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, Every, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, Every, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, Every, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
[Human, Tag, MobName, MobLocation, With, TagDesc, RepeatCountLocation, RepeatAll],
## Tag num X at all Y as Z ##
[Human, Tag, RepeatCount, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, RepeatCount, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, RepeatCount, Size, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, RepeatCount, Size, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, RepeatCount, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, RepeatCount, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, RepeatCount, Size, Colour, AbstractDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, RepeatCount, Size, Colour, ConcreteDescription, BlockObjectLocation, With, TagDesc, RepeatAllLocation],
[Human, Tag, RepeatCount, MobName, MobLocation, With, TagDesc, RepeatAllLocation]
]
PUT_MEMORY_TEMPLATES = [
## Give positive reward ##
[Human, HumanReward, PosReward],
## Give negative reward ##
[Human, HumanReward, NegReward],
] + TAG_TEMPLATES
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/put_memory_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
"""
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
GetMemory templates are written for filters and have an answer_type
They represent the action of fetching from the memory using the filters.
Examples:
[Human, QueryBotCurrentAction],
- human: what are you doing
- human: what are you up to
[Human, QueryBot, MoveTarget],
- human: where you going
- human: where are you heading
"""
from template_objects import *
ANSWER_WITH_CORRECTION = [
## what is this + the thing at location ##
[[Human, What, Is, BlockObjectThis],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, What, Is, BlockObjectThis, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, What, Is, BlockObjectThat],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, What, Is, BlockObjectThat, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
## what size is X + the thing at location ##
[[Human, AskSize, BlockObjectThis],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskSize, BlockObjectThis, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskSize, BlockObjectThis, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskSize, BlockObjectThat],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskSize, BlockObjectThat, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskSize, BlockObjectThat, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
## what color is X + the thing at location ##
[[Human, AskColour, BlockObjectThis],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskColour, BlockObjectThis, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskColour, BlockObjectThis, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskColour, BlockObjectThat],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskColour, BlockObjectThat, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskColour, BlockObjectThat, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
# Is X Y ##
[[Human, AskIs, BlockObjectThis, Size],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThis, AbstractDescription, Size],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThis, ConcreteDescription, Size],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThat, Size],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThat, AbstractDescription, Size],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThat, ConcreteDescription, Size],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, The, AbstractDescription, BlockObjectLocation, Size],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, The, ConcreteDescription, BlockObjectLocation, Size],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThis, Colour],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThis, AbstractDescription, Colour],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThis, ConcreteDescription, Colour],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThat, Colour],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThat, AbstractDescription, Colour],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThat, ConcreteDescription, Colour],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, The, AbstractDescription, BlockObjectLocation, Colour],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, The, ConcreteDescription, BlockObjectLocation, Colour],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
## Is X a Y ##
[[Human, AskIs, BlockObjectThis, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThis, AbstractDescription, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThat, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, AskIs, BlockObjectThat, AbstractDescription, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
]
ANSWER_TEMPLATES = [
# 1
## What is X ##
[Human, What, Is, BlockObjectThis],
[Human, What, Is, BlockObjectThis, AbstractDescription],
[Human, What, Is, BlockObjectThat],
[Human, What, Is, BlockObjectThat, AbstractDescription],
# 2
## What is at X ##
[Human, What, Is, BlockObjectLocation],
[Human, What, Is, The, AbstractDescription, BlockObjectLocation],
## What do you see at X ##
[Human, WhatSee, BlockObjectLocation],
# 3
# What size is X ##
[Human, AskSize, BlockObjectThis],
[Human, AskSize, BlockObjectThis, AbstractDescription],
[Human, AskSize, BlockObjectThis, ConcreteDescription],
[Human, AskSize, BlockObjectThat],
[Human, AskSize, BlockObjectThat, AbstractDescription],
[Human, AskSize, BlockObjectThat, ConcreteDescription],
# 4
## what size is X at Y ##
[Human, AskSize, The, AbstractDescription, BlockObjectLocation],
[Human, AskSize, The, ConcreteDescription, BlockObjectLocation],
# 5
# What colour is X ##
[Human, AskColour, BlockObjectThis],
[Human, AskColour, BlockObjectThis, AbstractDescription],
[Human, AskColour, BlockObjectThis, ConcreteDescription],
[Human, AskColour, BlockObjectThat],
[Human, AskColour, BlockObjectThat, AbstractDescription],
[Human, AskColour, BlockObjectThat, ConcreteDescription],
# 6
## what colour is X at Y ##
[Human, AskColour, The, AbstractDescription, BlockObjectLocation],
[Human, AskColour, The, ConcreteDescription, BlockObjectLocation],
# 7
## Is X Y ##
[Human, AskIs, BlockObjectThis, Size],
[Human, AskIs, BlockObjectThis, AbstractDescription, Size],
[Human, AskIs, BlockObjectThis, ConcreteDescription, Size],
[Human, AskIs, BlockObjectThat, Size],
[Human, AskIs, BlockObjectThat, AbstractDescription, Size],
[Human, AskIs, BlockObjectThat, ConcreteDescription, Size],
[Human, AskIs, The, AbstractDescription, BlockObjectLocation, Size],
[Human, AskIs, The, ConcreteDescription, BlockObjectLocation, Size],
[Human, AskIs, BlockObjectThis, Colour],
[Human, AskIs, BlockObjectThis, AbstractDescription, Colour],
[Human, AskIs, BlockObjectThis, ConcreteDescription, Colour],
[Human, AskIs, BlockObjectThat, Colour],
[Human, AskIs, BlockObjectThat, AbstractDescription, Colour],
[Human, AskIs, BlockObjectThat, ConcreteDescription, Colour],
[Human, AskIs, The, AbstractDescription, BlockObjectLocation, Colour],
[Human, AskIs, The, ConcreteDescription, BlockObjectLocation, Colour],
# 8
## Is X a Y ##
[Human, AskIs, BlockObjectThis, ConcreteDescription],
[Human, AskIs, BlockObjectThis, AbstractDescription, ConcreteDescription],
[Human, AskIs, BlockObjectThat, ConcreteDescription],
[Human, AskIs, BlockObjectThat, AbstractDescription, ConcreteDescription],
# 9
## IS X at Y Z ##
[Human, AskIs, The, AbstractDescription, BlockObjectLocation, ConcreteDescription],
]
GET_MEMORY_TEMPLATES = [
## What are you Doing (Action name) ##
[Human, QueryBotCurrentAction],
## What are you Building (Action reference object name) ##
[Human, QueryBot, ActionReferenceObjectName],
## Where are you heading (Move target) ##
[Human, QueryBot, MoveTarget],
## Where are you (Bot location) ##
[Human, QueryBot, CurrentLocation],
] + ANSWER_TEMPLATES
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/get_memory_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
'''
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Dig templates are written for a Location and represent the intent
for the action: Dig. This action intends to dig a hole at a certain location.
Examples:
[Human, Dig, DigSomeShape, ThereTemplate]
- dig a hole there
- make a tunnel there
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate]
- dig a hole a little to the right of the sheep
- make a tunnel a bit in front of the pig
'''
from template_objects import *
DIG_WITH_CORRECTION = [
## General pattern : dig + new location specification
## Dig X N times, add location ##
[[Human, Dig, DigSomeShape, NTimes],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigDimensions, DigSomeShape, NTimes],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigAbstractSize, DigSomeShape, NTimes],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigDimensions, NTimes],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigDimensions, DigSomeShape, NTimes],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, ThereTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, ThereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, HereTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, HereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, YouTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, ThereTemplateCoref, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, HereTemplate, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, HereTemplateCoref, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, YouTemplate, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DownTo, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, DownTo, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigSomeShape, DownTo, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, ThereTemplate, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, ThereTemplateCoref, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, HereTemplate, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, HereTemplateCoref, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, YouTemplate, ConditionTypeAdjacentBlockType],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
## Dig an X by Y ##
[[Human, Dig, DigDimensions],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
## Dig X of dimensions Y ##
[[Human, Dig, DigSomeShape, OfDimensionsPhrase, DigDimensions],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigDimensions, DigSomeShape, ThereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigDimensions, DigSomeShape, HereTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigDimensions, DigSomeShape, HereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigDimensions, DigSomeShape, YouTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigAbstractSize, DigSomeShape, ThereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigAbstractSize, DigSomeShape, HereTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigAbstractSize, DigSomeShape, HereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigAbstractSize, DigSomeShape, YouTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
## Dig X Y blocks long / wide / deep ##
[[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, NumBlocks, Squares, Long],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigSomeShape, ThereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigSomeShape, HereTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigSomeShape, HereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigSomeShape, YouTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ThereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, HereTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, HereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, YouTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ThereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, HereTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, HereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, YouTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
[[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate, Please]],
]
DIG_TEMPLATES = [
## Single word Dig command ##
[Human, DigSingle],
## Dig at location X (optional) ##
[Human, Dig, Under],
[Human, Dig, Under, YouTemplate],
[Human, Dig, YouTemplate],
[Human, Dig, HereTemplate],
[Human, Dig, HereTemplateCoref],
[Human, Dig, ThereTemplate],
[Human, Dig, ThereTemplateCoref],
[Human, Dig, At, LocationWord, CoordinatesTemplate],
[Human, Dig, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Dig, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Dig, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Dig X N times ##
[Human, Dig, DigSomeShape, NTimes],
[Human, Dig, DigDimensions, DigSomeShape, NTimes],
[Human, Dig, DigAbstractSize, DigSomeShape, NTimes],
[Human, Dig, DigDimensions, NTimes],
[Human, Dig, DigDimensions, DigSomeShape, NTimes],
## Dig X at location Y (optional) ##
[Human, Dig, DigSomeShape],
[Human, Dig, DigSomeShape, At, LocationWord, CoordinatesTemplate],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, DigSomeShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Dig, DigSomeShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Dig, DigSomeShape, ThereTemplate],
[Human, Dig, DigSomeShape, ThereTemplateCoref],
[Human, Dig, DigSomeShape, HereTemplate],
[Human, Dig, DigSomeShape, HereTemplateCoref],
[Human, Dig, DigSomeShape, YouTemplate],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Dig at location X (optional) until condition Y ##
[Human, Dig, ConditionTypeAdjacentBlockType],
[Human, Dig, At, LocationWord, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RelativeDirectionTemplate, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RelativeDirectionTemplate, BlockObjectThat, ConditionTypeAdjacentBlockType],
[Human, Dig, RelativeDirectionTemplate, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RelativeDirectionTemplate, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, ThereTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, ThereTemplateCoref, ConditionTypeAdjacentBlockType],
[Human, Dig, HereTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, HereTemplateCoref, ConditionTypeAdjacentBlockType],
[Human, Dig, YouTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, ConditionTypeAdjacentBlockType],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, ALittle, RelativeDirectionTemplate, YouTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, ALittle, RelativeDirectionTemplate, BlockObjectThat, ConditionTypeAdjacentBlockType],
[Human, Dig, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, ALittle, RelativeDirectionTemplate, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, ALittle, RelativeDirectionTemplate, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
## Dig down to block type X ##
[Human, Dig, DownTo, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, DownTo, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, DownTo, ConditionTypeAdjacentBlockType],
## Dig X at location Y (optional) until condition Z ##
[Human, Dig, DigSomeShape, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, At, LocationWord, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, ThereTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, ThereTemplateCoref, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, HereTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, HereTemplateCoref, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, YouTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, YouTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
## Dig an X by Y ##
[Human, Dig, DigDimensions],
## Dig X of dimensions Y ##
[Human, Dig, DigSomeShape, OfDimensionsPhrase, DigDimensions],
## Dig a dimension X shape Y at location Z (optional) ##
[Human, Dig, DigDimensions, DigSomeShape],
[Human, Dig, DigDimensions, DigSomeShape, At, LocationWord, CoordinatesTemplate],
[Human, Dig, DigDimensions, DigSomeShape, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, DigDimensions, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, DigDimensions, DigSomeShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Dig, DigDimensions, DigSomeShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Dig, DigDimensions, DigSomeShape, ThereTemplate],
[Human, Dig, DigDimensions, DigSomeShape, ThereTemplateCoref],
[Human, Dig, DigDimensions, DigSomeShape, HereTemplate],
[Human, Dig, DigDimensions, DigSomeShape, HereTemplateCoref],
[Human, Dig, DigDimensions, DigSomeShape, YouTemplate],
[Human, Dig, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Dig, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Dig a size X shape Y at location Z (optional) ##
[Human, Dig, DigAbstractSize, DigSomeShape],
[Human, Dig, DigAbstractSize, DigSomeShape, At, LocationWord, CoordinatesTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, DigAbstractSize, DigSomeShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, ThereTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, ThereTemplateCoref],
[Human, Dig, DigAbstractSize, DigSomeShape, HereTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, HereTemplateCoref],
[Human, Dig, DigAbstractSize, DigSomeShape, YouTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Dig X Y blocks long / wide / deep ##
[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Long],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep],
## Dig X Y blocks long and Z blocks deep ##
[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Deep],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Long],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Long, And, NumBlocks, Squares, Deep],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Long, And, NumBlocks, Squares, Wide],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Wide],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Long],
## Dig X Y blocks long Z blocks deep ##
[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Deep],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Long],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Deep],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Wide],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Wide],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Long],
## Dig X Y blocks long and Z blocks deep and Z blocks wide ##
[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Long],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Long, And, NumBlocks, Squares, Deep],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Long],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Long, And, NumBlocks, Squares, Wide],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Long, And, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Wide],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Long, And, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Deep],
## Dig X Y blocks long Z blocks deep Z and blocks wide ##
[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Long],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Long, And, NumBlocks, Squares, Deep],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Long],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Long, And, NumBlocks, Squares, Wide],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Wide],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Deep],
## Dig X Y blocks long Z blocks deep Z blocks wide ##
[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Deep, NumBlocks, Squares, Long],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Long, NumBlocks, Squares, Deep],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Wide, NumBlocks, Squares, Long],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Long, NumBlocks, Squares, Wide],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Deep, NumBlocks, Squares, Wide],
[Human, Dig, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Wide, NumBlocks, Squares, Deep],
##Dig at every location X ##
[Human, Dig, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Dig X at every location Y ##
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Dig dimension X shape Y at every location Z ##
[Human, Dig, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, DigDimensions, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Dig size X shape Y at every location Z ##
[Human, Dig, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate, RepeatAllLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Dig N Holes at location Y (optional) ##
[Human, Dig, RepeatCount, DigSomeShape],
[Human, Dig, RepeatCount, DigSomeShape, At, LocationWord, CoordinatesTemplate],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, RepeatCount, DigSomeShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigSomeShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Dig, RepeatCount, DigSomeShape, ThereTemplate],
[Human, Dig, RepeatCount, DigSomeShape, ThereTemplateCoref],
[Human, Dig, RepeatCount, DigSomeShape, HereTemplate],
[Human, Dig, RepeatCount, DigSomeShape, HereTemplateCoref],
[Human, Dig, RepeatCount, DigSomeShape, YouTemplate],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Dig N holes at location Y until condition Z ##
[Human, Dig, RepeatCount, DigSomeShape, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, At, LocationWord, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, ThereTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, ThereTemplateCoref, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, HereTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, HereTemplateCoref, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, YouTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, YouTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, ConditionTypeAdjacentBlockType],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate, ConditionTypeAdjacentBlockType],
## Dig N holes of dimension Y at location Z ##
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape],
[Human, Dig, RepeatCount, DigSomeShape, OfDimensionsPhrase, DigDimensions],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, At, LocationWord, CoordinatesTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ThereTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ThereTemplateCoref],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, HereTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, HereTemplateCoref],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, YouTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Dig N holes of size Y at location Z ##
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, At, LocationWord, CoordinatesTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ThereTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ThereTemplateCoref],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, HereTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, HereTemplateCoref],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, YouTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## Dig N holes X blocks wide ##
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep],
## Dig N holes X blocks wide and Y blocks long ##
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Deep],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Long],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long, And, NumBlocks, Squares, Deep],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long, And, NumBlocks, Squares, Wide],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Wide],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Long],
## Dig N holes X blocks wide Y blocks long ##
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Deep],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Long],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Deep],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Wide],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Wide],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Long],
## Dig N holes X blocks wide and Y blocks long and Z blocks deep ##
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Long],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Long, And, NumBlocks, Squares, Deep],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Long],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Long, And, NumBlocks, Squares, Wide],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long, And, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Wide],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long, And, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Deep],
## Dig N holes X blocks wide Y blocks long and Z blocks deep ##
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Long],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Long, And, NumBlocks, Squares, Deep],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Long],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Long, And, NumBlocks, Squares, Wide],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Deep, And, NumBlocks, Squares, Wide],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Wide, And, NumBlocks, Squares, Deep],
## Dig N holes X blocks wide Y blocks long Z blocks deep ##
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Deep, NumBlocks, Squares, Long],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Wide, NumBlocks, Squares, Long, NumBlocks, Squares, Deep],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Wide, NumBlocks, Squares, Long],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Deep, NumBlocks, Squares, Long, NumBlocks, Squares, Wide],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Deep, NumBlocks, Squares, Wide],
[Human, Dig, RepeatCount, DigSomeShape, NumBlocks, Squares, Long, NumBlocks, Squares, Wide, NumBlocks, Squares, Deep],
## Dig N X at every location Y ###
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Dig N dimension X Y at every location Z ##
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Dig N size X Y at every location Z ##
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate, RepeatAllLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatAllLocation],
## Dig at locations X ##
[Human, Dig, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
## Dig X at locations Y ##
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
## Dig dimension X Y at locations Z ##
[Human, Dig, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, DigDimensions, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
## Dig size X Y at locations Z ##
[Human, Dig, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate, RepeatCountLocation],
[Human, Dig, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
## Dig N X at locations Y ##
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, RepeatCount, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, RepeatCount, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
## Dig N dimension X Y at locations Z ##
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigDimensions, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
## Dig N size X Y at locations Z ##
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, LocationMobTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, CoordinatesTemplate, RepeatCountLocation],
[Human, Dig, RepeatCount, DigAbstractSize, DigSomeShape, ALittle, RelativeDirectionTemplate, BlockObjectThat, RepeatCountLocation],
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/dig_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
'''
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Copy templates are written for a BlockObject and may have a Location,
and represent the intent for the action: Copy.
This action builds a copy of a physical block object that already exists in the
environment.
Examples:
[Human, Copy, The, Colour, AbstractDescription, NTimes]
- make a copy of the red thing 4 times
- copy the blue structure 2 times
[Human, Copy, RepeatCount, AbstractDescription]
- copy 4 shapes
- make a copy of 4 structures
'''
from template_objects import *
COPY_WITH_CORRECTION = [
## Single word Copy command ##
[[Human, CopySingle],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
## Copy X n times ##
# Abstract #
[[Human, Copy, The, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, The, Size, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, The, Size, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, Size, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, AbstractDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, Colour, AbstractDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, Size, AbstractDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThis, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThis, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThis, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThis, Size, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThis, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThis, AbstractDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThis, Colour, AbstractDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThis, Size, AbstractDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectIt, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectIt, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
## Concrete ##
[[Human, Copy, The, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, The, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, The, Size, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, The, Size, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThose, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThese, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThose, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThese, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, ConcreteDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, Size, ConcreteDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, Size, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThis, ConcreteDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThis, Size, ConcreteDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, NTimes],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThis, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThis, Size, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
## Copy n of X ##
# Abstract #
[[Human, Copy, RepeatCount, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, RepeatCount, Colour, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, RepeatCount, Size, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, RepeatCount, Size, Colour, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, RepeatCount, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, RepeatCount, Colour, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, AbstractDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, RepeatCount, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, RepeatCount, Colour, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, RepeatCount, Size, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, RepeatCount, Size, Colour, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, RepeatCount, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, RepeatCount, Colour, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
# Concrete #
[[Human, Copy, RepeatCount, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, RepeatCount, Colour, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, RepeatCount, Size, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThose, RepeatCount],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThese, RepeatCount],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription],
[HumanReplace, The, AbstractDescription, BlockObjectLocation]],
[[Human, Copy, BlockObjectThose, RepeatCount],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThese, RepeatCount],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, LocationMobTemplate]],
## Adding rel_dir of BlockObjectThat templates ##
## Single word Copy command ##
[[Human, CopySingle],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
## Copy X n times ##
## Abstract #
[[Human, Copy, The, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, The, Size, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, The, Size, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, Size, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThis, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThis, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThis, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThis, Size, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectIt, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
## Concrete ##
[[Human, Copy, The, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, The, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, The, Size, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, The, Size, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThose, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThese, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, Size, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThis, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThis, Size, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, NTimes],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, RepeatCount, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, RepeatCount, Colour, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, RepeatCount, Size, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, RepeatCount, Size, Colour, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, RepeatCount, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, RepeatCount, Colour, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, AbstractDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
## Concrete #
[[Human, Copy, RepeatCount, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, RepeatCount, Colour, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, RepeatCount, Size, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThose, RepeatCount],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThese, RepeatCount],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription],
[HumanReplace, Copy, RelativeDirectionTemplate, BlockObjectThat]],
]
COPY_TEMPLATES = [
## Copy X n times ##
# Abstract #
[Human, Copy, The, Colour, AbstractDescription, NTimes],
[Human, Copy, The, Size, AbstractDescription, NTimes],
[Human, Copy, The, Size, Colour, AbstractDescription, NTimes],
[Human, Copy, BlockObjectThat, AbstractDescription, NTimes],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, NTimes],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, NTimes],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, NTimes],
[Human, Copy, BlockObjectThis, NTimes],
[Human, Copy, BlockObjectThis, AbstractDescription, NTimes],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, NTimes],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, NTimes],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, NTimes],
[Human, Copy, BlockObjectIt, NTimes],
# Concrete #
[Human, Copy, The, ConcreteDescription, NTimes],
[Human, Copy, The, Colour, ConcreteDescription, NTimes],
[Human, Copy, The, Size, ConcreteDescription, NTimes],
[Human, Copy, The, Size, Colour, ConcreteDescription, NTimes],
[Human, Copy, BlockObjectThat, NTimes],
[Human, Copy, BlockObjectThose, NTimes],
[Human, Copy, BlockObjectThese, NTimes],
[Human, Copy, BlockObjectThat, ConcreteDescription, NTimes],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, NTimes],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, NTimes],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, NTimes],
[Human, Copy, BlockObjectThis, ConcreteDescription, NTimes],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, NTimes],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, NTimes],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, NTimes],
## Copy n of X ##
# Abstract #
[Human, Copy, RepeatCount, AbstractDescription],
[Human, Copy, RepeatCount, Colour, AbstractDescription],
[Human, Copy, RepeatCount, Size, AbstractDescription],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription],
[Human, Copy, BlockObjectThat, RepeatCount, AbstractDescription],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, AbstractDescription],
[Human, Copy, BlockObjectThat, RepeatCount, Size, AbstractDescription],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, AbstractDescription],
# Concrete #
[Human, Copy, RepeatCount, ConcreteDescription],
[Human, Copy, RepeatCount, Colour, ConcreteDescription],
[Human, Copy, RepeatCount, Size, ConcreteDescription],
[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription],
[Human, Copy, BlockObjectThose, RepeatCount],
[Human, Copy, BlockObjectThese, RepeatCount],
[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription],
[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription],
# Copy n of X at Location ##
# Abstract #
[Human, Copy, RepeatCount, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Size, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatCount, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatCount, Size, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatCount, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatCount, Size, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Size, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatCount, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatCount, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatCount, Size, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatCount, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatCount, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatCount, Size, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatCount, AbstractDescription, HereTemplate],
[Human, Copy, RepeatCount, Colour, AbstractDescription, HereTemplate],
[Human, Copy, RepeatCount, Size, AbstractDescription, HereTemplate],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, HereTemplate],
[Human, Copy, RepeatCount, AbstractDescription, HereTemplateCoref],
[Human, Copy, RepeatCount, Colour, AbstractDescription, HereTemplateCoref],
[Human, Copy, RepeatCount, Size, AbstractDescription, HereTemplateCoref],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, HereTemplateCoref],
[Human, Copy, RepeatCount, AbstractDescription, YouTemplate],
[Human, Copy, RepeatCount, Colour, AbstractDescription, YouTemplate],
[Human, Copy, RepeatCount, Size, AbstractDescription, YouTemplate],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThat, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThose, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThese, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThose, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThese, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, ThereTemplate],
[Human, Copy, BlockObjectThose, ThereTemplate],
[Human, Copy, BlockObjectThese, ThereTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, ThereTemplateCoref],
[Human, Copy, BlockObjectThose, ThereTemplateCoref],
[Human, Copy, BlockObjectThese, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, RepeatCount, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, RepeatCount, Size, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, YouTemplate],
[Human, Copy, BlockObjectThese, YouTemplate],
[Human, Copy, BlockObjectThose, YouTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, AbstractDescription, YouTemplate],
# Concrete #
[Human, Copy, RepeatCount, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Size, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatCount, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatCount, Size, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatCount, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatCount, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatCount, Size, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatCount, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatCount, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatCount, Size, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatCount, ConcreteDescription, HereTemplate],
[Human, Copy, RepeatCount, Colour, ConcreteDescription, HereTemplate],
[Human, Copy, RepeatCount, Size, ConcreteDescription, HereTemplate],
[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription, HereTemplate],
[Human, Copy, RepeatCount, ConcreteDescription, HereTemplateCoref],
[Human, Copy, RepeatCount, Colour, ConcreteDescription, HereTemplateCoref],
[Human, Copy, RepeatCount, Size, ConcreteDescription, HereTemplateCoref],
[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription, HereTemplateCoref],
[Human, Copy, RepeatCount, ConcreteDescription, YouTemplate],
[Human, Copy, RepeatCount, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, RepeatCount, Size, ConcreteDescription, YouTemplate],
[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription, YouTemplate],
## Copy all X ##
# Abstract #
[Human, Copy, RepeatAll, AbstractDescription],
[Human, Copy, RepeatAll, Colour, AbstractDescription],
[Human, Copy, RepeatAll, Size, AbstractDescription],
[Human, Copy, RepeatAll, Size, Colour, AbstractDescription],
[Human, Copy, RepeatAll, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThose],
[Human, Copy, RepeatAll, BlockObjectThese],
[Human, Copy, RepeatAll, BlockObjectThat, AbstractDescription],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, AbstractDescription],
[Human, Copy, RepeatAll, BlockObjectThat, Size, AbstractDescription],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, AbstractDescription],
# Concrete #
[Human, Copy, RepeatAll, ConcreteDescription],
[Human, Copy, RepeatAll, Colour, ConcreteDescription],
[Human, Copy, RepeatAll, Size, ConcreteDescription],
[Human, Copy, RepeatAll, Size, Colour, ConcreteDescription],
[Human, Copy, RepeatAll, BlockObjectThat, ConcreteDescription],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, ConcreteDescription],
[Human, Copy, RepeatAll, BlockObjectThat, Size, ConcreteDescription],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, ConcreteDescription],
# Copy all X at Location ##
# Abstract #
[Human, Copy, RepeatAll, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Size, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, Size, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatAll, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatAll, Size, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatAll, Size, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatAll, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, Size, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, Size, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, AbstractDescription, HereTemplate],
[Human, Copy, RepeatAll, Colour, AbstractDescription, HereTemplate],
[Human, Copy, RepeatAll, Size, AbstractDescription, HereTemplate],
[Human, Copy, RepeatAll, Size, Colour, AbstractDescription, HereTemplate],
[Human, Copy, RepeatAll, AbstractDescription, HereTemplateCoref],
[Human, Copy, RepeatAll, Colour, AbstractDescription, HereTemplateCoref],
[Human, Copy, RepeatAll, Size, AbstractDescription, HereTemplateCoref],
[Human, Copy, RepeatAll, Size, Colour, AbstractDescription, HereTemplateCoref],
[Human, Copy, RepeatAll, AbstractDescription, YouTemplate],
[Human, Copy, RepeatAll, Colour, AbstractDescription, YouTemplate],
[Human, Copy, RepeatAll, Size, AbstractDescription, YouTemplate],
[Human, Copy, RepeatAll, Size, Colour, AbstractDescription, YouTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThose, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThese, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThose, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThese, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, ThereTemplate],
[Human, Copy, RepeatAll, BlockObjectThose, ThereTemplate],
[Human, Copy, RepeatAll, BlockObjectThese, ThereTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, ThereTemplateCoref],
[Human, Copy, RepeatAll, BlockObjectThose, ThereTemplateCoref],
[Human, Copy, RepeatAll, BlockObjectThese, ThereTemplateCoref],
[Human, Copy, RepeatAll, BlockObjectThat, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, BlockObjectThat, Size, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, BlockObjectThat, YouTemplate],
[Human, Copy, RepeatAll, BlockObjectThose, YouTemplate],
[Human, Copy, RepeatAll, BlockObjectThese, YouTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, AbstractDescription, YouTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, AbstractDescription, YouTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, AbstractDescription, YouTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, AbstractDescription, YouTemplate],
# Concrete #
[Human, Copy, RepeatAll, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Size, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, Size, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatAll, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatAll, Size, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatAll, Size, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatAll, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, Size, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, Size, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, ConcreteDescription, HereTemplate],
[Human, Copy, RepeatAll, Colour, ConcreteDescription, HereTemplate],
[Human, Copy, RepeatAll, Size, ConcreteDescription, HereTemplate],
[Human, Copy, RepeatAll, Size, Colour, ConcreteDescription, HereTemplate],
[Human, Copy, RepeatAll, ConcreteDescription, HereTemplateCoref],
[Human, Copy, RepeatAll, Colour, ConcreteDescription, HereTemplateCoref],
[Human, Copy, RepeatAll, Size, ConcreteDescription, HereTemplateCoref],
[Human, Copy, RepeatAll, Size, Colour, ConcreteDescription, HereTemplateCoref],
[Human, Copy, RepeatAll, ConcreteDescription, YouTemplate],
[Human, Copy, RepeatAll, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, RepeatAll, Size, ConcreteDescription, YouTemplate],
[Human, Copy, RepeatAll, Size, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, BlockObjectThat, Size, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, RepeatAll, BlockObjectThat, ConcreteDescription, YouTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, ConcreteDescription, YouTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, ConcreteDescription, YouTemplate],
## Make n copies of X ##
# Abstract #
[Human, CopyMultiple, The, AbstractDescription],
[Human, CopyMultiple, The, Colour, AbstractDescription],
[Human, CopyMultiple, The, Size, AbstractDescription],
[Human, CopyMultiple, The, Size, Colour, AbstractDescription],
[Human, CopyMultiple, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThese],
[Human, CopyMultiple, BlockObjectThose],
[Human, CopyMultiple, BlockObjectThat, AbstractDescription],
[Human, CopyMultiple, BlockObjectThat, Colour, AbstractDescription],
[Human, CopyMultiple, BlockObjectThat, Size, AbstractDescription],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, AbstractDescription],
[Human, CopyMultiple, BlockObjectThis],
[Human, CopyMultiple, BlockObjectIt],
[Human, CopyMultiple, BlockObjectThis, AbstractDescription],
[Human, CopyMultiple, BlockObjectThis, Colour, AbstractDescription],
[Human, CopyMultiple, BlockObjectThis, Size, AbstractDescription],
[Human, CopyMultiple, BlockObjectThis, Size, Colour, AbstractDescription],
# Concrete #
[Human, CopyMultiple, The, ConcreteDescription],
[Human, CopyMultiple, The, Colour, ConcreteDescription],
[Human, CopyMultiple, The, Size, ConcreteDescription],
[Human, CopyMultiple, The, Size, Colour, ConcreteDescription],
[Human, CopyMultiple, BlockObjectThat, ConcreteDescription],
[Human, CopyMultiple, BlockObjectThat, Colour, ConcreteDescription],
[Human, CopyMultiple, BlockObjectThat, Size, ConcreteDescription],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, ConcreteDescription],
[Human, CopyMultiple, BlockObjectThis, ConcreteDescription],
[Human, CopyMultiple, BlockObjectThis, Colour, ConcreteDescription],
[Human, CopyMultiple, BlockObjectThis, Size, ConcreteDescription],
[Human, CopyMultiple, BlockObjectThis, Size, Colour, ConcreteDescription],
# Make n copies of X at location ##
# Abstract #
[Human, CopyMultiple, The, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Size, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, The, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, The, Size, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, The, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, The, AbstractDescription, ThereTemplate],
[Human, CopyMultiple, The, Colour, AbstractDescription, ThereTemplate],
[Human, CopyMultiple, The, Size, AbstractDescription, ThereTemplate],
[Human, CopyMultiple, The, Size, Colour, AbstractDescription, ThereTemplate],
[Human, CopyMultiple, The, AbstractDescription, ThereTemplateCoref],
[Human, CopyMultiple, The, Colour, AbstractDescription, ThereTemplateCoref],
[Human, CopyMultiple, The, Size, AbstractDescription, ThereTemplateCoref],
[Human, CopyMultiple, The, Size, Colour, AbstractDescription, ThereTemplateCoref],
[Human, CopyMultiple, The, AbstractDescription, HereTemplate],
[Human, CopyMultiple, The, Colour, AbstractDescription, HereTemplate],
[Human, CopyMultiple, The, Size, AbstractDescription, HereTemplate],
[Human, CopyMultiple, The, Size, Colour, AbstractDescription, HereTemplate],
[Human, CopyMultiple, The, AbstractDescription, HereTemplateCoref],
[Human, CopyMultiple, The, Colour, AbstractDescription, HereTemplateCoref],
[Human, CopyMultiple, The, Size, AbstractDescription, HereTemplateCoref],
[Human, CopyMultiple, The, Size, Colour, AbstractDescription, HereTemplateCoref],
[Human, CopyMultiple, The, AbstractDescription, YouTemplate],
[Human, CopyMultiple, The, Colour, AbstractDescription, YouTemplate],
[Human, CopyMultiple, The, Size, AbstractDescription, YouTemplate],
[Human, CopyMultiple, The, Size, Colour, AbstractDescription, YouTemplate],
[Human, CopyMultiple, BlockObjectThat, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThese, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThose, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThese, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThose, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, ThereTemplate],
[Human, CopyMultiple, BlockObjectThose, ThereTemplate],
[Human, CopyMultiple, BlockObjectThese, ThereTemplate],
[Human, CopyMultiple, BlockObjectThat, AbstractDescription, ThereTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, AbstractDescription, ThereTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, AbstractDescription, ThereTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, AbstractDescription, ThereTemplate],
[Human, CopyMultiple, BlockObjectThat, ThereTemplateCoref],
[Human, CopyMultiple, BlockObjectThose, ThereTemplateCoref],
[Human, CopyMultiple, BlockObjectThese, ThereTemplateCoref],
[Human, CopyMultiple, BlockObjectThat, AbstractDescription, ThereTemplateCoref],
[Human, CopyMultiple, BlockObjectThat, Colour, AbstractDescription, ThereTemplateCoref],
[Human, CopyMultiple, BlockObjectThat, Size, AbstractDescription, ThereTemplateCoref],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, AbstractDescription, ThereTemplateCoref],
[Human, CopyMultiple, BlockObjectThis, HereTemplate],
[Human, CopyMultiple, BlockObjectThis, AbstractDescription, HereTemplate],
[Human, CopyMultiple, BlockObjectThis, Colour, AbstractDescription, HereTemplate],
[Human, CopyMultiple, BlockObjectThis, Size, AbstractDescription, HereTemplate],
[Human, CopyMultiple, BlockObjectThis, Size, Colour, AbstractDescription, HereTemplate],
[Human, CopyMultiple, BlockObjectThis, HereTemplateCoref],
[Human, CopyMultiple, BlockObjectThis, AbstractDescription, HereTemplateCoref],
[Human, CopyMultiple, BlockObjectThis, Colour, AbstractDescription, HereTemplateCoref],
[Human, CopyMultiple, BlockObjectThis, Size, AbstractDescription, HereTemplateCoref],
[Human, CopyMultiple, BlockObjectThis, Size, Colour, AbstractDescription, HereTemplateCoref],
[Human, CopyMultiple, BlockObjectThat, YouTemplate],
[Human, CopyMultiple, BlockObjectThose, YouTemplate],
[Human, CopyMultiple, BlockObjectThese, YouTemplate],
[Human, CopyMultiple, BlockObjectThat, AbstractDescription, YouTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, AbstractDescription, YouTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, AbstractDescription, YouTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, AbstractDescription, YouTemplate],
# Concrete #
[Human, CopyMultiple, The, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Size, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, The, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, The, Size, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, The, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, The, ConcreteDescription, ThereTemplate],
[Human, CopyMultiple, The, Colour, ConcreteDescription, ThereTemplate],
[Human, CopyMultiple, The, Size, ConcreteDescription, ThereTemplate],
[Human, CopyMultiple, The, Size, Colour, ConcreteDescription, ThereTemplate],
[Human, CopyMultiple, The, ConcreteDescription, ThereTemplateCoref],
[Human, CopyMultiple, The, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, CopyMultiple, The, Size, ConcreteDescription, ThereTemplateCoref],
[Human, CopyMultiple, The, Size, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, CopyMultiple, The, ConcreteDescription, HereTemplate],
[Human, CopyMultiple, The, Colour, ConcreteDescription, HereTemplate],
[Human, CopyMultiple, The, Size, ConcreteDescription, HereTemplate],
[Human, CopyMultiple, The, Size, Colour, ConcreteDescription, HereTemplate],
[Human, CopyMultiple, The, ConcreteDescription, HereTemplateCoref],
[Human, CopyMultiple, The, Colour, ConcreteDescription, HereTemplateCoref],
[Human, CopyMultiple, The, Size, ConcreteDescription, HereTemplateCoref],
[Human, CopyMultiple, The, Size, Colour, ConcreteDescription, HereTemplateCoref],
[Human, CopyMultiple, The, ConcreteDescription, YouTemplate],
[Human, CopyMultiple, The, Colour, ConcreteDescription, YouTemplate],
[Human, CopyMultiple, The, Size, ConcreteDescription, YouTemplate],
[Human, CopyMultiple, The, Size, Colour, ConcreteDescription, YouTemplate],
[Human, CopyMultiple, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, ConcreteDescription, ThereTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, ConcreteDescription, ThereTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, ConcreteDescription, ThereTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, ConcreteDescription, ThereTemplate],
[Human, CopyMultiple, BlockObjectThat, ConcreteDescription, ThereTemplateCoref],
[Human, CopyMultiple, BlockObjectThat, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, CopyMultiple, BlockObjectThat, Size, ConcreteDescription, ThereTemplateCoref],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, CopyMultiple, BlockObjectThis, ConcreteDescription, HereTemplate],
[Human, CopyMultiple, BlockObjectThis, Colour, ConcreteDescription, HereTemplate],
[Human, CopyMultiple, BlockObjectThis, Size, ConcreteDescription, HereTemplate],
[Human, CopyMultiple, BlockObjectThis, Size, Colour, ConcreteDescription, HereTemplate],
[Human, CopyMultiple, BlockObjectThis, ConcreteDescription, HereTemplateCoref],
[Human, CopyMultiple, BlockObjectThis, Colour, ConcreteDescription, HereTemplateCoref],
[Human, CopyMultiple, BlockObjectThis, Size, ConcreteDescription, HereTemplateCoref],
[Human, CopyMultiple, BlockObjectThis, Size, Colour, ConcreteDescription, HereTemplateCoref],
[Human, CopyMultiple, BlockObjectThat, ConcreteDescription, YouTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, ConcreteDescription, YouTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, ConcreteDescription, YouTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, ConcreteDescription, YouTemplate],
## Single word copy command ##
[Human, CopySingle],
## Copy X ##
[Human, Copy, BlockObjectThat],
[Human, Copy, BlockObjectThese],
[Human, Copy, BlockObjectThose],
[Human, Copy, BlockObjectThis],
[Human, Copy, BlockObjectIt],
[Human, Copy, BlockObjectThat, AbstractDescription],
[Human, Copy, BlockObjectThis, AbstractDescription],
[Human, Copy, BlockObjectThat, ConcreteDescription],
[Human, Copy, BlockObjectThis, ConcreteDescription],
[Human, Copy, The, AbstractDescription],
[Human, Copy, The, ConcreteDescription],
[Human, Copy, ConcreteDescription],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription],
[Human, Copy, The, Colour, AbstractDescription],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription],
[Human, Copy, The, Colour, ConcreteDescription],
[Human, Copy, BlockObjectThat, AbstractDescription],
[Human, Copy, BlockObjectThis, AbstractDescription],
[Human, Copy, BlockObjectThat, ConcreteDescription],
[Human, Copy, BlockObjectThis, ConcreteDescription],
[Human, Copy, BlockObjectThat, Size, AbstractDescription],
[Human, Copy, BlockObjectThis, Size, AbstractDescription],
[Human, Copy, The, Size, AbstractDescription],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription],
[Human, Copy, The, Size, ConcreteDescription],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription],
[Human, Copy, The, Size, Colour, AbstractDescription],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription],
[Human, Copy, The, Size, Colour, ConcreteDescription],
## Copy X to location Y ##
[Human, Copy, BlockObjectThat, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectIt, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, The, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, The, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, The, Colour, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, The, Colour, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, The, Size, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, The, Size, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, At, LocationWord, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectIt, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Colour, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Colour, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectIt, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectIt, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, ThereTemplate],
[Human, Copy, BlockObjectIt, ThereTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, ThereTemplate],
[Human, Copy, The, AbstractDescription, ThereTemplate],
[Human, Copy, The, ConcreteDescription, ThereTemplate],
[Human, Copy, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, The, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, The, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, ThereTemplate],
[Human, Copy, The, Size, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, ThereTemplate],
[Human, Copy, The, Size, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, ThereTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, ThereTemplate],
[Human, Copy, BlockObjectThis, ThereTemplateCoref],
[Human, Copy, BlockObjectIt, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThis, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThis, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, The, AbstractDescription, ThereTemplateCoref],
[Human, Copy, The, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, The, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, The, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThis, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThis, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, ThereTemplateCoref],
[Human, Copy, The, Size, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, The, Size, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, The, Size, Colour, AbstractDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, The, Size, Colour, ConcreteDescription, ThereTemplateCoref],
[Human, Copy, BlockObjectThat, HereTemplate],
[Human, Copy, BlockObjectThis, HereTemplate],
[Human, Copy, BlockObjectIt, HereTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, HereTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, HereTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, HereTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, HereTemplate],
[Human, Copy, The, AbstractDescription, HereTemplate],
[Human, Copy, The, ConcreteDescription, HereTemplate],
[Human, Copy, ConcreteDescription, HereTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, HereTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, HereTemplate],
[Human, Copy, The, Colour, AbstractDescription, HereTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, HereTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, HereTemplate],
[Human, Copy, The, Colour, ConcreteDescription, HereTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, HereTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, HereTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, HereTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, HereTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, HereTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, HereTemplate],
[Human, Copy, The, Size, AbstractDescription, HereTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, HereTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, HereTemplate],
[Human, Copy, The, Size, ConcreteDescription, HereTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, HereTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, HereTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, HereTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, HereTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, HereTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, HereTemplate],
[Human, Copy, BlockObjectThat, HereTemplateCoref],
[Human, Copy, BlockObjectThis, HereTemplateCoref],
[Human, Copy, BlockObjectIt, HereTemplateCoref],
[Human, Copy, BlockObjectThat, AbstractDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThis, AbstractDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThat, ConcreteDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThis, ConcreteDescription, HereTemplateCoref],
[Human, Copy, The, AbstractDescription, HereTemplateCoref],
[Human, Copy, The, ConcreteDescription, HereTemplateCoref],
[Human, Copy, ConcreteDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, HereTemplateCoref],
[Human, Copy, The, Colour, AbstractDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, HereTemplateCoref],
[Human, Copy, The, Colour, ConcreteDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThat, AbstractDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThis, AbstractDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThat, ConcreteDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThis, ConcreteDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, HereTemplateCoref],
[Human, Copy, The, Size, AbstractDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, HereTemplateCoref],
[Human, Copy, The, Size, ConcreteDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, HereTemplateCoref],
[Human, Copy, The, Size, Colour, AbstractDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, HereTemplateCoref],
[Human, Copy, The, Size, Colour, ConcreteDescription, HereTemplateCoref],
[Human, Copy, BlockObjectThis, YouTemplate],
[Human, Copy, BlockObjectIt, YouTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, YouTemplate],
[Human, Copy, The, AbstractDescription, YouTemplate],
[Human, Copy, The, ConcreteDescription, YouTemplate],
[Human, Copy, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, YouTemplate],
[Human, Copy, The, Colour, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, The, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, YouTemplate],
[Human, Copy, The, Size, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, YouTemplate],
[Human, Copy, The, Size, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, YouTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, YouTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, YouTemplate],
[Human, Copy, BlockObjectThat, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectIt, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectIt, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectIt, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThis, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectIt, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, The, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, The, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, The, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, The, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, The, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, The, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, Copy, BlockObjectThat, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectIt, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectIt, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, Copy, BlockObjectThat, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectIt, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
## rel_dir of BlockObjectThat templates ##
[Human, Copy, RepeatCount, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatCount, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatCount, Size, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatCount, Size, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatCount, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatCount, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatCount, Size, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, Size, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, Size, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThat, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThose, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThese, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThat, Size, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, Size, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThat, Size, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, The, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, The, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, The, Size, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, The, Size, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThat, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThese, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThose, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThat, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThat, Size, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, The, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, The, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, The, Size, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, The, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThat, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThat, Size, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectIt, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, Colour, AbstractDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, Colour, ConcreteDescription, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectIt, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, Colour, AbstractDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, Colour, ConcreteDescription, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectIt, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, Colour, AbstractDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
[Human, Copy, The, Size, Colour, ConcreteDescription, ALittle, RelativeDirectionTemplate, BlockObjectThat],
# between templates
[Human, Copy, BlockObjectThat, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThose, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThese, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Size, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Size, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Size, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThose, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThese, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Size, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, Size, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Size, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Size, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThese, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThose, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Size, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, The, Size, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectIt, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, The, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, The, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, The, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, The, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, The, Size, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, The, Size, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, Copy, BlockObjectThat, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThose, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThese, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatCount, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatCount, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatCount, Size, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatCount, Size, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, RepeatCount, Size, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, Size, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, Size, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThose, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThese, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, Size, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, Size, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, RepeatAll, BlockObjectThat, Size, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, The, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, The, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, The, Size, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, The, Size, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThese, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThose, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, The, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, The, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, The, Size, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, The, Size, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, CopyMultiple, BlockObjectThat, Size, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectIt, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, The, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, The, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, The, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, The, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThis, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThis, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, The, Size, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, The, Size, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, The, Size, Colour, AbstractDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThat, Size, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, BlockObjectThis, Size, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, Copy, The, Size, Colour, ConcreteDescription, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/copy_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
'''
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Freebuild templates are written for :
- either a BlockObject or a Location.
and represents the intent for the action: Freebuild.
This action intends for a generation model to complete or finish something that
is half-built.
Examples:
[Human, Freebuild, The, Colour, AbstractDescription, BlockObjectLocation]
- complete the red structure to the left of that grey shape.
- finish the blue thing at location: 2 , 3, 4 for me
[Human, Freebuild, BlockObjectThat, Size, Colour, AbstractDescription]
- complete that huge red structure
- finish that tiny blue thing for me please
etc
'''
from template_objects import *
FREEBUILD_WITH_CORRECTION = [
[[Human, FreebuildLocation, ThereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, FreebuildLocation, HereTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, FreebuildLocation, HereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, FreebuildLocation, YouTemplate],
[HumanReplace, RelativeDirectionTemplate, LocationMobTemplate]],
[[Human, FreebuildLocation, ThereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, FreebuildLocation, HereTemplate],
[HumanReplace, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, FreebuildLocation, HereTemplateCoref],
[HumanReplace, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, FreebuildLocation, YouTemplate],
[HumanReplace, RelativeDirectionTemplate, BlockObjectThat]],
[[Human, Freebuild, BlockObjectThat, ForMe],
[HumanReplace, The, Colour, AbstractDescription]],
[[Human, Freebuild, BlockObjectThat, ForMe],
[HumanReplace, The, Size, AbstractDescription]],
[[Human, Freebuild, BlockObjectThat, ForMe],
[HumanReplace, The, Size, Colour, AbstractDescription]],
[[Human, Freebuild, BlockObjectThis, ForMe],
[HumanReplace, The, Colour, AbstractDescription]],
[[Human, Freebuild, BlockObjectThis, ForMe],
[HumanReplace, The, Size, AbstractDescription]],
[[Human, Freebuild, BlockObjectThis, ForMe],
[HumanReplace, The, Size, Colour, AbstractDescription]],
[[Human, Freebuild, BlockObjectIt, ForMe],
[HumanReplace, The, Colour, AbstractDescription]],
[[Human, Freebuild, BlockObjectIt, ForMe],
[HumanReplace, The, Size, AbstractDescription]],
[[Human, Freebuild, BlockObjectIt, ForMe],
[HumanReplace, The, Size, Colour, AbstractDescription]],
[[Human, Freebuild, BlockObjectThat, Colour, AbstractDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, BlockObjectThis, Colour, AbstractDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, The, Colour, AbstractDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, BlockObjectThat, Colour, ConcreteDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, BlockObjectThis, Colour, ConcreteDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, The, Colour, ConcreteDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, BlockObjectThat, AbstractDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, BlockObjectThat, AbstractDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, BlockObjectThat, AbstractDescription, ForMe],
[HumanReplace, The, Size, Colour, One]],
[[Human, Freebuild, BlockObjectThis, AbstractDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, BlockObjectThis, AbstractDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, BlockObjectThis, AbstractDescription, ForMe],
[HumanReplace, The, Size, Colour, One]],
[[Human, Freebuild, BlockObjectThat, ConcreteDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, BlockObjectThat, ConcreteDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, BlockObjectThat, ConcreteDescription, ForMe],
[HumanReplace, The, Size, Colour, One]],
[[Human, Freebuild, BlockObjectThis, ConcreteDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, BlockObjectThis, ConcreteDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, BlockObjectThis, ConcreteDescription, ForMe],
[HumanReplace, The, Size, Colour, One]],
[[Human, Freebuild, BlockObjectThat, Size, AbstractDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, BlockObjectThis, Size, AbstractDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, The, Size, AbstractDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, BlockObjectThat, Size, ConcreteDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, BlockObjectThis, Size, ConcreteDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, The, Size, ConcreteDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, The, Size, AbstractDescription, BlockObjectLocation, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, The, Size, ConcreteDescription, BlockObjectLocation, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, RepeatCount, ConcreteDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, RepeatCount, ConcreteDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, RepeatCount, ConcreteDescription, ForMe],
[HumanReplace, The, Size, Colour, One]],
[[Human, Freebuild, RepeatCount, Colour, ConcreteDescription, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, RepeatCount, Size, AbstractDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, RepeatCount, Size, ConcreteDescription, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, RepeatCount, Size, AbstractDescription, BlockObjectLocation, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, RepeatCount, Size, ConcreteDescription, BlockObjectLocation, ForMe],
[HumanReplace, The, Colour, One]],
[[Human, Freebuild, RepeatCount, Colour, AbstractDescription, BlockObjectLocation, ForMe],
[HumanReplace, The, Size, One]],
[[Human, Freebuild, RepeatCount, Colour, ConcreteDescription, BlockObjectLocation, ForMe],
[HumanReplace, The, Size, One]],
]
FREEBUILD_TEMPLATES = [
## Freebuild with only Location ##
[Human, FreebuildLocation, At, LocationWord, CoordinatesTemplate],
[Human, FreebuildLocation, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, FreebuildLocation, Between, LocationBlockObjectTemplate, And, LocationMobTemplate],
[Human, FreebuildLocation, Between, LocationMobTemplate, And, LocationBlockObjectTemplate],
[Human, FreebuildLocation, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, FreebuildLocation, RelativeDirectionTemplate, LocationMobTemplate],
[Human, FreebuildLocation, RelativeDirectionTemplate, BlockObjectThat],
[Human, FreebuildLocation, ThereTemplate],
[Human, FreebuildLocation, ThereTemplateCoref],
[Human, FreebuildLocation, HereTemplate],
[Human, FreebuildLocation, HereTemplateCoref],
[Human, FreebuildLocation, YouTemplate],
[Human, FreebuildLocation, StepsTemplate, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, FreebuildLocation, StepsTemplate, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, FreebuildLocation, StepsTemplate, RelativeDirectionTemplate, LocationMobTemplate],
[Human, FreebuildLocation, StepsTemplate, RelativeDirectionTemplate, BlockObjectThat],
[Human, FreebuildLocation, ALittle, RelativeDirectionTemplate, YouTemplate],
[Human, FreebuildLocation, ALittle, RelativeDirectionTemplate, LocationBlockObjectTemplate],
[Human, FreebuildLocation, ALittle, RelativeDirectionTemplate, LocationMobTemplate],
[Human, FreebuildLocation, ALittle, RelativeDirectionTemplate, CoordinatesTemplate],
[Human, FreebuildLocation, ALittle, RelativeDirectionTemplate, BlockObjectThat],
## Freebuild with only BlockObject ##
[Human, Freebuild, BlockObjectThat, ForMe],
[Human, Freebuild, BlockObjectThis, ForMe],
[Human, Freebuild, BlockObjectIt, ForMe],
[Human, Freebuild, BlockObjectThat, AbstractDescription, ForMe],
[Human, Freebuild, BlockObjectThis, AbstractDescription, ForMe],
[Human, Freebuild, BlockObjectThat, ConcreteDescription, ForMe],
[Human, Freebuild, BlockObjectThis, ConcreteDescription, ForMe],
[Human, Freebuild, The, ConcreteDescription, ForMe],
[Human, Freebuild, ConcreteDescription, ForMe],
[Human, Freebuild, The, AbstractDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, The, ConcreteDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, BlockObjectThat, Colour, AbstractDescription, ForMe],
[Human, Freebuild, BlockObjectThis, Colour, AbstractDescription, ForMe],
[Human, Freebuild, The, Colour, AbstractDescription, ForMe],
[Human, Freebuild, BlockObjectThat, Colour, ConcreteDescription, ForMe],
[Human, Freebuild, BlockObjectThis, Colour, ConcreteDescription, ForMe],
[Human, Freebuild, The, Colour, ConcreteDescription, ForMe],
[Human, Freebuild, BlockObjectThat, AbstractDescription, ForMe],
[Human, Freebuild, BlockObjectThis, AbstractDescription, ForMe],
[Human, Freebuild, BlockObjectThat, ConcreteDescription, ForMe],
[Human, Freebuild, BlockObjectThis, ConcreteDescription, ForMe],
[Human, Freebuild, BlockObjectThat, Size, AbstractDescription, ForMe],
[Human, Freebuild, BlockObjectThis, Size, AbstractDescription, ForMe],
[Human, Freebuild, The, Size, AbstractDescription, ForMe],
[Human, Freebuild, BlockObjectThat, Size, ConcreteDescription, ForMe],
[Human, Freebuild, BlockObjectThis, Size, ConcreteDescription, ForMe],
[Human, Freebuild, The, Size, ConcreteDescription, ForMe],
[Human, Freebuild, The, Size, AbstractDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, The, Size, ConcreteDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, The, Colour, AbstractDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, The, Colour, ConcreteDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, BlockObjectThat, Size, Colour, AbstractDescription, ForMe],
[Human, Freebuild, BlockObjectThis, Size, Colour, AbstractDescription, ForMe],
[Human, Freebuild, The, Size, Colour, AbstractDescription, ForMe],
[Human, Freebuild, BlockObjectThat, Size, Colour, ConcreteDescription, ForMe],
[Human, Freebuild, BlockObjectThis, Size, Colour, ConcreteDescription, ForMe],
[Human, Freebuild, The, Size, Colour, ConcreteDescription, ForMe],
[Human, Freebuild, The, Size, Colour, AbstractDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, The, Size, Colour, ConcreteDescription, BlockObjectLocation, ForMe],
### Freebuild num X ###
[Human, Freebuild, RepeatCount, ConcreteDescription, ForMe],
[Human, Freebuild, RepeatCount, Colour, ConcreteDescription, ForMe],
[Human, Freebuild, RepeatCount, Size, AbstractDescription, ForMe],
[Human, Freebuild, RepeatCount, Size, ConcreteDescription, ForMe],
[Human, Freebuild, RepeatCount, Size, AbstractDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, RepeatCount, Size, ConcreteDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, RepeatCount, Colour, AbstractDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, RepeatCount, Colour, ConcreteDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, RepeatCount, Size, Colour, AbstractDescription, ForMe],
[Human, Freebuild, RepeatCount, Size, Colour, ConcreteDescription, ForMe],
[Human, Freebuild, RepeatCount, Size, Colour, AbstractDescription, BlockObjectLocation, ForMe],
[Human, Freebuild, RepeatCount, Size, Colour, ConcreteDescription, BlockObjectLocation, ForMe],
### Freebuild X in front of num Y ###
[Human, Freebuild, The, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, The, Size, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, The, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, The, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, The, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, The, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
### Freebuild num X in front of num Y ###
[Human, Freebuild, RepeatCount, AbstractDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, RepeatCount, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, RepeatCount, Size, AbstractDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, RepeatCount, Size, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, RepeatCount, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, RepeatCount, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, RepeatCount, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
[Human, Freebuild, RepeatCount, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, ForMe],
### Freebuild All X in front of Y ###
[Human, Freebuild, All, ConcreteDescription, RepeatAll, ForMe],
[Human, Freebuild, Every, ConcreteDescription, RepeatAll, ForMe],
[Human, Freebuild, All, Colour, ConcreteDescription, RepeatAll, ForMe],
[Human, Freebuild, Every, Colour, ConcreteDescription, RepeatAll, ForMe],
[Human, Freebuild, All, Colour, AbstractDescription, RepeatAll, ForMe],
[Human, Freebuild, Every, Colour, AbstractDescription, RepeatAll, ForMe],
[Human, Freebuild, All, Size, AbstractDescription, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, AbstractDescription, RepeatAll, ForMe],
[Human, Freebuild, All, Size, ConcreteDescription, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, ConcreteDescription, RepeatAll, ForMe],
[Human, Freebuild, All, Size, AbstractDescription, BlockObjectLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Size, ConcreteDescription, BlockObjectLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, AbstractDescription, BlockObjectLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, ConcreteDescription, BlockObjectLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Colour, AbstractDescription, BlockObjectLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Colour, ConcreteDescription, BlockObjectLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Colour, AbstractDescription, BlockObjectLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Colour, ConcreteDescription, BlockObjectLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Size, Colour, AbstractDescription, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, Colour, AbstractDescription, RepeatAll, ForMe],
[Human, Freebuild, All, Size, Colour, ConcreteDescription, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, Colour, ConcreteDescription, RepeatAll, ForMe],
[Human, Freebuild, All, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAll, ForMe],
### Freebuild X in front of all Ys ###
[Human, Freebuild, The, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, The, Size, AbstractDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, The, Size, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, The, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, The, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, The, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, The, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
### Freebuild all X in front of all Ys ###
[Human, Freebuild, All, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Size, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Size, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, RepeatAll, ForMe],
### Freebuild all X in front of n Ys ###
[Human, Freebuild, All, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Size, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Size, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, All, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
[Human, Freebuild, Every, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatCountLocation, RepeatAll, ForMe],
### Freebuild n X in front of all Ys ###
[Human, Freebuild, RepeatCount, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, RepeatCount, Size, AbstractDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, RepeatCount, Size, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, RepeatCount, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, RepeatCount, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, RepeatCount, Size, Colour, AbstractDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
[Human, Freebuild, RepeatCount, Size, Colour, ConcreteDescription, BlockObjectLocation, RepeatAllLocation, ForMe],
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/freebuild_templates.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# fmt: off
'''
Every template contains an ordered list of TemplateObjects.
TemplateObject is defined in template_objects.py
Dance templates are written with an optional location and stop condition.
Examples:
[Human, DanceSingle]
- do a dance
- dance
[Human, DanceSingle, ConditionTypeNever],
- keep dancing
- dance until I tell you to stop
'''
from template_objects import *
DANCE_WITH_CORRECTION = [
[[Human, Dance],
[HumanReplace, Dance, AroundString]],
[[Human, Jump],
[HumanReplace, Jump, AroundString]],
[[Human, Fly],
[HumanReplace, Fly, AroundString]],
[[Human, Hop],
[HumanReplace, Hop, AroundString]],
]
DANCE_TEMPLATES = [
## Dance single word ##
[Human, Dance],
[Human, Dance, ConditionTypeNever],
[Human, Fly],
[Human, Fly, ConditionTypeNever],
[Human, Jump],
[Human, Jump, ConditionTypeNever],
[Human, Hop],
[Human, Hop, ConditionTypeNever],
## Walk around X ##
[Human, Fly, AroundString, LocationBlockObjectTemplate],
[Human, Jump, AroundString, LocationBlockObjectTemplate],
[Human, Hop, AroundString, LocationBlockObjectTemplate],
[Human, Dance, AroundString, LocationBlockObjectTemplate],
[Human, Walk, AroundString, LocationBlockObjectTemplate],
## Move around X clockwise / anticlockwise ##
[Human, Fly, AroundString, LocationBlockObjectTemplate, RelativeDirectionTemplate],
[Human, Jump, AroundString, LocationBlockObjectTemplate, RelativeDirectionTemplate],
[Human, Hop, AroundString, LocationBlockObjectTemplate, RelativeDirectionTemplate],
[Human, Dance, AroundString, LocationBlockObjectTemplate, RelativeDirectionTemplate],
[Human, Walk, AroundString, LocationBlockObjectTemplate, RelativeDirectionTemplate],
## move around X clockwise/anticlockwise n times ##
[Human, Dance, NTimes],
[Human, Fly, NTimes],
[Human, Jump, NTimes],
[Human, Hop, NTimes],
[Human, Fly, AroundString, LocationBlockObjectTemplate, RelativeDirectionTemplate, NTimes],
[Human, Jump, AroundString, LocationBlockObjectTemplate, RelativeDirectionTemplate, NTimes],
[Human, Hop, AroundString, LocationBlockObjectTemplate, RelativeDirectionTemplate, NTimes],
[Human, Dance, AroundString, LocationBlockObjectTemplate, RelativeDirectionTemplate, NTimes],
[Human, Walk, AroundString, LocationBlockObjectTemplate, RelativeDirectionTemplate, NTimes],
]
| craftassist-master | python/base_agent/ttad/generation_dialogues/templates/dance_templates.py |
import torch
from dataset import *
from huggingface_modeling_gpt2 import *
from transformer import *
def compute_accuracy(outputs, y, tokenizer):
"""Compute model accuracy given predictions and targets. Used in validation.
"""
# Do not include [CLS] token
target_tokens = y[:, 1:]
predicted_tokens = outputs.max(dim=-1)[1][:, :-1]
acc = (predicted_tokens == target_tokens).sum(dim=1) == target_tokens.shape[-1]
return acc
def validate(model, dataset, tokenizer):
valid_loader = torch.utils.data.DataLoader(dataset=dataset, batch_size=1, shuffle=False)
tot_acc = 0.0
tot_loss = 0.0
steps = 0
with torch.no_grad():
for i, batch in enumerate(valid_loader):
trees, text = batch
text_idx_ls = [tokenizer.encode(cmd) for cmd in text]
tree_idx_ls = [tokenizer.encode(tree) for tree in trees]
x, x_mask, y, y_mask = collate(tree_idx_ls, text_idx_ls, tokenizer)
out = model(x, x_mask, y, y_mask)
loss, predictions = out[:2]
lm_acc = compute_accuracy(predictions, y, tokenizer)
acc = lm_acc.sum().item() / lm_acc.shape[0]
tot_acc += acc
tot_loss += loss.item()
steps += 1
print("Valid accuracy: {} Loss: {}".format(tot_acc / steps, tot_loss / steps))
| craftassist-master | python/base_agent/ttad/back_translation/train_utils.py |
from transformers import GPT2Tokenizer, BertTokenizer
from dataset import *
# from transformers.modeling_gpt2 import *
from huggingface_modeling_gpt2 import *
from transformer import *
import argparse
import numpy as np
import torch.nn.functional as F
# make sure GPT2 appends EOS in begin and end
def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None):
outputs = [self.bos_token_id] + token_ids_0 + [self.eos_token_id]
return outputs
class QueryModel:
def __init__(self, model, encoder_tokenizer, decoder_tokenizer):
self.model = model
self.encoder_tokenizer = encoder_tokenizer
self.decoder_tokenizer = decoder_tokenizer
def top_k_sampling(self, y, y_mask, x_reps, x_mask, ntok):
orig_mask = y_mask
for _ in range(ntok):
out = self.model.decoder(
input_ids=y,
attention_mask=y_mask,
encoder_hidden_states=x_reps,
encoder_attention_mask=x_mask,
# use_lm=True,
)[0]
logits = out[:, -1, :]
indices_to_remove = logits < torch.topk(logits, 10)[0][..., -1, None]
logits[indices_to_remove] = np.NINF
next_tok = torch.multinomial(nn.Softmax(dim=-1)(logits), num_samples=1).squeeze(1)
y = torch.cat([y, next_tok.unsqueeze(-1)], dim=-1)
y_mask = F.pad(orig_mask, pad=(0, y.shape[-1] - 1), mode="constant", value=1)
if next_tok == self.decoder_tokenizer.eos_token_id:
return y
return y
def generate(self, tree_input, top_k=0, beam_size=0):
model_device = self.model.encoder.device
text_idx_ls = [[self.decoder_tokenizer.eos_token_id]]
tree_idx_ls = [self.encoder_tokenizer.encode(tree_input, add_special_tokens=True)]
batch = collate(tree_idx_ls, text_idx_ls, self.encoder_tokenizer, self.decoder_tokenizer)
batch = [torch.tensor(t) for t in batch[:4]]
batch = [t.to(model_device) for t in batch[:4]]
x, x_mask, y, y_mask = batch
x_reps = self.model.encoder(input_ids=x, attention_mask=x_mask)[0].detach()
if top_k > 0:
out = self.top_k_sampling(y, y_mask, x_reps, x_mask, top_k)
return self.decoder_tokenizer.decode(out[0])
if beam_size > 1:
# NOTE: beam search is WIP
x_mask = x_mask.expand(beam_size, -1)
x_reps = x_reps.expand(beam_size, -1, -1)
y = torch.LongTensor(
[[self.decoder_tokenizer.eos_token_id] for _ in range(beam_size)]
).to(model_device)
beam_scores = torch.Tensor([-1e9 for _ in range(beam_size)]).to(model_device) # B
beam_scores[0] = 0
finished = [False for _ in range(beam_size)]
else:
# defaults to greedy
y = torch.LongTensor([[self.decoder_tokenizer.eos_token_id]]).to(model_device)
beam_scores = torch.Tensor([-1e9]).to(model_device)
beam_scores[0] = 0
preds = [
[self.decoder_tokenizer._convert_id_to_token(self.decoder_tokenizer.eos_token_id)]
]
finished = [False]
pad_scores = torch.Tensor([-1e9] * self.decoder_tokenizer.vocab_size).to(model_device)
for i in range(20):
outputs = self.model.decoder(
input_ids=y,
attention_mask=y_mask,
encoder_hidden_states=x_reps,
encoder_attention_mask=x_mask,
# use_lm=True,
)[0]
predicted_scores = outputs[:, -1, :]
for i, fshed in enumerate(finished):
if fshed:
predicted_scores[i] = pad_scores
total_scores = predicted_scores + beam_scores[:, None]
linearized_scores = total_scores.view(-1)
sorted_scores, sorted_ids = linearized_scores.sort(dim=-1, descending=True)
# all 0 for now
seq_ids = sorted_ids // total_scores.shape[-1]
s_word_ids = sorted_ids % total_scores.shape[-1]
# just taking first and only element for now
beam_scores = sorted_scores[:1]
# beam size of 1
beam_ids = seq_ids[:1]
word_ids = s_word_ids[:1]
words = [self.decoder_tokenizer.decode(word_ids)]
# add next token
y = torch.cat([y[beam_ids], word_ids[:, None]], dim=1)
# find out whether sequence is finished; currently only one sequence
pre_finished = [finished[b_id.item()] for b_id in beam_ids]
new_finished = [
w_id.item() == self.decoder_tokenizer.eos_token_id for w_id in word_ids
]
finished = [p or n for p, n in zip(pre_finished, new_finished)]
n_mask = 1 - torch.Tensor(finished).type_as(y_mask)
y_mask = torch.cat([y_mask[beam_ids], n_mask[:, None]], dim=1)
preds = [preds[0] + [(words[0])]]
# check whether sequence has reached EOS; currently only one sequence
if finished[0]:
break
return " ".join(preds[0])
parser = argparse.ArgumentParser()
parser.add_argument(
"--pretrained_encoder_path",
default="python/craftassist/models/backtranslation/encoder/",
type=str,
help="path to binarized model and config of saved encoder",
)
parser.add_argument(
"--pretrained_decoder_path",
default="python/craftassist/models/backtranslation/decoder/",
type=str,
help="path to binarized model and config of saved decoder",
)
args = parser.parse_args()
bert_tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
bert_tokenizer.bos_token = bert_tokenizer.cls_token
bert_tokenizer.eos_token = bert_tokenizer.sep_token
gpt2_tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
gpt2_tokenizer.pad_token = gpt2_tokenizer.unk_token
GPT2Tokenizer.build_inputs_with_special_tokens = build_inputs_with_special_tokens
enc_model = BertModel.from_pretrained(args.pretrained_encoder_path)
dec_model = GPT2LMHeadModel.from_pretrained(args.pretrained_decoder_path)
encoder_decoder = EncoderDecoder(enc_model, dec_model)
generator = QueryModel(encoder_decoder, bert_tokenizer, gpt2_tokenizer)
| craftassist-master | python/base_agent/ttad/back_translation/generate.py |
from transformers import AutoConfig, AutoTokenizer
from dataset import *
from modeling_gpt2 import *
from transformer import *
from torch.utils.data import DataLoader
import argparse
from os.path import join as pjoin
import torch
from train_utils import *
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--data_dir",
default="/checkpoint/rebeccaqian/datasets/fairseq/08_04/",
type=str,
help="train/valid/test data",
)
parser.add_argument(
"--output_dir",
default="/checkpoint/rebeccaqian/backtranslation/{}/models/".format(str(date.today())),
type=str,
help="directory to save checkpoint models",
)
parser.add_argument("--lr", default=0.0001, type=float, help="learning rate")
parser.add_argument("--batch_size", default=1, type=int, help="batch size")
parser.add_argument("--num_epochs", default=20, type=int, help="number of epochs")
args = parser.parse_args()
config_decoder = AutoConfig.from_pretrained("gpt2", is_decoder=True)
config_encoder = AutoConfig.from_pretrained("gpt2", is_decoder=False)
tokenizer = AutoTokenizer.from_pretrained("gpt2")
enc_model = GPT2Model(config=config_encoder)
dec_model = GPT2LMHeadModel.from_pretrained("gpt2", config=config_decoder)
encoder_decoder = EncoderDecoder(enc_model, dec_model)
# freeze decoder weights
decoder_params = dec_model.named_parameters()
for name, param in decoder_params:
param.requires_grad = False
train_prog_data, train_chat_data = load_paired_dataset(args.data_dir, "train")
train_dataset = Tree2TextDataset(train_prog_data, train_chat_data)
train_loader = DataLoader(dataset=train_dataset, batch_size=1, shuffle=True)
valid_prog_data, valid_chat_data = load_paired_dataset(args.data_dir, "valid")
valid_dataset = Tree2TextDataset(valid_prog_data, valid_chat_data)
optimizer = torch.optim.Adam(encoder_decoder.parameters(), lr=args.lr)
for epoch in range(args.num_epochs):
print("Epoch: {}".format(epoch))
enc_model.train()
dec_model.train()
for i, batch in enumerate(train_loader):
trees, text = batch
optimizer.zero_grad()
text_idx_ls = [tokenizer.encode(cmd) for cmd in text]
tree_idx_ls = [tokenizer.encode(tree) for tree in trees]
x, x_mask, y, y_mask = collate(tree_idx_ls, text_idx_ls, tokenizer)
outputs = encoder_decoder(x, x_mask, y, y_mask)
loss, predictions = outputs[:2]
# Taking the first row in the batch as logging example
predicted_example = predictions.max(dim=-1)[1][:, :-1]
predicted_sentence = tokenizer.decode(predicted_example[0])
print(
"sample predictions:\n X: {} Y: {} predicted: {}".format(
trees[0], text[0], predicted_sentence
)
)
loss.backward()
optimizer.step()
print("Iteration: {} Loss: {}".format(i, loss))
torch.save(
encoder_decoder.state_dict(),
pjoin("{}encoder|(ep=={}).pth".format(args.output_dir, epoch)),
)
# Evaluating model
encoder_decoder.eval()
print("Evaluating model")
validate(encoder_decoder, valid_dataset, tokenizer)
if __name__ == "__main__":
main()
| craftassist-master | python/base_agent/ttad/back_translation/train_custom_gpt2.py |
# coding=utf-8
# Copyright 2018 The OpenAI Team Authors and HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""PyTorch OpenAI GPT-2 model."""
import logging
import os
import warnings
import torch
import torch.nn as nn
from torch.nn import CrossEntropyLoss
from transformers.modeling_gpt2 import PreTrainedModel, GPT2Config
from transformers.modeling_outputs import (
BaseModelOutputWithPast,
CausalLMOutputWithPast,
GPT2DoubleHeadsModelOutput,
)
from transformers.activations import ACT2FN
from transformers.modeling_utils import (
Conv1D,
prune_conv1d_layer,
SequenceSummary,
find_pruneable_heads_and_indices,
)
logger = logging.getLogger(__name__)
_CONFIG_FOR_DOC = "GPT2Config"
_TOKENIZER_FOR_DOC = "GPT2Tokenizer"
GPT2_PRETRAINED_MODEL_ARCHIVE_LIST = [
"gpt2",
"gpt2-medium",
"gpt2-large",
"gpt2-xl",
"distilgpt2",
# See all GPT-2 models at https://huggingface.co/models?filter=gpt2
]
def load_tf_weights_in_gpt2(model, config, gpt2_checkpoint_path):
""" Load tf checkpoints in a pytorch model
"""
try:
import re
import tensorflow as tf
except ImportError:
logger.error(
"Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see "
"https://www.tensorflow.org/install/ for installation instructions."
)
raise
tf_path = os.path.abspath(gpt2_checkpoint_path)
logger.info("Converting TensorFlow checkpoint from {}".format(tf_path))
# Load weights from TF model
init_vars = tf.train.list_variables(tf_path)
names = []
arrays = []
for name, shape in init_vars:
logger.info("Loading TF weight {} with shape {}".format(name, shape))
array = tf.train.load_variable(tf_path, name)
names.append(name)
arrays.append(array.squeeze())
for name, array in zip(names, arrays):
name = name[6:] # skip "model/"
name = name.split("/")
pointer = model
for m_name in name:
if re.fullmatch(r"[A-Za-z]+\d+", m_name):
scope_names = re.split(r"(\d+)", m_name)
else:
scope_names = [m_name]
if scope_names[0] == "w" or scope_names[0] == "g":
pointer = getattr(pointer, "weight")
elif scope_names[0] == "b":
pointer = getattr(pointer, "bias")
elif scope_names[0] == "wpe" or scope_names[0] == "wte":
pointer = getattr(pointer, scope_names[0])
pointer = getattr(pointer, "weight")
else:
pointer = getattr(pointer, scope_names[0])
if len(scope_names) >= 2:
num = int(scope_names[1])
pointer = pointer[num]
try:
assert (
pointer.shape == array.shape
), f"Pointer shape {pointer.shape} and array shape {array.shape} mismatched"
except AssertionError as e:
e.args += (pointer.shape, array.shape)
raise
logger.info("Initialize PyTorch weight {}".format(name))
pointer.data = torch.from_numpy(array)
return model
class Attention(nn.Module):
def __init__(self, nx, n_ctx, config, scale=False):
super().__init__()
n_state = nx # in Attention: n_state=768 (nx=n_embd)
# [switch nx => n_state from Block to Attention to keep identical to TF implem]
assert n_state % config.n_head == 0
self.register_buffer(
"bias",
torch.tril(torch.ones((n_ctx, n_ctx), dtype=torch.uint8)).view(1, 1, n_ctx, n_ctx),
)
self.register_buffer("masked_bias", torch.tensor(-1e4))
self.n_head = config.n_head
self.split_size = n_state
self.scale = scale
self.c_attn = Conv1D(n_state * 3, nx)
# TODO: check config.hidden_size
self.query = nn.Linear(n_state, nx)
self.key = nn.Linear(n_state, nx)
self.value = nn.Linear(n_state, nx)
self.c_proj = Conv1D(n_state, nx)
self.attn_dropout = nn.Dropout(config.attn_pdrop)
self.resid_dropout = nn.Dropout(config.resid_pdrop)
self.pruned_heads = set()
self.config = config
def prune_heads(self, heads):
if len(heads) == 0:
return
heads, index = find_pruneable_heads_and_indices(
heads, self.n_head, self.split_size // self.n_head, self.pruned_heads
)
index_attn = torch.cat([index, index + self.split_size, index + (2 * self.split_size)])
# Prune conv1d layers
self.c_attn = prune_conv1d_layer(self.c_attn, index_attn, dim=1)
self.c_proj = prune_conv1d_layer(self.c_proj, index, dim=0)
# Update hyper params
self.split_size = (self.split_size // self.n_head) * (self.n_head - len(heads))
self.n_head = self.n_head - len(heads)
self.pruned_heads = self.pruned_heads.union(heads)
def _attn(self, q, k, v, attention_mask=None, head_mask=None, output_attentions=False):
w = torch.matmul(q, k)
if self.scale:
w = w / (float(v.size(-1)) ** 0.5)
nd, ns = w.size(-2), w.size(-1)
mask = self.bias[:, :, ns - nd : ns, :ns]
w = torch.where(mask.bool(), w, self.masked_bias.to(w.dtype))
if attention_mask is not None:
# Apply the attention mask
w = w + attention_mask
w = nn.Softmax(dim=-1)(w)
w = self.attn_dropout(w)
# Mask heads if we want to
if head_mask is not None:
w = w * head_mask
outputs = [torch.matmul(w, v)]
if output_attentions:
outputs.append(w)
return outputs
def merge_heads(self, x):
x = x.permute(0, 2, 1, 3).contiguous()
new_x_shape = x.size()[:-2] + (x.size(-2) * x.size(-1),)
return x.view(*new_x_shape) # in Tensorflow implem: fct merge_states
def split_heads(self, x, k=False):
new_x_shape = x.size()[:-1] + (self.n_head, x.size(-1) // self.n_head)
x = x.view(*new_x_shape) # in Tensorflow implem: fct split_states
if k:
return x.permute(0, 2, 3, 1) # (batch, head, head_features, seq_length)
else:
return x.permute(0, 2, 1, 3) # (batch, head, seq_length, head_features)
def forward(
self,
x,
layer_past=None,
attention_mask=None,
head_mask=None,
use_cache=False,
output_attentions=False,
encoder_hidden_states=None,
encoder_attention_mask=None,
):
if self.config.is_decoder:
assert encoder_hidden_states is not None
key = self.key(encoder_hidden_states)
value = self.value(encoder_hidden_states)
query = self.query(x)
else:
x = self.c_attn(x)
query, key, value = x.split(self.split_size, dim=2)
query = self.split_heads(query)
key = self.split_heads(key, k=True)
value = self.split_heads(value)
if layer_past is not None:
past_key, past_value = (
layer_past[0].transpose(-2, -1),
layer_past[1],
) # transpose back cf below
key = torch.cat((past_key, key), dim=-1)
value = torch.cat((past_value, value), dim=-2)
if use_cache is True:
present = torch.stack(
(key.transpose(-2, -1), value)
) # transpose to have same shapes for stacking
else:
present = (None,)
if self.config.is_decoder:
attn_outputs = self._attn(
query, key, value, encoder_attention_mask, head_mask, output_attentions
)
else:
attn_outputs = self._attn(
query, key, value, attention_mask, head_mask, output_attentions
)
at = attn_outputs[0]
at = self.merge_heads(at)
at = self.c_proj(at)
at = self.resid_dropout(at)
outputs = [at, present] + attn_outputs[1:]
return outputs # a, present, (attentions)
class MLP(nn.Module):
def __init__(self, n_state, config): # in MLP: n_state=3072 (4 * n_embd)
super().__init__()
nx = config.n_embd
self.c_fc = Conv1D(n_state, nx)
self.c_proj = Conv1D(nx, n_state)
self.act = ACT2FN[config.activation_function]
self.dropout = nn.Dropout(config.resid_pdrop)
def forward(self, x):
h = self.act(self.c_fc(x))
h2 = self.c_proj(h)
return self.dropout(h2)
class Block(nn.Module):
def __init__(self, n_ctx, config, scale=False):
super().__init__()
nx = config.n_embd
inner_dim = config.n_inner if config.n_inner is not None else 4 * nx
self.ln_1 = nn.LayerNorm(nx, eps=config.layer_norm_epsilon)
self.attn = Attention(nx, n_ctx, config, scale)
self.ln_2 = nn.LayerNorm(nx, eps=config.layer_norm_epsilon)
self.mlp = MLP(inner_dim, config)
self.config = config
"""
TODO: add another self attention layer?
"""
def forward(
self,
x,
layer_past=None,
attention_mask=None,
head_mask=None,
use_cache=False,
output_attentions=False,
encoder_hidden_states=None,
encoder_attention_mask=None,
):
output_attn = self.attn(
self.ln_1(x),
layer_past=layer_past,
attention_mask=attention_mask,
head_mask=head_mask,
use_cache=use_cache,
output_attentions=output_attentions,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
)
a = output_attn[0] # output_attn: a, present, (attentions)
x = x + a
m = self.mlp(self.ln_2(x))
x = x + m
outputs = [x] + output_attn[1:]
return outputs # x, present, (attentions)
class GPT2PreTrainedModel(PreTrainedModel):
""" An abstract class to handle weights initialization and
a simple interface for downloading and loading pretrained models.
"""
config_class = GPT2Config
load_tf_weights = load_tf_weights_in_gpt2
base_model_prefix = "transformer"
def __init__(self, *inputs, **kwargs):
super().__init__(*inputs, **kwargs)
def _init_weights(self, module):
""" Initialize the weights.
"""
if isinstance(module, (nn.Linear, nn.Embedding, Conv1D)):
# Slightly different from the TF version which uses truncated_normal for initialization
# cf https://github.com/pytorch/pytorch/pull/5617
module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
if isinstance(module, (nn.Linear, Conv1D)) and module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.LayerNorm):
module.bias.data.zero_()
module.weight.data.fill_(1.0)
class GPT2Model(GPT2PreTrainedModel):
def __init__(self, config):
super().__init__(config)
self.wte = nn.Embedding(config.vocab_size, config.n_embd)
self.wpe = nn.Embedding(config.n_positions, config.n_embd)
self.drop = nn.Dropout(config.embd_pdrop)
self.h = nn.ModuleList(
[Block(config.n_ctx, config, scale=True) for _ in range(config.n_layer)]
)
self.ln_f = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)
self.init_weights()
def get_input_embeddings(self):
return self.wte
def set_input_embeddings(self, new_embeddings):
self.wte = new_embeddings
def _prune_heads(self, heads_to_prune):
""" Prunes heads of the model.
heads_to_prune: dict of {layer_num: list of heads to prune in this layer}
"""
for layer, heads in heads_to_prune.items():
self.h[layer].attn.prune_heads(heads)
def forward(
self,
input_ids=None,
past_key_values=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
use_cache=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
**kwargs,
):
if "past" in kwargs:
warnings.warn(
"The `past` argument is deprecated and will be removed in a future version, use `past_key_values` instead.",
FutureWarning,
)
past_key_values = kwargs.pop("past")
assert kwargs == {}, f"Unexpected keyword arguments: {list(kwargs.keys())}."
output_attentions = (
output_attentions if output_attentions is not None else self.config.output_attentions
)
output_hidden_states = (
output_hidden_states
if output_hidden_states is not None
else self.config.output_hidden_states
)
use_cache = use_cache if use_cache is not None else self.config.use_cache
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
if input_ids is not None and inputs_embeds is not None:
raise ValueError(
"You cannot specify both input_ids and inputs_embeds at the same time"
)
elif input_ids is not None:
input_shape = input_ids.size()
input_ids = input_ids.view(-1, input_shape[-1])
batch_size = input_ids.shape[0]
elif inputs_embeds is not None:
input_shape = inputs_embeds.size()[:-1]
batch_size = inputs_embeds.shape[0]
else:
raise ValueError("You have to specify either input_ids or inputs_embeds")
if token_type_ids is not None:
token_type_ids = token_type_ids.view(-1, input_shape[-1])
if position_ids is not None:
position_ids = position_ids.view(-1, input_shape[-1])
if past_key_values is None:
past_length = 0
past_key_values = [None] * len(self.h)
else:
past_length = past_key_values[0][0].size(-2)
if position_ids is None:
device = input_ids.device if input_ids is not None else inputs_embeds.device
position_ids = torch.arange(
past_length, input_shape[-1] + past_length, dtype=torch.long, device=device
)
position_ids = position_ids.unsqueeze(0).view(-1, input_shape[-1])
# Attention mask.
if attention_mask is not None:
assert batch_size > 0, "batch_size has to be defined and > 0"
attention_mask = attention_mask.view(batch_size, -1)
# We create a 3D attention mask from a 2D tensor mask.
# Sizes are [batch_size, 1, 1, to_seq_length]
# So we can broadcast to [batch_size, num_heads, from_seq_length, to_seq_length]
# this attention mask is more simple than the triangular masking of causal attention
# used in OpenAI GPT, we just need to prepare the broadcast dimension here.
attention_mask = attention_mask.unsqueeze(1).unsqueeze(2)
# Since attention_mask is 1.0 for positions we want to attend and 0.0 for
# masked positions, this operation will create a tensor which is 0.0 for
# positions we want to attend and -10000.0 for masked positions.
# Since we are adding it to the raw scores before the softmax, this is
# effectively the same as removing these entirely.
attention_mask = attention_mask.to(
dtype=next(self.parameters()).dtype
) # fp16 compatibility
attention_mask = (1.0 - attention_mask) * -10000.0
# Prepare head mask if needed
# 1.0 in head_mask indicate we keep the head
# attention_probs has shape bsz x n_heads x N x N
# head_mask has shape n_layer x batch x n_heads x N x N
head_mask = self.get_head_mask(head_mask, self.config.n_layer)
if self.config.is_decoder and encoder_hidden_states is not None:
encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
if encoder_attention_mask is None:
encoder_attention_mask = torch.ones(encoder_hidden_shape)
if inputs_embeds is None:
inputs_embeds = self.wte(input_ids)
position_embeds = self.wpe(position_ids)
if token_type_ids is not None:
token_type_embeds = self.wte(token_type_ids)
else:
token_type_embeds = 0
hidden_states = inputs_embeds + position_embeds + token_type_embeds
hidden_states = self.drop(hidden_states)
output_shape = input_shape + (hidden_states.size(-1),)
presents = () if use_cache else None
all_attentions = () if output_attentions else None
all_hidden_states = () if output_hidden_states else None
for i, (block, layer_past) in enumerate(zip(self.h, past_key_values)):
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states.view(*output_shape),)
outputs = block(
hidden_states,
layer_past=layer_past,
attention_mask=attention_mask,
head_mask=head_mask[i],
use_cache=use_cache,
output_attentions=output_attentions,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
)
hidden_states, present = outputs[:2]
if use_cache is True:
presents = presents + (present,)
if output_attentions:
all_attentions = all_attentions + (outputs[2],)
hidden_states = self.ln_f(hidden_states)
hidden_states = hidden_states.view(*output_shape)
# Add last hidden state
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
if not return_dict:
return tuple(
v
for v in [hidden_states, presents, all_hidden_states, all_attentions]
if v is not None
)
return BaseModelOutputWithPast(
last_hidden_state=hidden_states,
past_key_values=presents,
hidden_states=all_hidden_states,
attentions=all_attentions,
)
class GPT2LMHeadModel(GPT2PreTrainedModel):
authorized_missing_keys = [r"h\.\d+\.attn\.masked_bias", r"lm_head\.weight"]
def __init__(self, config):
super().__init__(config)
self.transformer = GPT2Model(config)
self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
self.init_weights()
def get_output_embeddings(self):
return self.lm_head
def prepare_inputs_for_generation(self, input_ids, past, **kwargs):
# only last token for inputs_ids if past is defined in kwargs
if past:
input_ids = input_ids[:, -1].unsqueeze(-1)
return {"input_ids": input_ids, "past_key_values": past, "use_cache": kwargs["use_cache"]}
def forward(
self,
input_ids=None,
past_key_values=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
labels=None,
use_cache=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
**kwargs,
):
r"""
labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Labels for language modeling.
Note that the labels **are shifted** inside the model, i.e. you can set ``labels = input_ids``
Indices are selected in ``[-100, 0, ..., config.vocab_size]``
All labels set to ``-100`` are ignored (masked), the loss is only
computed for labels in ``[0, ..., config.vocab_size]``
"""
if "past" in kwargs:
warnings.warn(
"The `past` argument is deprecated and will be removed in a future version, use `past_key_values` instead.",
FutureWarning,
)
past_key_values = kwargs.pop("past")
assert kwargs == {}, f"Unexpected keyword arguments: {list(kwargs.keys())}."
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
transformer_outputs = self.transformer(
input_ids,
past_key_values=past_key_values,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
use_cache=use_cache,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_states = transformer_outputs[0]
lm_logits = self.lm_head(hidden_states)
loss = None
if labels is not None:
# Shift so that tokens < n predict n
shift_logits = lm_logits[..., :-1, :].contiguous()
shift_labels = labels[..., 1:].contiguous()
# Flatten the tokens
loss_fct = CrossEntropyLoss()
loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
if not return_dict:
output = (lm_logits,) + transformer_outputs[1:]
return ((loss,) + output) if loss is not None else output
return CausalLMOutputWithPast(
loss=loss,
logits=lm_logits,
past_key_values=transformer_outputs.past_key_values,
hidden_states=transformer_outputs.hidden_states,
attentions=transformer_outputs.attentions,
)
class GPT2DoubleHeadsModel(GPT2PreTrainedModel):
def __init__(self, config):
super().__init__(config)
config.num_labels = 1
self.transformer = GPT2Model(config)
self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
self.multiple_choice_head = SequenceSummary(config)
self.init_weights()
def get_output_embeddings(self):
return self.lm_head
def forward(
self,
input_ids=None,
past_key_values=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
mc_token_ids=None,
labels=None,
mc_labels=None,
use_cache=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
**kwargs,
):
r"""
mc_token_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, num_choices)`, `optional`, default to index of the last token of the input)
Index of the classification token in each input sequence.
Selected in the range ``[0, input_ids.size(-1) - 1[``.
labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`)
Labels for language modeling.
Note that the labels **are shifted** inside the model, i.e. you can set ``labels = input_ids``
Indices are selected in ``[-1, 0, ..., config.vocab_size]``
All labels set to ``-100`` are ignored (masked), the loss is only
computed for labels in ``[0, ..., config.vocab_size]``
mc_labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size)`, `optional`, defaults to :obj:`None`)
Labels for computing the multiple choice classification loss.
Indices should be in ``[0, ..., num_choices]`` where `num_choices` is the size of the second dimension
of the input tensors. (see `input_ids` above)
kwargs (:obj:`Dict[str, any]`, optional, defaults to `{}`):
Used to hide legacy arguments that have been deprecated.
Return:
Examples::
>>> import torch
>>> from transformers import GPT2Tokenizer, GPT2DoubleHeadsModel
>>> tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
>>> model = GPT2DoubleHeadsModel.from_pretrained('gpt2, return_dict=True)
>>> # Add a [CLS] to the vocabulary (we should train it also!)
>>> num_added_tokens = tokenizer.add_special_tokens({'cls_token': '[CLS]'})
>>> embedding_layer = model.resize_token_embeddings(len(tokenizer)) # Update the model embeddings with the new vocabulary size
>>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
>>> encoded_choices = [tokenizer.encode(s) for s in choices]
>>> cls_token_location = [tokens.index(tokenizer.cls_token_id) for tokens in encoded_choices]
>>> input_ids = torch.tensor(encoded_choices).unsqueeze(0) # Batch size: 1, number of choices: 2
>>> mc_token_ids = torch.tensor([cls_token_location]) # Batch size: 1
>>> outputs = model(input_ids, mc_token_ids=mc_token_ids)
>>> lm_logits = outputs.lm_logits
>>> mc_logits = outputs.mc_logits
"""
if "lm_labels" in kwargs:
warnings.warn(
"The `lm_labels` argument is deprecated and will be removed in a future version, use `labels` instead.",
FutureWarning,
)
labels = kwargs.pop("lm_labels")
if "past" in kwargs:
warnings.warn(
"The `past` argument is deprecated and will be removed in a future version, use `past_key_values` instead.",
FutureWarning,
)
past_key_values = kwargs.pop("past")
assert kwargs == {}, f"Unexpected keyword arguments: {list(kwargs.keys())}."
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
transformer_outputs = self.transformer(
input_ids,
past_key_values=past_key_values,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
use_cache=use_cache,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_states = transformer_outputs[0]
lm_logits = self.lm_head(hidden_states)
mc_logits = self.multiple_choice_head(hidden_states, mc_token_ids).squeeze(-1)
mc_loss = None
if mc_labels is not None:
loss_fct = CrossEntropyLoss()
mc_loss = loss_fct(mc_logits.view(-1, mc_logits.size(-1)), mc_labels.view(-1))
lm_loss = None
if labels is not None:
shift_logits = lm_logits[..., :-1, :].contiguous()
shift_labels = labels[..., 1:].contiguous()
loss_fct = CrossEntropyLoss()
lm_loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
if not return_dict:
output = (lm_logits, mc_logits) + transformer_outputs[1:]
if mc_loss is not None:
output = (mc_loss,) + output
return ((lm_loss,) + output) if lm_loss is not None else output
return GPT2DoubleHeadsModelOutput(
lm_loss=lm_loss,
mc_loss=mc_loss,
lm_logits=lm_logits,
mc_logits=mc_logits,
past_key_values=transformer_outputs.past_key_values,
hidden_states=transformer_outputs.hidden_states,
attentions=transformer_outputs.attentions,
)
| craftassist-master | python/base_agent/ttad/back_translation/modeling_gpt2.py |
craftassist-master | python/base_agent/ttad/back_translation/__init__.py |
|
import torch
import argparse
import random
class Tree2TextDataset(torch.utils.data.Dataset):
"""Dataset class extending pytorch Dataset definition.
"""
def __init__(self, prog, chat):
"""Initialize paired data, tokenizer, dictionaries.
"""
assert len(prog) == len(chat)
self.prog = prog
self.chat = chat
def __len__(self):
"""Returns total number of samples.
"""
return len(self.prog)
def __getitem__(self, index):
"""Generates one sample of data.
"""
X = self.prog[index]
Y = self.chat[index]
return (X, Y)
def load_paired_dataset(data_dir, prefix):
chat_data = []
prog_data = []
with open(data_dir + "{}.chat".format(prefix)) as fd:
chat_data = fd.read().splitlines()
with open(data_dir + "{}.prog".format(prefix)) as fd:
prog_data = fd.read().splitlines()
return (prog_data, chat_data)
def collate(tree, text, tree_tokenizer, text_tokenizer):
"""Pad and tensorize data.
"""
# Longest tree
max_x_len = max([len(x) for x in tree])
x_mask = [[1] * len(x) + [0] * (max_x_len - len(x)) for x in tree]
batch_x_with_pad = [x + [tree_tokenizer.pad_token_id] * (max_x_len - len(x)) for x in tree]
# Longest text command
max_y_len = max([len(y) for y in text])
y_mask = [[1] * len(y) + [0] * (max_y_len - len(y)) for y in text]
batch_y_with_pad = [y + [text_tokenizer.pad_token_id] * (max_y_len - len(y)) for y in text]
# Convert padded data to tensors
x = batch_x_with_pad
x_mask = x_mask
y = batch_y_with_pad
y_mask = y_mask
return (x, x_mask, y, y_mask)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--data_dir",
default="/checkpoint/rebeccaqian/datasets/fairseq/07_25/",
type=str,
help="train/valid/test data",
)
parser.add_argument(
"--prefix", default="train", type=str, help="partition to load eg. train, valid"
)
# Load dataset and print some meta stats.
args = parser.parse_args()
train_prog_data, train_chat_data = load_paired_dataset(args.data_dir, args.prefix)
train_dataset = Tree2TextDataset(train_prog_data, train_chat_data)
length = train_dataset.__len__()
print("Size of data: {}".format(length))
# Randomly generate some samples.
for i in range(5):
rand = random.uniform(0, 1)
idx = round(rand * length)
example = train_dataset.__getitem__(idx)
print("Example:\n X: {}\n Y: {}".format(example[0], example[1]))
if __name__ == "__main__":
main()
| craftassist-master | python/base_agent/ttad/back_translation/dataset.py |
from transformers.modeling_bert import BertModel
import torch.nn as nn
class TransformerEncoder(nn.Module):
"""Transformer Encoder class.
"""
def __init__(self, config, tokenizer):
super(TransformerEncoder, self).__init__()
# Initializes transformer architecture with BERT structure
self.bert = BertModel(config)
def forward(self, input_ids, attention_mask):
bert_model = self.bert(input_ids=input_ids, attention_mask=attention_mask)
hidden_out = bert_model[0]
return hidden_out
class EncoderDecoder(nn.Module):
"""Encoder decoder architecture used for back translation.
"""
def __init__(self, encoder, decoder):
super(EncoderDecoder, self).__init__()
self.encoder = encoder
self.decoder = decoder
def forward(self, x, x_mask, y, y_mask, labels, use_lm=False):
hidden_out = self.encoder(input_ids=x, attention_mask=x_mask)[0]
dec_out = self.decoder(
input_ids=y,
attention_mask=y_mask,
encoder_hidden_states=hidden_out,
encoder_attention_mask=x_mask,
use_lm=use_lm,
labels=labels,
)
return dec_out
def step(self, x_reps, x_mask, y, y_mask, use_lm=False):
"""No loss, used during inference.
"""
dec_out = self.decoder(
input_ids=y,
attention_mask=y_mask,
encoder_hidden_states=x_reps,
encoder_attention_mask=x_mask,
use_lm=use_lm,
)
return dec_out
| craftassist-master | python/base_agent/ttad/back_translation/transformer.py |
from transformers import AutoConfig, GPT2Tokenizer, BertTokenizer
from os.path import isdir
from dataset import *
from transformer import *
from torch.utils.data import DataLoader
from datetime import date
import argparse
import os
import sys
from time import time
from huggingface_modeling_gpt2 import *
import logging
import logging.handlers
BASE_AGENT_ROOT = os.path.join(os.path.dirname(__file__), "../..")
sys.path.append(BASE_AGENT_ROOT)
# make sure GPT2 appends EOS in begin and end
def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None):
outputs = [self.bos_token_id] + token_ids_0 + [self.eos_token_id]
return outputs
def compute_accuracy(outputs, y, tokenizer):
"""Compute model accuracy given predictions and targets. Used in validation.
"""
# Do not include BOS token
target_tokens = y[:, 1:]
predicted_tokens = outputs.max(dim=-1)[1][:, :-1]
acc = (predicted_tokens == target_tokens).sum(dim=1) == target_tokens.shape[-1]
return acc
def validate(model, dataset, text_tokenizer, tree_tokenizer, args):
valid_loader = torch.utils.data.DataLoader(dataset=dataset, batch_size=10, shuffle=False)
tot_acc = 0.0
tot_loss = 0.0
steps = 0
with torch.no_grad():
for i, batch in enumerate(valid_loader):
trees, text = batch
text_idx_ls = [
text_tokenizer.encode(cmd.strip(), add_special_tokens=True) for cmd in text
]
tree_idx_ls = [tree_tokenizer.encode(tree, add_special_tokens=True) for tree in trees]
x, x_mask, y, y_mask = collate(
tree_idx_ls, text_idx_ls, tree_tokenizer, text_tokenizer
)
y_copy = y.copy()
y_mask_copy = y_mask.copy()
labels = [
[-100 if mask == 0 else token for mask, token in mask_and_tokens]
for mask_and_tokens in [
zip(mask, label) for mask, label in zip(y_mask_copy, y_copy)
]
]
labels = torch.tensor(labels)
x = torch.tensor(x)
x_mask = torch.tensor(x_mask)
y = torch.tensor(y)
y_mask = torch.tensor(y_mask)
out = model(x, x_mask, y, y_mask, labels, args.use_lm)
loss, predictions = out[:2]
# Taking the first row in the batch as logging example
predicted_example = predictions.max(dim=-1)[1][:, :-1]
predicted_sentence = text_tokenizer.decode(predicted_example[0])
logging.info(
"sample predictions:\n X: {} \n Y: {} \n predicted: {}".format(
trees[0], text[0], predicted_sentence
)
)
print(
"sample predictions:\n X: {} \n Y: {} \n predicted: {}".format(
trees[0], text[0], predicted_sentence
)
)
lm_acc = compute_accuracy(predictions, y, text_tokenizer)
acc = lm_acc.sum().item() / lm_acc.shape[0]
tot_acc += acc
tot_loss += loss.item()
steps += 1
logging.info("Valid accuracy: {} Loss: {}".format(tot_acc / steps, tot_loss / steps))
print("Valid accuracy: {} Loss: {}".format(tot_acc / steps, tot_loss / steps))
def generate_model_name(args):
# unix time in seconds, used as a unique identifier
time_now = round(time())
name = ""
args_keys = {
"batch_size": "batch",
"lr": "lr",
"train_decoder": "finetune",
"encoder_size": "size",
}
for k, v in vars(args).items():
if k in args_keys:
name += "{param}={value}|".format(param=args_keys[k], value=v)
# In case we want additional identification for the model, eg. test run
name += "{time}|".format(time=time_now)
name += args.model_identifier
return name
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--data_dir",
default="/checkpoint/rebeccaqian/datasets/backtranslation/09_11/mixed_spans/",
type=str,
help="train/valid/test data",
)
parser.add_argument(
"--output_dir",
default="/checkpoint/rebeccaqian/backtranslation/{}/".format(str(date.today())),
type=str,
help="directory to save checkpoint models",
)
parser.add_argument(
"--train_decoder",
default=False,
action="store_true",
help="whether to finetune the decoder",
)
parser.add_argument(
"--model_identifier",
default="ttad_bert2gpt2",
type=str,
help="optional identifier string used in filenames",
)
parser.add_argument("--encoder_size", default="medium", type=str, help="size of encoder")
parser.add_argument(
"--num_hidden_layers",
default=12,
type=int,
help="number of hidden layers in BERT Transformer",
)
parser.add_argument(
"--hidden_dropout_prob",
default=0.1,
type=int,
help="dropout probabilitiy for all fully connected encoder layers",
)
parser.add_argument(
"--data_type", default="annotated", type=str, help="name of dataset to load from"
)
parser.add_argument(
"--use_lm", default=False, action="store_true", help="whether to use decoder as lm"
)
parser.add_argument("--lr", default=0.00001, type=float, help="learning rate")
parser.add_argument("--batch_size", default=48, type=int, help="batch size")
parser.add_argument("--num_epochs", default=30, type=int, help="number of epochs")
args = parser.parse_args()
model_identifier = generate_model_name(args)
l_handler = logging.handlers.WatchedFileHandler(
"{}/{}.log".format(args.output_dir, model_identifier)
)
l_format = logging.Formatter(fmt="%(asctime)s - %(message)s", datefmt="%d-%b-%y %H:%M:%S")
l_handler.setFormatter(l_format)
l_root = logging.getLogger()
l_root.setLevel(os.environ.get("LOGLEVEL", "INFO"))
l_root.addHandler(l_handler)
logging.info(args)
print(args)
if args.encoder_size == "large":
encoder_name = "bert-large-uncased"
decoder_name = "gpt2-medium"
else:
encoder_name = "bert-base-uncased"
decoder_name = "gpt2"
if args.use_lm:
config_decoder = AutoConfig.from_pretrained(decoder_name, is_decoder=False)
config_decoder.add_cross_attention = False
else:
config_decoder = AutoConfig.from_pretrained(decoder_name, is_decoder=True)
config_decoder.add_cross_attention = True
config_encoder = AutoConfig.from_pretrained(encoder_name, is_decoder=False)
bert_tokenizer = BertTokenizer.from_pretrained(encoder_name)
# CLS token will work as BOS token
bert_tokenizer.bos_token = bert_tokenizer.cls_token
# SEP token will work as EOS token
bert_tokenizer.eos_token = bert_tokenizer.sep_token
tokenizer = GPT2Tokenizer.from_pretrained(decoder_name)
tokenizer.pad_token = tokenizer.unk_token
GPT2Tokenizer.build_inputs_with_special_tokens = build_inputs_with_special_tokens
enc_model = BertModel(config=config_encoder)
dec_model = GPT2LMHeadModel.from_pretrained(decoder_name, config=config_decoder)
dec_model.config.decoder_start_token_id = tokenizer.bos_token_id
dec_model.config.eos_token_id = tokenizer.eos_token_id
dec_model.resize_token_embeddings(len(tokenizer))
decoder_params = dec_model.named_parameters()
if not args.train_decoder:
# enumerate all decoder params, 244
decoder_params = dec_model.named_parameters()
for name, param in decoder_params:
# train decoder attention weights, 94
if "cross_attn" in name or "crossattention" in name:
param.requires_grad = True
else:
# freeze other layer weights
param.requires_grad = False
train_prog_data, train_chat_data = load_paired_dataset(args.data_dir, "train")
train_dataset = Tree2TextDataset(train_prog_data, train_chat_data)
train_loader = DataLoader(dataset=train_dataset, batch_size=args.batch_size, shuffle=True)
valid_prog_data, valid_chat_data = load_paired_dataset(args.data_dir, "valid")
valid_dataset = Tree2TextDataset(valid_prog_data, valid_chat_data)
encoder_decoder = EncoderDecoder(enc_model, dec_model)
optimizer = torch.optim.Adam(encoder_decoder.parameters(), lr=args.lr)
for epoch in range(args.num_epochs):
logging.info("Epoch: {}".format(epoch))
print("Epoch: {}".format(epoch))
encoder_decoder.train()
for i, batch in enumerate(train_loader):
trees, text = batch
optimizer.zero_grad()
text_idx_ls = [tokenizer.encode(cmd.strip(), add_special_tokens=True) for cmd in text]
tree_idx_ls = [bert_tokenizer.encode(tree, add_special_tokens=True) for tree in trees]
x, x_mask, y, y_mask = collate(tree_idx_ls, text_idx_ls, bert_tokenizer, tokenizer)
y_copy = y.copy()
y_mask_copy = y_mask.copy()
labels = [
[-100 if mask == 0 else token for mask, token in mask_and_tokens]
for mask_and_tokens in [
zip(mask, label) for mask, label in zip(y_mask_copy, y_copy)
]
]
labels = torch.tensor(labels)
y = torch.tensor(y)
y_mask = torch.tensor(y_mask)
x = torch.tensor(x)
x_mask = torch.tensor(x_mask)
outputs = encoder_decoder(x, x_mask, y, y_mask, labels, args.use_lm)
loss, predictions = outputs[:2]
# Taking the first row in the batch as logging example
predicted_example = predictions.max(dim=-1)[1][:, :-1]
predicted_sentence = tokenizer.decode(predicted_example[0])
loss.backward()
optimizer.step()
if i % 20 == 0:
logging.info(
"sample predictions:\n X: {} \n Y: {} \n predicted: {}".format(
trees[0], text[0], predicted_sentence
)
)
print(
"sample predictions:\n X: {} \n Y: {} \n predicted: {}".format(
trees[0], text[0], predicted_sentence
)
)
logging.info("Iteration: {} Loss: {}".format(i, loss))
print("Iteration: {} Loss: {}".format(i, loss))
enc_dirpath = "{}encoder/".format(args.output_dir)
if not isdir(enc_dirpath):
os.mkdir(enc_dirpath)
enc_checkpoint_path = enc_dirpath + "{}(ep=={})/".format(model_identifier, epoch)
if not isdir(enc_checkpoint_path):
os.mkdir(enc_checkpoint_path)
dec_dirpath = "{}decoder/".format(args.output_dir)
if not isdir(dec_dirpath):
os.mkdir(dec_dirpath)
dec_checkpoint_path = dec_dirpath + "{}(ep=={})/".format(model_identifier, epoch)
if not isdir(dec_checkpoint_path):
os.mkdir(dec_checkpoint_path)
enc_model.save_pretrained(enc_checkpoint_path)
dec_model.save_pretrained(dec_checkpoint_path)
# Evaluating model
encoder_decoder.eval()
logging.info("Evaluating model")
validate(encoder_decoder, valid_dataset, tokenizer, bert_tokenizer, args)
if __name__ == "__main__":
main()
| craftassist-master | python/base_agent/ttad/back_translation/train.py |
# coding=utf-8
# Copyright 2018 The OpenAI Team Authors and HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""PyTorch OpenAI GPT-2 model."""
import os
import warnings
from dataclasses import dataclass
from typing import List, Optional, Tuple
import torch
import torch.nn as nn
from torch.nn import CrossEntropyLoss
from transformers.activations import ACT2FN
from transformers.configuration_gpt2 import GPT2Config
from transformers.file_utils import (
ModelOutput,
add_code_sample_docstrings,
add_start_docstrings,
add_start_docstrings_to_callable,
replace_return_docstrings,
)
from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast
from transformers.modeling_utils import (
Conv1D,
PreTrainedModel,
SequenceSummary,
find_pruneable_heads_and_indices,
prune_conv1d_layer,
)
from transformers.utils import logging
logger = logging.get_logger(__name__)
_CONFIG_FOR_DOC = "GPT2Config"
_TOKENIZER_FOR_DOC = "GPT2Tokenizer"
GPT2_PRETRAINED_MODEL_ARCHIVE_LIST = [
"gpt2",
"gpt2-medium",
"gpt2-large",
"gpt2-xl",
"distilgpt2",
# See all GPT-2 models at https://huggingface.co/models?filter=gpt2
]
def load_tf_weights_in_gpt2(model, config, gpt2_checkpoint_path):
"""Load tf checkpoints in a pytorch model"""
try:
import re
import tensorflow as tf
except ImportError:
logger.error(
"Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see "
"https://www.tensorflow.org/install/ for installation instructions."
)
raise
tf_path = os.path.abspath(gpt2_checkpoint_path)
logger.info("Converting TensorFlow checkpoint from {}".format(tf_path))
# Load weights from TF model
init_vars = tf.train.list_variables(tf_path)
names = []
arrays = []
for name, shape in init_vars:
logger.info("Loading TF weight {} with shape {}".format(name, shape))
array = tf.train.load_variable(tf_path, name)
names.append(name)
arrays.append(array.squeeze())
for name, array in zip(names, arrays):
name = name[6:] # skip "model/"
name = name.split("/")
pointer = model
for m_name in name:
if re.fullmatch(r"[A-Za-z]+\d+", m_name):
scope_names = re.split(r"(\d+)", m_name)
else:
scope_names = [m_name]
if scope_names[0] == "w" or scope_names[0] == "g":
pointer = getattr(pointer, "weight")
elif scope_names[0] == "b":
pointer = getattr(pointer, "bias")
elif scope_names[0] == "wpe" or scope_names[0] == "wte":
pointer = getattr(pointer, scope_names[0])
pointer = getattr(pointer, "weight")
else:
pointer = getattr(pointer, scope_names[0])
if len(scope_names) >= 2:
num = int(scope_names[1])
pointer = pointer[num]
try:
assert (
pointer.shape == array.shape
), f"Pointer shape {pointer.shape} and array shape {array.shape} mismatched"
except AssertionError as e:
e.args += (pointer.shape, array.shape)
raise
logger.info("Initialize PyTorch weight {}".format(name))
pointer.data = torch.from_numpy(array)
return model
class Attention(nn.Module):
def __init__(self, nx, n_ctx, config, scale=False, is_cross_attention=False):
super().__init__()
n_state = nx # in Attention: n_state=768 (nx=n_embd)
# [switch nx => n_state from Block to Attention to keep identical to TF implem]
assert n_state % config.n_head == 0
self.register_buffer(
"bias",
torch.tril(torch.ones((n_ctx, n_ctx), dtype=torch.uint8)).view(1, 1, n_ctx, n_ctx),
)
self.register_buffer("masked_bias", torch.tensor(-1e4))
self.n_head = config.n_head
self.split_size = n_state
self.scale = scale
self.is_cross_attention = is_cross_attention
if self.is_cross_attention:
self.c_attn = Conv1D(2 * n_state, nx)
self.q_attn = Conv1D(n_state, nx)
else:
self.c_attn = Conv1D(3 * n_state, nx)
self.c_proj = Conv1D(n_state, nx)
self.attn_dropout = nn.Dropout(config.attn_pdrop)
self.resid_dropout = nn.Dropout(config.resid_pdrop)
self.pruned_heads = set()
def prune_heads(self, heads):
if len(heads) == 0:
return
heads, index = find_pruneable_heads_and_indices(
heads, self.n_head, self.split_size // self.n_head, self.pruned_heads
)
index_attn = torch.cat([index, index + self.split_size, index + (2 * self.split_size)])
# Prune conv1d layers
self.c_attn = prune_conv1d_layer(self.c_attn, index_attn, dim=1)
self.c_proj = prune_conv1d_layer(self.c_proj, index, dim=0)
# Update hyper params
self.split_size = (self.split_size // self.n_head) * (self.n_head - len(heads))
self.n_head = self.n_head - len(heads)
self.pruned_heads = self.pruned_heads.union(heads)
def _attn(
self,
q,
k,
v,
attention_mask=None,
head_mask=None,
output_attentions=False,
decoder_input_length=None,
):
w = torch.matmul(q, k)
if self.scale:
w = w / (float(v.size(-1)) ** 0.5)
nd, ns = w.size(-2), w.size(-1)
if not self.is_cross_attention:
if decoder_input_length is not None:
# if only "normal" attention layer implements causal mask
x_len = attention_mask.shape[-1] - decoder_input_length
y_len = decoder_input_length
x_mask = torch.ones(y_len, x_len, dtype=torch.uint8)
y_mask = torch.tril(torch.ones(y_len, y_len, dtype=torch.uint8))
mask = torch.cat((x_mask, y_mask), 1)
# pad remainder with zeros
mask = torch.cat((mask, torch.zeros([x_len, x_len + y_len])), 0)
w = torch.where(mask.bool(), w, self.masked_bias)
else:
mask = self.bias[:, :, ns - nd : ns, :ns]
w = torch.where(mask.bool(), w, self.masked_bias.to(w.dtype))
if attention_mask is not None:
# Apply the attention mask
w = w + attention_mask
w = nn.Softmax(dim=-1)(w)
w = self.attn_dropout(w)
# Mask heads if we want to
if head_mask is not None:
w = w * head_mask
outputs = [torch.matmul(w, v)]
if output_attentions:
outputs.append(w)
return outputs
def merge_heads(self, x):
x = x.permute(0, 2, 1, 3).contiguous()
new_x_shape = x.size()[:-2] + (x.size(-2) * x.size(-1),)
return x.view(*new_x_shape) # in Tensorflow implem: fct merge_states
def split_heads(self, x, k=False):
new_x_shape = x.size()[:-1] + (self.n_head, x.size(-1) // self.n_head)
x = x.view(*new_x_shape) # in Tensorflow implem: fct split_states
if k:
return x.permute(0, 2, 3, 1) # (batch, head, head_features, seq_length)
else:
return x.permute(0, 2, 1, 3) # (batch, head, seq_length, head_features)
def forward(
self,
hidden_states,
layer_past=None,
attention_mask=None,
head_mask=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
use_cache=False,
output_attentions=False,
decoder_input_length=None,
):
if encoder_hidden_states is not None:
assert hasattr(
self, "q_attn"
), "If class is used as cross attention, the weights `q_attn` have to be defined. Please make sure to instantiate class with `Attention(..., is_cross_attention=True)`."
query = self.q_attn(hidden_states)
key, value = self.c_attn(encoder_hidden_states).split(self.split_size, dim=2)
attention_mask = encoder_attention_mask
else:
query, key, value = self.c_attn(hidden_states).split(self.split_size, dim=2)
query = self.split_heads(query)
key = self.split_heads(key, k=True)
value = self.split_heads(value)
if layer_past is not None:
past_key, past_value = (
layer_past[0].transpose(-2, -1),
layer_past[1],
) # transpose back cf below
key = torch.cat((past_key, key), dim=-1)
value = torch.cat((past_value, value), dim=-2)
if use_cache is True:
present = torch.stack(
(key.transpose(-2, -1), value)
) # transpose to have same shapes for stacking
else:
present = (None,)
attn_outputs = self._attn(
query, key, value, attention_mask, head_mask, output_attentions, decoder_input_length
)
a = attn_outputs[0]
a = self.merge_heads(a)
a = self.c_proj(a)
a = self.resid_dropout(a)
outputs = [a, present] + attn_outputs[1:]
return outputs # a, present, (attentions)
class MLP(nn.Module):
def __init__(self, n_state, config): # in MLP: n_state=3072 (4 * n_embd)
super().__init__()
nx = config.n_embd
self.c_fc = Conv1D(n_state, nx)
self.c_proj = Conv1D(nx, n_state)
self.act = ACT2FN[config.activation_function]
self.dropout = nn.Dropout(config.resid_pdrop)
def forward(self, x):
h = self.act(self.c_fc(x))
h2 = self.c_proj(h)
return self.dropout(h2)
class Block(nn.Module):
def __init__(self, n_ctx, config, scale=False):
super().__init__()
hidden_size = config.n_embd
inner_dim = config.n_inner if config.n_inner is not None else 4 * hidden_size
self.ln_1 = nn.LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
self.attn = Attention(hidden_size, n_ctx, config, scale)
self.ln_2 = nn.LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
if config.add_cross_attention:
self.crossattention = Attention(
hidden_size, n_ctx, config, scale, is_cross_attention=True
)
self.ln_cross_attn = nn.LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
self.mlp = MLP(inner_dim, config)
def forward(
self,
hidden_states,
layer_past=None,
attention_mask=None,
head_mask=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
use_cache=False,
output_attentions=False,
decoder_input_length=None,
):
attn_outputs = self.attn(
self.ln_1(hidden_states),
layer_past=layer_past,
attention_mask=attention_mask,
head_mask=head_mask,
use_cache=use_cache,
output_attentions=output_attentions,
decoder_input_length=decoder_input_length,
)
attn_output = attn_outputs[0] # output_attn: a, present, (attentions)
outputs = attn_outputs[1:]
# residual connection
hidden_states = attn_output + hidden_states
if encoder_hidden_states is not None:
# add one self-attention block for cross-attention
assert hasattr(
self, "crossattention"
), f"If `encoder_hidden_states` are passed, {self} has to be instantiated with cross-attention layers by setting `config.add_cross_attention=True`"
cross_attn_outputs = self.crossattention(
self.ln_cross_attn(hidden_states),
attention_mask=attention_mask,
head_mask=head_mask,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
output_attentions=output_attentions,
)
attn_output = cross_attn_outputs[0]
# residual connection
hidden_states = hidden_states + attn_output
outputs = (
outputs + cross_attn_outputs[1:]
) # add cross attentions if we output attention weights
feed_forward_hidden_states = self.mlp(self.ln_2(hidden_states))
# residual connection
hidden_states = hidden_states + feed_forward_hidden_states
outputs = [hidden_states] + outputs
return outputs # hidden_states, present, (cross_attentions, attentions)
class GPT2PreTrainedModel(PreTrainedModel):
"""An abstract class to handle weights initialization and
a simple interface for downloading and loading pretrained models.
"""
config_class = GPT2Config
load_tf_weights = load_tf_weights_in_gpt2
base_model_prefix = "transformer"
def __init__(self, *inputs, **kwargs):
super().__init__(*inputs, **kwargs)
def _init_weights(self, module):
"""Initialize the weights."""
if isinstance(module, (nn.Linear, nn.Embedding, Conv1D)):
# Slightly different from the TF version which uses truncated_normal for initialization
# cf https://github.com/pytorch/pytorch/pull/5617
module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
if isinstance(module, (nn.Linear, Conv1D)) and module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.LayerNorm):
module.bias.data.zero_()
module.weight.data.fill_(1.0)
@dataclass
class GPT2DoubleHeadsModelOutput(ModelOutput):
"""
Base class for outputs of models predicting if two sentences are consecutive or not.
Args:
loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when ``labels`` is provided):
Language modeling loss.
mc_loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when :obj:`mc_labels` is provided):
Multiple choice classification loss.
logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, num_choices, sequence_length, config.vocab_size)`):
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
mc_logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, num_choices)`):
Prediction scores of the multiple choice classification head (scores for each choice before SoftMax).
past_key_values (:obj:`List[torch.FloatTensor]`, `optional`, returned when ``use_cache=True`` is passed or when ``config.use_cache=True``):
List of :obj:`torch.FloatTensor` of length :obj:`config.n_layers`, with each tensor of shape
:obj:`(2, batch_size, num_heads, sequence_length, embed_size_per_head)`).
Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
``past_key_values`` input) to speed up sequential decoding.
hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``):
Tuple of :obj:`torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer)
of shape :obj:`(batch_size, sequence_length, hidden_size)`.
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``):
Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape
:obj:`(batch_size, num_heads, sequence_length, sequence_length)`.
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.
"""
loss: Optional[torch.FloatTensor] = None
mc_loss: Optional[torch.FloatTensor] = None
logits: torch.FloatTensor = None
mc_logits: torch.FloatTensor = None
past_key_values: Optional[List[torch.FloatTensor]] = None
hidden_states: Optional[Tuple[torch.FloatTensor]] = None
attentions: Optional[Tuple[torch.FloatTensor]] = None
GPT2_START_DOCSTRING = r"""
This model is a PyTorch `torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>`_ sub-class.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general
usage and behavior.
Parameters:
config (:class:`~transformers.GPT2Config`): Model configuration class with all the parameters of the model.
Initializing with a config file does not load the weights associated with the model, only the configuration.
Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model weights.
"""
GPT2_INPUTS_DOCSTRING = r"""
Args:
input_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, input_ids_length)`):
:obj:`input_ids_length` = ``sequence_length`` if ``past_key_values`` is ``None`` else
``past_key_values[0].shape[-2]`` (``sequence_length`` of input past key value states).
Indices of input sequence tokens in the vocabulary.
If ``past_key_values`` is used, only ``input_ids`` that do not have their past calculated should be passed
as ``input_ids``.
Indices can be obtained using :class:`transformers.GPT2Tokenizer`.
See :func:`transformers.PreTrainedTokenizer.encode` and
:func:`transformers.PreTrainedTokenizer.__call__` for details.
`What are input IDs? <../glossary.html#input-ids>`__
past_key_values (:obj:`List[torch.FloatTensor]` of length :obj:`config.n_layers`):
Contains pre-computed hidden-states (key and values in the attention blocks) as computed by the model
(see ``past_key_values`` output below). Can be used to speed up sequential decoding.
The ``input_ids`` which have their past given to this model should not be passed as ``input_ids`` as they have already been computed.
attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
Mask to avoid performing attention on padding token indices.
Mask values selected in ``[0, 1]``:
``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
`What are attention masks? <../glossary.html#attention-mask>`__
token_type_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, input_ids_length)`, `optional`):
`input_ids_length` = `sequence_length if `past` is None else 1
Segment token indices to indicate first and second portions of the inputs.
Indices are selected in ``[0, 1]``: ``0`` corresponds to a `sentence A` token, ``1``
corresponds to a `sentence B` token
`What are token type IDs? <../glossary.html#token-type-ids>`_
position_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
Indices of positions of each input sequence tokens in the position embeddings.
Selected in the range ``[0, config.max_position_embeddings - 1]``.
`What are position IDs? <../glossary.html#position-ids>`_
head_mask (:obj:`torch.FloatTensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`):
Mask to nullify selected heads of the self-attention modules.
Mask values selected in ``[0, 1]``:
:obj:`1` indicates the head is **not masked**, :obj:`0` indicates the head is **masked**.
inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):
This is useful if you want more control over how to convert `input_ids` indices into associated vectors
than the model's internal embedding lookup matrix.
If ``past_key_values`` is used, optionally only the last `inputs_embeds` have to be input (see ``past_key_values``).
use_cache (:obj:`bool`):
If `use_cache` is True, ``past_key_values`` key value states are returned and can be used to speed up decoding (see ``past_key_values``). Defaults to `True`.
output_attentions (:obj:`bool`, `optional`):
If set to ``True``, the attentions tensors of all attention layers are returned. See ``attentions`` under returned tensors for more detail.
output_hidden_states (:obj:`bool`, `optional`):
If set to ``True``, the hidden states of all layers are returned. See ``hidden_states`` under returned tensors for more detail.
return_dict (:obj:`bool`, `optional`):
If set to ``True``, the model will return a :class:`~transformers.file_utils.ModelOutput` instead of a
plain tuple.
"""
@add_start_docstrings(
"The bare GPT2 Model transformer outputting raw hidden-states without any specific head on top.",
GPT2_START_DOCSTRING,
)
class GPT2Model(GPT2PreTrainedModel):
def __init__(self, config):
super().__init__(config)
self.wte = nn.Embedding(config.vocab_size, config.n_embd)
self.wpe = nn.Embedding(config.n_positions, config.n_embd)
self.drop = nn.Dropout(config.embd_pdrop)
self.h = nn.ModuleList(
[Block(config.n_ctx, config, scale=True) for _ in range(config.n_layer)]
)
self.ln_f = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)
self.init_weights()
def get_input_embeddings(self):
return self.wte
def set_input_embeddings(self, new_embeddings):
self.wte = new_embeddings
def _prune_heads(self, heads_to_prune):
"""Prunes heads of the model.
heads_to_prune: dict of {layer_num: list of heads to prune in this layer}
"""
for layer, heads in heads_to_prune.items():
self.h[layer].attn.prune_heads(heads)
@add_start_docstrings_to_callable(GPT2_INPUTS_DOCSTRING)
@add_code_sample_docstrings(
tokenizer_class=_TOKENIZER_FOR_DOC,
checkpoint="gpt2",
output_type=BaseModelOutputWithPast,
config_class=_CONFIG_FOR_DOC,
)
def forward(
self,
input_ids=None,
past_key_values=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
use_cache=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
use_lm=False,
**kwargs,
):
if "past" in kwargs:
warnings.warn(
"The `past` argument is deprecated and will be removed in a future version, use `past_key_values` instead.",
FutureWarning,
)
past_key_values = kwargs.pop("past")
assert kwargs == {}, f"Unexpected keyword arguments: {list(kwargs.keys())}."
output_attentions = (
output_attentions if output_attentions is not None else self.config.output_attentions
)
output_hidden_states = (
output_hidden_states
if output_hidden_states is not None
else self.config.output_hidden_states
)
use_cache = use_cache if use_cache is not None else self.config.use_cache
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
if input_ids is not None and inputs_embeds is not None:
raise ValueError(
"You cannot specify both input_ids and inputs_embeds at the same time"
)
elif input_ids is not None:
input_shape = input_ids.size()
input_ids = input_ids.view(-1, input_shape[-1])
batch_size = input_ids.shape[0]
elif inputs_embeds is not None:
input_shape = inputs_embeds.size()[:-1]
batch_size = inputs_embeds.shape[0]
else:
raise ValueError("You have to specify either input_ids or inputs_embeds")
if token_type_ids is not None:
token_type_ids = token_type_ids.view(-1, input_shape[-1])
if position_ids is not None:
position_ids = position_ids.view(-1, input_shape[-1])
if past_key_values is None:
past_length = 0
past_key_values = [None] * len(self.h)
else:
past_length = past_key_values[0][0].size(-2)
if position_ids is None:
device = input_ids.device if input_ids is not None else inputs_embeds.device
position_ids = torch.arange(
past_length, input_shape[-1] + past_length, dtype=torch.long, device=device
)
position_ids = position_ids.unsqueeze(0).view(-1, input_shape[-1])
# Attention mask.
if attention_mask is not None:
assert batch_size > 0, "batch_size has to be defined and > 0"
attention_mask = attention_mask.view(batch_size, -1)
# We create a 3D attention mask from a 2D tensor mask.
# Sizes are [batch_size, 1, 1, to_seq_length]
# So we can broadcast to [batch_size, num_heads, from_seq_length, to_seq_length]
# this attention mask is more simple than the triangular masking of causal attention
# used in OpenAI GPT, we just need to prepare the broadcast dimension here.
attention_mask = attention_mask[:, None, None, :]
# Since attention_mask is 1.0 for positions we want to attend and 0.0 for
# masked positions, this operation will create a tensor which is 0.0 for
# positions we want to attend and -10000.0 for masked positions.
# Since we are adding it to the raw scores before the softmax, this is
# effectively the same as removing these entirely.
attention_mask = attention_mask.to(
dtype=next(self.parameters()).dtype
) # fp16 compatibility
attention_mask = (1.0 - attention_mask) * -10000.0
# If a 2D ou 3D attention mask is provided for the cross-attention
# we need to make broadcastabe to [batch_size, num_heads, seq_length, seq_length]
if self.config.add_cross_attention and encoder_hidden_states is not None:
encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
if encoder_attention_mask is None:
encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
encoder_attention_mask = self.invert_attention_mask(encoder_attention_mask)
elif use_lm:
encoder_attention_mask = self.invert_attention_mask(encoder_attention_mask)
else:
encoder_attention_mask = None
# Prepare head mask if needed
# 1.0 in head_mask indicate we keep the head
# attention_probs has shape bsz x n_heads x N x N
# head_mask has shape n_layer x batch x n_heads x N x N
head_mask = self.get_head_mask(head_mask, self.config.n_layer)
if inputs_embeds is None:
inputs_embeds = self.wte(input_ids)
position_embeds = self.wpe(position_ids)
if token_type_ids is not None:
token_type_embeds = self.wte(token_type_ids)
else:
token_type_embeds = 0
hidden_states = inputs_embeds + position_embeds + token_type_embeds
hidden_states = self.drop(hidden_states)
output_shape = input_shape + (hidden_states.size(-1),)
presents = () if use_cache else None
all_attentions = () if output_attentions else None
all_hidden_states = () if output_hidden_states else None
if use_lm:
hidden_states = torch.cat((encoder_hidden_states, inputs_embeds), 1)
attention_mask = torch.cat((encoder_attention_mask, attention_mask), 3)
y_len = inputs_embeds.shape[-2]
encoder_hidden_states = None
encoder_attention_mask = None
else:
y_len = None
for i, (block, layer_past) in enumerate(zip(self.h, past_key_values)):
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states.view(*output_shape),)
outputs = block(
hidden_states,
layer_past=layer_past,
attention_mask=attention_mask,
head_mask=head_mask[i],
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
use_cache=use_cache,
output_attentions=output_attentions,
decoder_input_length=y_len,
)
hidden_states, present = outputs[:2]
if use_cache is True:
presents = presents + (present,)
if output_attentions:
all_attentions = all_attentions + (outputs[2],)
hidden_states = self.ln_f(hidden_states)
if use_lm:
hidden_states = hidden_states[:, -output_shape[-2] :, :]
else:
hidden_states = hidden_states.view(*output_shape)
# Add last hidden state
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
if not return_dict:
return tuple(
v
for v in [hidden_states, presents, all_hidden_states, all_attentions]
if v is not None
)
return BaseModelOutputWithPast(
last_hidden_state=hidden_states,
past_key_values=presents,
hidden_states=all_hidden_states,
attentions=all_attentions,
)
@add_start_docstrings(
"""The GPT2 Model transformer with a language modeling head on top
(linear layer with weights tied to the input embeddings). """,
GPT2_START_DOCSTRING,
)
class GPT2LMHeadModel(GPT2PreTrainedModel):
authorized_missing_keys = [r"h\.\d+\.attn\.masked_bias", r"lm_head\.weight"]
def __init__(self, config):
super().__init__(config)
self.transformer = GPT2Model(config)
self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
self.init_weights()
def get_output_embeddings(self):
return self.lm_head
def prepare_inputs_for_generation(self, input_ids, past=None, **kwargs):
# only last token for inputs_ids if past is defined in kwargs
if past:
input_ids = input_ids[:, -1].unsqueeze(-1)
return {
"input_ids": input_ids,
"past_key_values": past,
"use_cache": kwargs.get("use_cache"),
}
@add_start_docstrings_to_callable(GPT2_INPUTS_DOCSTRING)
@add_code_sample_docstrings(
tokenizer_class=_TOKENIZER_FOR_DOC,
checkpoint="gpt2",
output_type=CausalLMOutputWithPast,
config_class=_CONFIG_FOR_DOC,
)
def forward(
self,
input_ids=None,
past_key_values=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
labels=None,
use_cache=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
use_lm=False,
**kwargs,
):
r"""
labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
Labels for language modeling.
Note that the labels **are shifted** inside the model, i.e. you can set ``labels = input_ids``
Indices are selected in ``[-100, 0, ..., config.vocab_size]``
All labels set to ``-100`` are ignored (masked), the loss is only
computed for labels in ``[0, ..., config.vocab_size]``
"""
if "past" in kwargs:
warnings.warn(
"The `past` argument is deprecated and will be removed in a future version, use `past_key_values` instead.",
FutureWarning,
)
past_key_values = kwargs.pop("past")
assert kwargs == {}, f"Unexpected keyword arguments: {list(kwargs.keys())}."
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
transformer_outputs = self.transformer(
input_ids,
past_key_values=past_key_values,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
use_cache=use_cache,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
use_lm=use_lm,
)
hidden_states = transformer_outputs[0]
lm_logits = self.lm_head(hidden_states)
loss = None
if labels is not None:
# Shift so that tokens < n predict n
shift_logits = lm_logits[..., :-1, :].contiguous()
shift_labels = labels[..., 1:].contiguous()
# Flatten the tokens
loss_fct = CrossEntropyLoss()
loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
if not return_dict:
output = (lm_logits,) + transformer_outputs[1:]
return ((loss,) + output) if loss is not None else output
return CausalLMOutputWithPast(
loss=loss,
logits=lm_logits,
past_key_values=transformer_outputs.past_key_values,
hidden_states=transformer_outputs.hidden_states,
attentions=transformer_outputs.attentions,
)
@add_start_docstrings(
"""The GPT2 Model transformer with a language modeling and a multiple-choice classification
head on top e.g. for RocStories/SWAG tasks. The two heads are two linear layers.
The language modeling head has its weights tied to the input embeddings,
the classification head takes as input the input of a specified classification token index in the input sequence).
""",
GPT2_START_DOCSTRING,
)
class GPT2DoubleHeadsModel(GPT2PreTrainedModel):
def __init__(self, config):
super().__init__(config)
config.num_labels = 1
self.transformer = GPT2Model(config)
self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
self.multiple_choice_head = SequenceSummary(config)
self.init_weights()
def get_output_embeddings(self):
return self.lm_head
def prepare_inputs_for_generation(self, input_ids, past=None, **kwargs):
# only last token for inputs_ids if past is defined in kwargs
if past:
input_ids = input_ids[:, -1].unsqueeze(-1)
return {
"input_ids": input_ids,
"past_key_values": past,
"use_cache": kwargs.get("use_cache"),
}
@add_start_docstrings_to_callable(GPT2_INPUTS_DOCSTRING)
@replace_return_docstrings(
output_type=GPT2DoubleHeadsModelOutput, config_class=_CONFIG_FOR_DOC
)
def forward(
self,
input_ids=None,
past_key_values=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
mc_token_ids=None,
labels=None,
mc_labels=None,
use_cache=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
**kwargs,
):
r"""
mc_token_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, num_choices)`, `optional`, default to index of the last token of the input)
Index of the classification token in each input sequence.
Selected in the range ``[0, input_ids.size(-1) - 1[``.
labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`)
Labels for language modeling.
Note that the labels **are shifted** inside the model, i.e. you can set ``labels = input_ids``
Indices are selected in ``[-1, 0, ..., config.vocab_size]``
All labels set to ``-100`` are ignored (masked), the loss is only
computed for labels in ``[0, ..., config.vocab_size]``
mc_labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size)`, `optional`)
Labels for computing the multiple choice classification loss.
Indices should be in ``[0, ..., num_choices]`` where `num_choices` is the size of the second dimension
of the input tensors. (see `input_ids` above)
kwargs (:obj:`Dict[str, any]`, optional, defaults to `{}`):
Used to hide legacy arguments that have been deprecated.
Return:
Examples::
>>> import torch
>>> from transformers import GPT2Tokenizer, GPT2DoubleHeadsModel
>>> tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
>>> model = GPT2DoubleHeadsModel.from_pretrained('gpt2, return_dict=True)
>>> # Add a [CLS] to the vocabulary (we should train it also!)
>>> num_added_tokens = tokenizer.add_special_tokens({'cls_token': '[CLS]'})
>>> embedding_layer = model.resize_token_embeddings(len(tokenizer)) # Update the model embeddings with the new vocabulary size
>>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
>>> encoded_choices = [tokenizer.encode(s) for s in choices]
>>> cls_token_location = [tokens.index(tokenizer.cls_token_id) for tokens in encoded_choices]
>>> input_ids = torch.tensor(encoded_choices).unsqueeze(0) # Batch size: 1, number of choices: 2
>>> mc_token_ids = torch.tensor([cls_token_location]) # Batch size: 1
>>> outputs = model(input_ids, mc_token_ids=mc_token_ids)
>>> lm_logits = outputs.lm_logits
>>> mc_logits = outputs.mc_logits
"""
if "lm_labels" in kwargs:
warnings.warn(
"The `lm_labels` argument is deprecated and will be removed in a future version, use `labels` instead.",
FutureWarning,
)
labels = kwargs.pop("lm_labels")
if "past" in kwargs:
warnings.warn(
"The `past` argument is deprecated and will be removed in a future version, use `past_key_values` instead.",
FutureWarning,
)
past_key_values = kwargs.pop("past")
assert kwargs == {}, f"Unexpected keyword arguments: {list(kwargs.keys())}."
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
transformer_outputs = self.transformer(
input_ids,
past_key_values=past_key_values,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
use_cache=use_cache,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_states = transformer_outputs[0]
lm_logits = self.lm_head(hidden_states)
mc_logits = self.multiple_choice_head(hidden_states, mc_token_ids).squeeze(-1)
mc_loss = None
if mc_labels is not None:
loss_fct = CrossEntropyLoss()
mc_loss = loss_fct(mc_logits.view(-1, mc_logits.size(-1)), mc_labels.view(-1))
lm_loss = None
if labels is not None:
shift_logits = lm_logits[..., :-1, :].contiguous()
shift_labels = labels[..., 1:].contiguous()
loss_fct = CrossEntropyLoss()
lm_loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
if not return_dict:
output = (lm_logits, mc_logits) + transformer_outputs[1:]
if mc_loss is not None:
output = (mc_loss,) + output
return ((lm_loss,) + output) if lm_loss is not None else output
return GPT2DoubleHeadsModelOutput(
loss=lm_loss,
mc_loss=mc_loss,
logits=lm_logits,
mc_logits=mc_logits,
past_key_values=transformer_outputs.past_key_values,
hidden_states=transformer_outputs.hidden_states,
attentions=transformer_outputs.attentions,
)
| craftassist-master | python/base_agent/ttad/back_translation/huggingface_modeling_gpt2.py |
import argparse
import ast
import copy
import json
import os
import random
from recombine_data_utils import *
from typing import *
def create_train_valid_split(chunk_index: int, k: int, data_dir: str, output_dir: str):
"""Create partitions for k fold Cross Validation
Given a chunk index for the valid set, create train and valid split from k chunks of the dataset.
Chunk index is a an index in the range 0 to k.
"""
# Read from other chunks and write JSON file to train/ dir
train_dataset: List[Dict] = []
valid_dataset: List[Dict] = []
for i in range(k):
# Use this as the validation set
if i == chunk_index:
valid_dataset += json.load(
open(data_dir + "cv_pool/chunk_{}/annotated_augmented.json".format(i))
)
else:
train_dataset += json.load(
open(data_dir + "cv_pool/chunk_{}/annotated_augmented.json".format(i))
)
# Write to train and valid directories
directories: List[str] = ["/", "train/", "valid/"]
for d in directories:
if not os.path.isdir(output_dir + d):
os.mkdir(output_dir + d)
print(
"Writing {} entries to {}".format(
len(train_dataset), output_dir + "train/annotated_augmented.json"
)
)
json.dump(train_dataset, open(output_dir + "train/annotated_augmented.json", "w"))
print(
"Writing {} entries to {}".format(
len(valid_dataset), output_dir + "valid/annotated_augmented.json"
)
)
json.dump(valid_dataset, open(output_dir + "valid/annotated_augmented.json", "w"))
def get_train_annotated_commands(
data_dir: str, tool1_path: str, tool2_path: str, node_types: List[str]
) -> (List[str], List[str], Dict[str, dict]):
"""
Fetch Turk data corresponding to annotated data training set.
"""
# Read from tool 1
tool1_lines: List[str] = open(tool1_path).readlines()
# Read from tool 2
tool2_lines: List[str] = open(tool2_path).readlines()
# Load the training data that we created
train_annotated_trees = json.load(open(data_dir + "train/annotated_augmented.json"))
train_annotated_phrases: List[str] = [x[0] for x in train_annotated_trees]
turk_processor = TurkToolProcessor(train_annotated_phrases, node_types)
# Filter samples that we want to use for recombination
filtered_tool1_lines: List[str] = turk_processor.filter_tool1_lines(tool1_lines)
filtered_tool2_lines: List[str] = turk_processor.filter_tool2_lines(tool2_lines)
chat_tree_inserts = turk_processor.build_tree_inserts_dict(tool2_lines)
return (filtered_tool1_lines, filtered_tool2_lines, chat_tree_inserts)
def create_templates_for_node_type(
chat: str,
node_type: str,
action_dict: dict,
filtered_tool1_lines: List[str],
chat_tree_inserts: dict,
) -> (List[tuple], List[tuple]):
"""
Generate templates and fragments for recombination.
"""
new_templates = []
new_fragments = []
# create recombination template and fragment from tree and chat
for k, v in ast.literal_eval(action_dict).items():
if k == node_type:
if contains_span(v):
full_tree_with_hole = get_full_tree(
chat, node_type, filtered_tool1_lines, chat_tree_inserts
)
if full_tree_with_hole is None:
print("Error finding the full tree for chat {}".format(chat))
break
span_idxs = get_loc_span_range(full_tree_with_hole, node_type)
fragment, new_chat = process_chat(chat, span_idxs[1])
# chat, fragment for subs, original tree with hole (for fragment)
# original span idxs so we can shift the new ones over
new_templates.append((new_chat, span_idxs[1], v, full_tree_with_hole))
# chat fragment, corresponding tree
new_fragments.append((fragment, span_idxs[1], v))
return (new_templates, new_fragments)
def gen_chat_tree_templates_and_fragments(
filtered_tool1_lines, filtered_tool2_lines, chat_tree_inserts, node_types
) -> (Dict[str, list], Dict[str, list]):
"""
Generate chat and tree fragments and templates.
"""
full_trees = {}
fragments = {}
for l in filtered_tool2_lines:
chat, child_name, action_dict = l.split("\t")
if child_name in node_types:
if child_name not in full_trees:
full_trees[child_name] = []
if child_name not in fragments:
fragments[child_name] = []
new_templates, new_fragments = create_templates_for_node_type(
chat, child_name, action_dict, filtered_tool1_lines, chat_tree_inserts
)
full_trees[child_name] += new_templates
fragments[child_name] += new_fragments
return (full_trees, fragments)
def process_chat(chat: str, span_idxs: list) -> (str, str):
"""Given a chat and span range, remove the span and insert a single <unk> token.
Return the removed span (Fragment) and processed chat (Template).
"""
tokens = chat.split(" ")
fragment = []
new_tokens = []
idx = span_idxs[0]
while idx <= span_idxs[1]:
fragment.append(tokens[idx])
idx += 1
new_tokens += tokens[0 : span_idxs[0]]
new_tokens.append("<unk>")
if len(span_idxs) > 1:
new_tokens += tokens[(span_idxs[1] + 1) : len(tokens)]
return (" ".join(fragment), " ".join(new_tokens))
def insert_fragment_to_templated_chat(templated_chat: str, fragment: str) -> (str, list):
"""
Utility for inserting fragments to trees and chats. Note that we deepcopy subtrees.
"""
chat_str = templated_chat.split(" ")
new_chat_str = []
span_idx = []
for token in chat_str:
if token == "<unk>":
span_idx.append(len(new_chat_str))
new_chat_str += fragment.split(" ")
span_idx.append(len(new_chat_str) - 1)
else:
new_chat_str.append(token)
return (" ".join(new_chat_str), span_idx)
def insert_subtree_into_full_tree(
subtree: dict, full_tree: dict, original_span_idx: list, idx_shift: int, span_offset: int
) -> dict:
"""
Recursively make sure each span node is updated other than the "no"
"""
new_tree = copy.deepcopy(full_tree)
for k, v in new_tree.items():
if type(v) == dict:
new_tree[k] = insert_subtree_into_full_tree(
subtree, v, original_span_idx, idx_shift, span_offset
)
if type(v) == list:
if type(v[0]) == str:
if v[0] == "yes":
if type(v[1]) == dict:
new_tree[k] = insert_subtree_into_full_tree(
subtree, v[1], original_span_idx, idx_shift, span_offset
)
elif type(v[1]) == list and is_span(v[1]):
new_tree[k] = reformat_span_idxs(v[1])
if new_tree[k][1][0] > original_span_idx[0]:
new_tree[k][1] = [x - idx_shift[1] for x in new_tree[k][1]]
else:
new_tree[k] = v[1]
elif v[0] == "no":
new_tree[k] = update_tree_spans(copy.deepcopy(subtree), span_offset)
elif is_span(v):
new_tree[k] = reformat_span_idxs(v)
# shift indices over if needed
if new_tree[k][1][0] > original_span_idx[0]:
new_tree[k][1] = [x - idx_shift[1] for x in new_tree[k][1]]
return new_tree
def update_fragment_tree(tree: dict, offset: int) -> dict:
"""
Update span positions in a subtree.
"""
new_tree = copy.deepcopy(tree)
for key, value in tree.items():
if type(value) == list and is_span(value):
reformat_idxs = reformat_span_idxs(value)
if contains_negative(reformat_idxs[1], offset):
del new_tree[key]
else:
new_tree[key] = [0, [x - offset for x in reformat_idxs[1]]]
elif type(value) == dict:
new_tree[key] = update_fragment_tree(value, offset)
return new_tree
def create_fragment_dataset(subtrees: list, key: str) -> list:
"""
Creates a dataset of spans given a node type, eg. schematic.
"""
fragments_dataset = []
for fragment_set in subtrees:
text, span, tree = fragment_set
head = {key: copy.deepcopy(tree)}
new_tree = postprocess_tree(update_fragment_tree(head, span[0]))
fragments_dataset.append((text, new_tree["action_sequence"][0]))
return fragments_dataset
def gen_recombined_data(templates: List[tuple], fragments: List[tuple]) -> List[tuple]:
"""
Generate recombined examples.
"""
recombined_data = []
for i in range(len(templates)):
for j in range(len(fragments)):
if i == j:
continue
templated_chat, orig_chat_span_idx, templated_tree, templated_full_tree = templates[i]
fragment, orig_fragment_span_idx, subtree = fragments[j]
recombined_chat, new_chat_span_idx = insert_fragment_to_templated_chat(
templated_chat, fragment
)
# Calculate shift between original span idx and new span idx
idx_shift = [
orig_chat_span_idx[0] - new_chat_span_idx[0],
orig_chat_span_idx[1] - new_chat_span_idx[1],
]
# span gap for templated chat - orig_chat_span_idx
# offset for span - orig_fragment_span_idx
span_offset = orig_fragment_span_idx[0] - new_chat_span_idx[0]
recombined_full_tree = insert_subtree_into_full_tree(
subtree, templated_full_tree, orig_chat_span_idx, idx_shift, span_offset
)
recombined_full_tree = postprocess_tree(recombined_full_tree)
recombined_data.append((recombined_chat, recombined_full_tree))
return recombined_data
def write_recombined_data_chunk(
data_dir: str,
output_dir: str,
tool1_path: str,
tool2_path: str,
dataset_name: str,
node_types: List[str],
use_fragments: bool,
):
"""
Read from a partition and write recombined results to output directory.
"""
filtered_tool1_lines, filtered_tool2_lines, chat_tree_inserts = get_train_annotated_commands(
data_dir, tool1_path, tool2_path, node_types
)
combined_templates, combined_fragments = gen_chat_tree_templates_and_fragments(
filtered_tool1_lines, filtered_tool2_lines, chat_tree_inserts, node_types
)
recombined_data: List[List[str, dict]] = []
fragments_dataset: List[List[str, dict]] = []
for key in node_types:
recombined_data += gen_recombined_data(combined_templates[key], combined_fragments[key])
fragments_dataset += create_fragment_dataset(combined_fragments[key], key)
train_output_dir = output_dir + "train/"
if not os.path.isdir(train_output_dir):
os.mkdir(train_output_dir)
if use_fragments:
random.shuffle(fragments_dataset)
fragments_data = [[str(x[0]), x[1]] for x in fragments_dataset]
with open(train_output_dir + dataset_name + "_fragments.json", "w") as outfile:
print(
"Writing {} fragments data samples to directory {}".format(
len(fragments_data), train_output_dir + dataset_name + ".json"
)
)
json.dump(fragments_dataset, outfile)
else:
recombined_data += fragments_dataset
random.shuffle(recombined_data)
recombined_data = [[str(x[0]), x[1]] for x in recombined_data]
print("Created recombined dataset with size {}".format(len(recombined_data)))
with open(train_output_dir + dataset_name + ".json", "w") as outfile:
print(
"Writing {} recombined data samples to directory {}".format(
len(recombined_data), train_output_dir + dataset_name + ".json"
)
)
json.dump(recombined_data, outfile)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--data_dir",
default="/private/home/rebeccaqian/minecraft/python/craftassist/ttad/data/annotated_data/",
type=str,
help="train/valid/test data",
)
parser.add_argument(
"--dataset_name",
default="prompts_recombined_location_ref_objects",
type=str,
help="name of recombined dataset",
)
parser.add_argument(
"--output_dir",
default="/checkpoint/rebeccaqian/files/annotated_data/",
type=str,
help="directory to write recombined data",
)
parser.add_argument(
"-k", default=10, type=int, help="Number of partitions in leave-k-out-cross-validation."
)
parser.add_argument(
"--create_k_fold_split",
action="store_true",
help="Whether to split data into k partitions.",
)
parser.add_argument(
"--fragments", action="store_true", help="Only generate fragments (default is both)."
)
parser.add_argument(
"--node_types",
default="location,reference_object,schematic",
type=str,
help="Comma-separated types of nodes to use for recombination",
)
parser.add_argument(
"--tool1_path",
default="/private/home/rebeccaqian/minecraft/python/craftassist/text_to_tree_tool/turk_data/tool1/prompts/2_200/all_agreements.txt",
type=str,
help="Path to tool1 .txt file",
)
parser.add_argument(
"--tool2_path",
default="/private/home/rebeccaqian/minecraft/python/craftassist/text_to_tree_tool/turk_data/tool2/prompts/2_200/all_agreements.txt",
type=str,
help="Path to tool2 .txt file",
)
args = parser.parse_args()
# types of nodes we want to use for recombination
node_types = args.node_types.split(",")
if args.create_k_fold_split:
for valid_partition_idx in range(args.k):
output_dir = args.output_dir + "run_{}".format(str(valid_partition_idx)) + "/"
create_train_valid_split(valid_partition_idx, args.k, args.data_dir, output_dir)
data_dir = output_dir
write_recombined_data_chunk(
data_dir=data_dir,
output_dir=output_dir,
tool1_path=args.tool1_path,
tool2_path=args.tool2_path,
dataset_name=args.dataset_name,
node_types=node_types,
use_fragments=args.fragments,
)
else:
output_dir = args.output_dir
data_dir = args.data_dir
write_recombined_data_chunk(
data_dir=data_dir,
output_dir=output_dir,
tool1_path=args.tool1_path,
tool2_path=args.tool2_path,
dataset_name=args.dataset_name,
node_types=node_types,
use_fragments=args.fragments,
)
if __name__ == "__main__":
main()
| craftassist-master | python/base_agent/ttad/ttad_transformer_model/recombine_data.py |
# flake8: noqa
import json
import math
import pickle
import torch
from transformers import AutoModel, AutoTokenizer, BertConfig
from utils_caip import *
from utils_parsing import *
from train_model import *
from pprint import pprint
model = "python/craftassist/models/semantic_parser/ttad_bert_updated/caip_test_model.pth"
args_path = "python/craftassist/models/semantic_parser/ttad_bert_updated/caip_test_model_args.pk"
args = pickle.load(open(args_path, "rb"))
tokenizer = AutoTokenizer.from_pretrained(args.pretrained_encoder_name)
full_tree, tree_i2w = json.load(open(args.tree_voc_file))
dataset = CAIPDataset(tokenizer, args, prefix="", full_tree_voc=(full_tree, tree_i2w))
enc_model = AutoModel.from_pretrained(args.pretrained_encoder_name)
bert_config = BertConfig.from_pretrained("bert-base-uncased")
bert_config.is_decoder = True
bert_config.vocab_size = len(tree_i2w) + 8
bert_config.num_hidden_layers = args.num_decoder_layers
dec_with_loss = DecoderWithLoss(bert_config, args, tokenizer)
encoder_decoder = EncoderDecoderWithLoss(enc_model, dec_with_loss, args)
encoder_decoder.load_state_dict(torch.load(model))
encoder_decoder = encoder_decoder.cuda()
_ = encoder_decoder.eval()
def get_beam_tree(chat, noop_thres=0.95, beam_size=5, well_formed_pen=1e2):
btr = beam_search(chat, encoder_decoder, tokenizer, dataset, beam_size, well_formed_pen)
if btr[0][0].get("dialogue_type", "NONE") == "NOOP" and math.exp(btr[0][1]) < noop_thres:
tree = btr[1][0]
else:
tree = btr[0][0]
return tree
| craftassist-master | python/base_agent/ttad/ttad_transformer_model/test_model_script.py |
import argparse
import functools
import json
import logging
import logging.handlers
import os
import pickle
from time import time
from os.path import isfile
from os.path import join as pjoin
from tqdm import tqdm
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler
from transformers import AutoModel, AutoTokenizer, BertConfig
from utils_parsing import *
from utils_caip import *
# Wrapper Class around model and data loader
class ModelTrainer:
def __init__(self, args):
self.args = args
# training loop (all epochs at once)
def train(self, model, dataset, tokenizer, model_identifier, full_tree_voc):
# make data sampler
train_sampler = RandomSampler(dataset)
logging.info("Initializing train data sampler: {}".format(train_sampler))
model_collate_fn = functools.partial(
caip_collate, tokenizer=tokenizer, tree_to_text=self.args.tree_to_text
)
train_dataloader = DataLoader(
dataset,
sampler=train_sampler,
batch_size=self.args.batch_size,
collate_fn=model_collate_fn,
)
epoch_iterator = tqdm(train_dataloader, desc="Iteration", disable=True)
# make optimizer
optimizer = OptimWarmupEncoderDecoder(model, self.args)
text_span_optimizer = Adam(
[
{"params": model.decoder.text_span_start_head.parameters()},
{"params": model.decoder.text_span_end_head.parameters()},
],
lr=0.001,
)
text_span_loss_attenuation_factor = self.args.alpha
# training loop
logging.info("Beginning training loop")
for e in range(self.args.num_epochs):
logging.info("Epoch: {}".format(e))
loc_steps = 0
loc_loss = 0.0
loc_int_acc = 0.0
loc_span_acc = 0.0
loc_full_acc = 0.0
text_span_accuracy = 0.0
tot_steps = 0
tot_loss = 0.0
text_span_tot_loss = 0.0
text_span_loc_loss = 0.0
tot_accuracy = 0.0
st_time = time()
for step, batch in enumerate(epoch_iterator):
batch_examples = batch[-1]
batch_tensors = [
t.to(model.decoder.lm_head.predictions.decoder.weight.device)
for t in batch[:4]
]
x, x_mask, y, y_mask = batch_tensors
if self.args.tree_to_text:
outputs = model(y, y_mask, x, x_mask)
else:
outputs = model(x, x_mask, y, y_mask)
loss = outputs["loss"]
text_span_loss = outputs["text_span_loss"]
model.zero_grad()
# backprop
text_span_loss.backward()
text_span_optimizer.step()
loss.backward()
model.decoder.bert_final_layer_out.grad = model.decoder.bert_final_layer_out.grad.add(
text_span_loss_attenuation_factor
* (
model.decoder.text_span_start_hidden_z.grad
+ model.decoder.text_span_end_hidden_z.grad
)
)
if step % self.args.param_update_freq == 0:
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
# text_span_optimizer.step()
optimizer.step()
# compute accuracy and add hard examples
if self.args.tree_to_text:
full_acc = compute_accuracy(outputs, x)
# hacky
lm_acc = full_acc
else:
lm_acc, sp_acc, text_span_acc, full_acc = compute_accuracy(outputs, y)
if "hard" in dataset.dtypes:
if e > 0 or tot_steps > 2 * args.decoder_warmup_steps:
for acc, exple in zip(lm_acc, batch_examples):
if not acc.item():
if step % 200 == 100:
print("ADDING HE:", step, exple[0])
dataset.add_hard_example(exple)
# book-keeping
loc_int_acc += lm_acc.sum().item() / lm_acc.shape[0]
loc_full_acc += full_acc.sum().item() / full_acc.shape[0]
tot_accuracy += full_acc.sum().item() / full_acc.shape[0]
text_span_accuracy += text_span_acc.sum().item() / text_span_acc.shape[0]
if not self.args.tree_to_text:
loc_span_acc += sp_acc.sum().item() / sp_acc.shape[0]
loc_loss += loss.item()
loc_steps += 1
tot_loss += loss.item()
tot_steps += 1
text_span_tot_loss += text_span_loss.item()
text_span_loc_loss += text_span_loss.item()
if step % 400 == 0:
print(
"{:2d} - {:5d} \t L: {:.3f} A: {:.3f} \t {:.2f}".format(
e,
step,
loc_loss / loc_steps,
loc_full_acc / loc_steps,
time() - st_time,
)
)
logging.info(
"{:2d} - {:5d} \t L: {:.3f} A: {:.3f} \t {:.2f}".format(
e,
step,
loc_loss / loc_steps,
loc_full_acc / loc_steps,
time() - st_time,
)
)
logging.info("text span acc: {:.3f}".format(text_span_accuracy / loc_steps))
logging.info("text span loss: {:.3f}".format(text_span_loc_loss / loc_steps))
loc_loss = 0
loc_steps = 0
loc_int_acc = 0.0
loc_span_acc = 0.0
loc_full_acc = 0.0
text_span_accuracy = 0.0
text_span_loc_loss = 0.0
torch.save(
model.state_dict(),
pjoin(self.args.output_dir, "{}(ep=={}).pth".format(model_identifier, e)),
)
# Evaluating model
model.eval()
logging.info("evaluating model")
for dtype_spec in json.loads(self.args.dtype_samples):
dtype, ratio = dtype_spec
self.eval_model_on_dataset(model, dtype, full_tree_voc, tokenizer)
return (tot_loss / tot_steps, tot_accuracy / tot_steps)
# same as training loop without back-propagation
def validate(self, model, dataset, tokenizer, args):
# make data sampler
train_sampler = SequentialSampler(dataset)
model_collate_fn = functools.partial(
caip_collate, tokenizer=tokenizer, tree_to_text=args.tree_to_text
)
train_dataloader = DataLoader(
dataset, sampler=train_sampler, batch_size=args.batch_size, collate_fn=model_collate_fn
)
epoch_iterator = tqdm(train_dataloader, desc="Iteration", disable=True)
# training loop
tot_steps = 0
tot_loss = 0.0
tot_int_acc = 0.0
tot_span_acc = 0.0
tot_accu = 0.0
text_span_tot_acc = 0.0
text_span_tot_loss = 0.0
# disable autograd to reduce memory usage
with torch.no_grad():
for step, batch in enumerate(epoch_iterator):
batch_tensors = [
t.to(model.decoder.lm_head.predictions.decoder.weight.device)
for t in batch[:4]
]
x, x_mask, y, y_mask = batch_tensors
outputs = model(x, x_mask, y, y_mask)
loss = outputs["loss"]
text_span_loss = outputs["text_span_loss"]
# compute accuracy and add hard examples
lm_acc, sp_acc, text_span_acc, full_acc = compute_accuracy(outputs, y)
# book-keeping
tot_int_acc += lm_acc.sum().item() / lm_acc.shape[0]
tot_span_acc += sp_acc.sum().item() / sp_acc.shape[0]
tot_accu += full_acc.sum().item() / full_acc.shape[0]
tot_loss += loss.item()
tot_steps += 1
# text span stats
text_span_tot_acc += text_span_acc.sum().item() / text_span_acc.shape[0]
text_span_tot_loss += text_span_loss.item()
return (
tot_loss / tot_steps,
tot_int_acc / tot_steps,
tot_span_acc / tot_steps,
tot_accu / tot_steps,
text_span_tot_acc / tot_steps,
text_span_tot_loss / tot_steps,
)
# Evaluate model on a given validation dataset:
def eval_model_on_dataset(self, encoder_decoder, dtype, full_tree_voc, tokenizer):
valid_dataset = CAIPDataset(
tokenizer, self.args, prefix="valid", dtype=dtype, full_tree_voc=full_tree_voc
)
l, _, _, a, text_span_acc, text_span_loss = self.validate(
encoder_decoder, valid_dataset, tokenizer, self.args
)
print("evaluating on {} valid: \t Loss: {:.4f} \t Accuracy: {:.4f}".format(dtype, l, a))
logging.info(
"evaluating on {} valid: \t Loss: {:.4f} \t Accuracy: {:.4f}".format(dtype, l, a)
)
logging.info(
"text span Loss: {:.4f} \t Accuracy: {:.4f}".format(text_span_loss, text_span_acc)
)
def generate_model_name(args, optional_identifier=""):
name = ""
# unix time in seconds, used as a unique identifier
time_now = round(time())
args_keys = {
"batch_size": "batch",
"decoder_learning_rate": "dec_lr",
"decoder_warmup_steps": "dec_ws",
"dtype_samples": "spl",
"encoder_learning_rate": "enc_lr",
"encoder_warmup_steps": "enc_ws",
"model_name": "name",
"node_label_smoothing": "n_ls",
"num_epochs": "ep",
"num_highway": "hw",
"param_update_freq": "upd_frq",
"word_dropout": "word_drp",
"alpha": "a",
}
for k, v in vars(args).items():
if k in args_keys:
name += "{param}={value}|".format(param=args_keys[k], value=v)
# In case we want additional identification for the model, eg. test run
name += "{time}|".format(time=time_now)
name += optional_identifier
return name
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--data_dir",
default="python/craftassist/datasets/annotated_data/",
type=str,
help="train/valid/test data",
)
parser.add_argument(
"--output_dir",
default="python/craftassist/models/semantic_parser/ttad_bert_updated/",
type=str,
help="Where we save the model",
)
parser.add_argument("--model_name", default="caip_parser", type=str, help="Model name")
parser.add_argument(
"--tree_voc_file",
default="python/craftassist/models/semantic_parser/ttad_bert_updated/caip_test_model_tree.json",
type=str,
help="Pre-computed grammar and output vocabulary",
)
# model arguments
parser.add_argument(
"--pretrained_encoder_name",
default="distilbert-base-uncased",
type=str,
help="Pretrained text encoder "
"See full list at https://huggingface.co/transformers/pretrained_models.html",
)
parser.add_argument(
"--num_decoder_layers",
default=6,
type=int,
help="Number of transformer layers in the decoder",
)
parser.add_argument(
"--num_highway", default=2, type=int, help="Number of highway layers in the mapping model"
)
# optimization arguments
parser.add_argument(
"--optimizer", default="adam", type=str, help="Optimizer in [adam|adagrad]"
)
parser.add_argument("--batch_size", default=56, type=int, help="Batch size")
parser.add_argument("--param_update_freq", default=1, type=int, help="Group N batch updates")
parser.add_argument("--num_epochs", default=8, type=int, help="Number of training epochs")
parser.add_argument(
"--examples_per_epoch", default=-1, type=int, help="Number of training examples per epoch"
)
parser.add_argument(
"--train_encoder", action="store_true", help="Whether to finetune the encoder"
)
parser.add_argument(
"--encoder_warmup_steps",
default=1,
type=int,
help="Learning rate warmup steps for the encoder",
)
parser.add_argument(
"--encoder_learning_rate", default=0.0, type=float, help="Learning rate for the encoder"
)
parser.add_argument(
"--decoder_warmup_steps",
default=1000,
type=int,
help="Learning rate warmup steps for the decoder",
)
parser.add_argument(
"--decoder_learning_rate", default=1e-5, type=float, help="Learning rate for the decoder"
)
parser.add_argument(
"--lambda_span_loss",
default=0.5,
type=float,
help="Weighting between node and span prediction losses",
)
parser.add_argument(
"--node_label_smoothing",
default=0.0,
type=float,
help="Label smoothing for node prediction",
)
parser.add_argument(
"--span_label_smoothing",
default=0.0,
type=float,
help="Label smoothing for span prediction",
)
parser.add_argument(
"--dtype_samples",
default='[["templated", 0.55], ["templated_modify", 0.05], ["annotated", 0.4]]',
type=str,
help="Sampling probabilities for handling different data types",
)
parser.add_argument(
"--rephrase_proba", default=-1.0, type=float, help="Only specify probablility of rephrases"
)
parser.add_argument(
"--word_dropout",
default=0.0,
type=float,
help="Probability of replacing input token with [UNK]",
)
parser.add_argument(
"--encoder_dropout", default=0.0, type=float, help="Apply dropout to encoder output"
)
parser.add_argument("--tree_to_text", action="store_true", help="Back translation flag")
parser.add_argument(
"--optional_identifier", default="", type=str, help="Optional run info eg. debug or test"
)
parser.add_argument(
"--alpha",
default=0.8,
type=float,
help="Attenuation factor for text span loss gradient affecting shared layers for tree structure prediction",
)
args = parser.parse_args()
# HACK: allows us to give rephrase proba only instead of full dictionary
if args.rephrase_proba > 0:
args.dtype_samples = json.dumps(
[["templated", 1.0 - args.rephrase_proba], ["rephrases", args.rephrase_proba]]
)
model_identifier = generate_model_name(args, args.optional_identifier)
# set up logging
l_handler = logging.handlers.WatchedFileHandler(
"{}/{}.log".format(args.output_dir, model_identifier)
)
l_format = logging.Formatter(fmt="%(asctime)s - %(message)s", datefmt="%d-%b-%y %H:%M:%S")
l_handler.setFormatter(l_format)
l_root = logging.getLogger()
l_root.setLevel(os.environ.get("LOGLEVEL", "INFO"))
l_root.addHandler(l_handler)
logging.info("****** Args ******")
logging.info(vars(args))
logging.info("model identifier: {}".format(model_identifier))
if isfile(args.tree_voc_file):
logging.info("====== Loading Grammar ======")
full_tree, tree_i2w = json.load(open(args.tree_voc_file))
else:
logging.info("====== Making Grammar ======")
data = {"train": {}, "valid": {}, "test": {}}
dtype_samples_unpacked = json.loads(args.dtype_samples)
dtypes = [t for t, p in dtype_samples_unpacked]
for spl in data:
for dt in dtypes:
fname = pjoin(args.data_dir, "{}/{}.txt".format(spl, dt))
logging.info("loading file {}".format(fname))
if isfile(fname):
data[spl][fname.split("/")[-1][:-4]] = process_txt_data(filepath=fname)
full_tree, tree_i2w = make_full_tree(
[
(d_list, 1.0)
for spl, dtype_dict in data.items()
for dtype, d_list in dtype_dict.items()
]
)
json.dump((full_tree, tree_i2w), open(args.tree_voc_file, "w"))
tokenizer = AutoTokenizer.from_pretrained(args.pretrained_encoder_name)
logging.info("====== Loading Dataset ======")
train_dataset = CAIPDataset(
tokenizer,
args,
prefix="train",
sampling=True,
word_noise=args.word_dropout,
full_tree_voc=(full_tree, tree_i2w),
)
logging.info("====== Setting up Model ======")
# make model
logging.info("making model")
enc_model = AutoModel.from_pretrained(args.pretrained_encoder_name)
bert_config = BertConfig.from_pretrained("bert-base-uncased")
bert_config.is_decoder = True
if args.tree_to_text:
tokenizer.add_tokens(tree_i2w)
else:
bert_config.vocab_size = len(tree_i2w) + 8
logging.info("vocab size {}".format(bert_config.vocab_size))
bert_config.num_hidden_layers = args.num_decoder_layers
dec_with_loss = DecoderWithLoss(bert_config, args, tokenizer)
encoder_decoder = EncoderDecoderWithLoss(enc_model, dec_with_loss, args)
# save configs
json.dump(
(full_tree, tree_i2w), open(pjoin(args.output_dir, model_identifier + "_tree.json"), "w")
)
pickle.dump(args, open(pjoin(args.output_dir, model_identifier + "_args.pk"), "wb"))
# train_model
logging.info("====== Training Model ======")
encoder_decoder = encoder_decoder.cuda()
encoder_decoder.train()
full_tree_voc = (full_tree, tree_i2w)
model_trainer = ModelTrainer(args)
loss, accu = model_trainer.train(
encoder_decoder, train_dataset, tokenizer, model_identifier, full_tree_voc
)
if __name__ == "__main__":
main()
| craftassist-master | python/base_agent/ttad/ttad_transformer_model/train_model.py |
import os
import sys
sys.path.append(os.path.dirname(__file__))
| craftassist-master | python/base_agent/ttad/ttad_transformer_model/__init__.py |
import ast
import copy
from enum import Enum
from typing import *
class TurkToolProcessor:
def __init__(self, train_annotated_phrases: List[str], node_types: List[str]):
self.train_annotated_phrases = train_annotated_phrases
self.node_types = node_types
def filter_tool1_lines(self, tool1_lines: List[str]) -> List[str]:
"""Fetch Turk tool1 lines that correspond to the training dataset.
-- tool1_lines: input from Turk tool, with format <text> \t <action dict>
-- node_types: list of nodes we want to swap, eg. location
Source: https://github.com/fairinternal/minecraft/tree/master/python/craftassist/text_to_tree_tool/turk_data/tool1/
"""
filtered_lines = []
for l in tool1_lines:
text, action_dict = l.split("\t")
if text in self.train_annotated_phrases:
# Check that the tree can be expanded
if "no" not in action_dict:
continue
for key in self.node_types:
if key in action_dict:
filtered_lines.append(l)
break
return filtered_lines
def is_chat_subset(self, chat: str) -> bool:
"""
Checks whether a chat fits criteria for recombination.
"""
return (
chat in self.train_annotated_phrases
and len(chat.split(" ")) <= 30
and "composite_action" not in chat
)
def filter_tool2_lines(self, tool2_lines: List[str]) -> List[str]:
"""Fetch Turk tool2 lines that correspond to the training dataset.
tool2_lines -- input from Turk tool, with format <chat> \t <tag> \t <action dict>
node_types -- list of nodes we want to swap, eg. location
Source: https://github.com/fairinternal/minecraft/tree/master/python/craftassist/text_to_tree_tool/turk_data/tool2/
"""
filtered_lines = []
for l in tool2_lines:
chat, tag, action_dict = l.split("\t")
use_chat = self.is_chat_subset(chat)
if tag in self.node_types and use_chat:
filtered_lines.append(l)
return filtered_lines
def build_tree_inserts_dict(self, lines: List[str]) -> Dict[str, dict]:
"""
Build tree representation of chats and all inserts for the full tree
"""
chat_tree_inserts = {}
for l in lines:
chat, tag, action_dict = l.split("\t")
if chat in self.train_annotated_phrases:
if chat not in chat_tree_inserts:
chat_tree_inserts[chat] = {tag: ast.literal_eval(action_dict)}
else:
chat_tree_inserts[chat][tag] = ast.literal_eval(action_dict)
return chat_tree_inserts
def get_full_tree(
chat: str, key: str, tool1_lines: List[str], chat_tree_inserts: List[dict]
) -> Union[dict, None]:
"""
Given a chat command, fetch the full tree minus the node we want to swap.
"""
# Fetch the corresponding full tree with hole
for full_line in tool1_lines:
if chat in full_line:
_, full_tree = full_line.split("\t")
full_tree_dict = ast.literal_eval(full_tree)
# fill other holes
full_tree_dict = fill_other_holes(key, full_tree_dict, chat, chat_tree_inserts)
return full_tree_dict
return None
def fill_other_holes(key: str, full_tree: dict, chat: str, chat_tree_inserts: dict) -> dict:
"""Given a full tree (with holes), node type of swaps and the chat command, fill the holes for nodes
that we are not swapping.
"""
new_tree = copy.deepcopy(full_tree)
for k, v in new_tree.items():
if v[0] == "no" and k != key:
if type(v[1]) == list:
new_tree[k] = v[1]
# get the subtree from the grouped document by the chat instruction
tree_insert = copy.deepcopy(chat_tree_inserts[chat][k][k])
new_tree[k] = tree_insert
return new_tree
class SpanType(Enum):
TURK = 1
DATASET = 2
def is_span(val: Any) -> Union[bool, SpanType]:
"""
Check if a value is a span type.
"""
if type(val) == list:
# Unformatted spans
if type(val[0]) == list and type(val[0][0]) == int:
return SpanType.TURK
# Formatted spans
if type(val[0]) == int and type(val[1]) == list:
return SpanType.DATASET
return False
def contains_negative(span: List[int], offset: int) -> bool:
"""
Checks if a recombined span contains negative values.
"""
for idx in span:
if idx - int(offset) < 0:
return True
return False
def contains_span(tree: dict) -> bool:
"""
Whether a tree contains span nodes.
"""
for k, v in tree.items():
if type(v) == dict:
return contains_span(v)
if type(v) == list:
if is_span(v):
return True
return False
def get_loc_span_range(tree: dict, key: str) -> Union[list, None]:
"""
Fetch the span range for the subtree to be inserted into the full tree (with hole).
"""
for k, v in tree.items():
if k == key:
if type(v) == list and v[0] == "no":
span_range = reformat_span_idxs(v[1])
return span_range
return None
def reformat_span_idxs(span_idx_list: List[List[int]]) -> list:
"""
Reformat span idxs to look like [0, [start_idx, end_idx]]
"""
span_idxs = [x[0] for x in span_idx_list]
start_idx = min(span_idxs)
end_idx = max(span_idxs)
return [0, [start_idx, end_idx]]
def update_tree_spans(tree: dict, shift: int) -> dict:
"""Insert recombined tree into parent tree.
Get rid of "yes" and "no" indicators, reformat tree, insert subtrees.
"""
new_tree = copy.deepcopy(tree)
for k, v in new_tree.items():
if type(v) == dict:
new_tree[k] = update_tree_spans(v, shift)
span_type = is_span(v)
if span_type:
if span_type == SpanType.TURK:
new_tree[k] = reformat_span_idxs(v)
new_tree[k][1] = [x - shift for x in new_tree[k][1]]
return new_tree
def postprocess_tree(tree: dict) -> dict:
"""
Process a turk tool generated tree to fit the format for model datasets.
"""
new_tree = copy.deepcopy(tree)
new_tree = postprocess_tree_helper(new_tree)
new_tree["action_sequence"] = [{}]
for k, v in copy.deepcopy(new_tree).items():
if k != "dialogue_type" and k != "action_sequence":
for i in range(len(new_tree["action_sequence"])):
action_dict = new_tree["action_sequence"][i]
if k not in action_dict:
action_dict[k] = v
elif i == len(new_tree["action_sequence"]) - 1:
new_tree["action_sequence"].append({k: v})
del new_tree[k]
return new_tree
def postprocess_tree_helper(tree: dict) -> dict:
"""
Post processing recombined tree.
"""
new_tree = copy.deepcopy(tree)
for k, v in tree.items():
if k == "action_type":
if v == "copy":
new_tree[k] = "build"
new_tree[k] = new_tree[k].upper()
if k == "contains_coreference" and v == "no":
del new_tree[k]
if type(v) == dict:
new_tree[k] = postprocess_tree_helper(v)
return new_tree
| craftassist-master | python/base_agent/ttad/ttad_transformer_model/recombine_data_utils.py |
import json
import numpy as np
import random
import re
import ast
from os.path import isfile, isdir
from os.path import join as pjoin
import torch
from torch.utils.data import Dataset
#########
# Node typing: checking the type of a specific sub-tree (dict value)
#########
def is_span(val):
try:
a, (b, c) = val
return all([type(v) == int for v in [a, b, c]])
except (ValueError, TypeError):
return False
def is_span_list(val):
res = type(val) == list and len(val) > 0 and all([is_span(v) for v in val])
return res
def is_cat(val):
return type(val) == str or val is True or val is False
def is_cat_list(val):
res = (type(val) == list) and len(val) > 0 and all([is_cat(v) for v in val])
return res
def is_int(val):
return type(val) == dict
def is_int_list(val):
res = (type(val) == list) and len(val) > 0 and all([is_int(v) for v in val])
return res
#########
# Make grammar from dataset. Starts with empty full_tree
# then add all nodes found in the dataset
#########
# if new_tree is outside of what the grammar can handle, modifies grammar
# also counts number of occurence of each node
def add_tree(full_tree, new_tree, vocounts, nw=1):
for k, v in new_tree.items():
if k not in full_tree:
full_tree[k] = {"name": k, "children": {}, "values": {}, "count": 0}
full_tree[k]["count"] += nw
if is_cat(v):
full_tree[k]["values"][v] = full_tree[k]["values"].get(v, 0) + nw
w = "C:" + k + "|" + str(v)
vocounts[w] = vocounts.get(w, 0) + nw
elif is_int(v):
ws = "IB:" + k
we = "IE:" + k
vocounts[ws] = vocounts.get(ws, 0) + nw
vocounts[we] = vocounts.get(we, 0) + nw
add_tree(full_tree[k]["children"], v, vocounts, nw)
elif is_int_list(v):
ws = "ILB:" + k
wi = "IL&:" + k
we = "ILE:" + k
vocounts[ws] = vocounts.get(ws, 0) + nw
vocounts[wi] = vocounts.get(wi, 0) + nw
vocounts[we] = vocounts.get(we, 0) + nw
for c in v:
add_tree(full_tree[k]["children"], c, vocounts, nw)
elif is_span(v) or is_span_list(v):
# Treating text spans differently because of separate head predicting text spans
if k == "text_span":
w = "TS:" + k
ws = "TBE:" + k
vocounts[w] = vocounts.get(w, 0) + nw
vocounts[ws] = vocounts.get(ws, 0) + nw
w = "S:" + k
ws = "BE:" + k
vocounts[w] = vocounts.get(w, 0) + nw
vocounts[ws] = vocounts.get(ws, 0) + nw
# starts with an empty grammar and adds trees from the dataset
def make_full_tree(trees_weight_ls):
res = {}
vocounts = {}
for trees, weight in trees_weight_ls:
try:
for tree in trees:
dlg, tr = tree
add_tree(res, tr, vocounts, weight)
except ValueError as e:
print(e)
print(tree)
tree_i2w = [k for k, v in sorted(vocounts.items(), key=lambda x: x[1], reverse=True)] + [
"BE:span"
]
return res, tree_i2w
# Converts a txt file format to the tree format needed to construct grammar
def process_txt_data(filepath: str):
samples = open(filepath, "r").readlines()
split_lines = [line.split("|") for line in samples]
# Format of each sample is [text, action_dict]
formatted_data = [[text, ast.literal_eval(action_dict)] for text, action_dict in split_lines]
return formatted_data
#########
# Linearize and de-linearize trees
#########
# transforms tree into sequence of (token, span_start, span_end, text_span_start, text_span_end)
# idx_map maps the span ids before and after tokenization
def tree_to_seq(full_tree, tree, idx_map=None):
res = []
sorted_keys = sorted(
[k for k in tree.keys() if k in full_tree],
key=lambda x: full_tree[x]["count"],
reverse=True,
) + sorted([k for k, v in tree.items() if k not in full_tree])
for k in sorted_keys:
if is_cat(tree[k]):
res += [("C:" + k + "|" + str(tree[k]), -1, -1, -1, -1)]
elif is_span(tree[k]):
if k == "text_span":
a, (b, c) = tree[k]
res += [("TS:" + k, -1, -1, -1, -1)]
res += [("TBE:" + k, -1, -1, idx_map[a][b][0], idx_map[a][c][1])]
else:
a, (b, c) = tree[k]
res += [("S:" + k, -1, -1, -1, -1)]
res += [("BE:" + k, idx_map[a][b][0], idx_map[a][c][1], -1, -1)]
elif is_int(tree[k]):
res += (
[("IB:" + k, -1, -1, -1, -1)]
+ tree_to_seq(full_tree.get(k, {"children": {}})["children"], tree[k], idx_map)
+ [("IE:" + k, -1, -1, -1, -1)]
)
elif is_int_list(tree[k]):
res += [("ILB:" + k, -1, -1, -1, -1)]
for c in tree[k]:
res += tree_to_seq(full_tree.get(k, {"children": {}})["children"], c, idx_map) + [
("IL&:" + k, -1, -1, -1, -1)
]
res = res[:-1] + [("ILE:" + k, -1, -1, -1, -1)]
else:
raise NotImplementedError
return res
# selects sub-tree in (span in the output sequence) so we can apply recursively seq_to_tree
def select_spans(seq):
spans = [-1 for _ in seq]
active = {}
unopened = False
for i, (w, b_id, e_id, text_span_b_id, text_span_e_id) in enumerate(seq):
if w.startswith("IB:") or w.startswith("ILB:"):
active[w] = active.get(w, {})
active[w][i] = 0
for s_idx in active[w]:
active[w][s_idx] += 1
elif w.startswith("IE:") or w.startswith("ILE:"):
ws = w.replace("E:", "B:")
if ws not in active:
# closing an unopened bracket
unopened = True
else:
closed = []
for s_idx in active[ws]:
active[ws][s_idx] -= 1
if active[ws][s_idx] <= 0:
closed += [s_idx]
spans[s_idx] = i
for s_idx in closed:
del active[ws][s_idx]
# check whether all brackets have been closed
well_formed = (sum([len(ctr_dict) for ws, ctr_dict in active.items()]) == 0) and not unopened
for ws in active:
for s_idx in active[ws]:
spans[s_idx] = len(seq)
# create a dictionary of left bracket > right bracket
span_dict = {}
for s_idx, e_idx in enumerate(spans):
if e_idx > 0:
span_dict[s_idx] = e_idx
return (span_dict, well_formed)
# transforms sequence back into tree of nested dictionaries
# span_dict identifies the sub-sequences corresponding to sub-trees
def seq_to_tree(full_tree, seq, idx_rev_map=None, span_dct=None, start_id=0):
res = {}
if span_dct is None:
span_dict, well_formed = select_spans(seq)
else:
span_dict = span_dct
well_formed = True
idx = 0
while idx < len(seq):
if ":" not in seq[idx][0]:
idx += 1
continue
t, w = seq[idx][0].split(":")
# categorical node
if t == "C":
cat, val = w.split("|")
res[cat] = val
idx += 1
# span node
elif t == "S":
if idx + 1 < len(seq):
b_pre = seq[idx + 1][1]
e_pre = seq[idx + 1][2]
l_idx, b_idx = idx_rev_map[b_pre]
_, e_idx = idx_rev_map[e_pre]
res[w] = [l_idx, [b_idx, e_idx]]
else:
res[w] = [-1, [-1, -1]]
# idx += 1
idx += 2
elif t == "TS":
if idx + 1 < len(seq):
text_span_start = seq[idx + 1][3]
text_span_end = seq[idx + 1][4]
list_idx, start_idx = idx_rev_map[text_span_start]
_, end_idx = idx_rev_map[text_span_end]
res[w] = [list_idx, [start_idx, end_idx]]
else:
res[w] = [-1, [-1, -1]]
idx += 2
# internal node
elif t == "IB":
sub_full_tree = full_tree.get(w, {"children": {}})["children"]
sub_span = (idx + 1, span_dict[start_id + idx] - start_id)
sub_seq = seq[sub_span[0] : sub_span[1]]
res[w] = seq_to_tree(
sub_full_tree, sub_seq, idx_rev_map, span_dict, start_id=start_id + sub_span[0]
)[0]
idx = sub_span[1]
# internal node list
elif t == "ILB":
sub_full_tree = full_tree.get(w, {"children": {}})["children"]
sub_span = (idx + 1, span_dict[start_id + idx] - start_id)
pre_sub_seq = seq[sub_span[0] : sub_span[1]]
# split sub-sequence by list items
sub_seq_ls_idx = (
[-1]
+ [i for i, sw in enumerate(pre_sub_seq) if sw[0] == "IL&:" + w]
+ [len(pre_sub_seq)]
)
sub_span_ls = [
(sub_span[0] + sub_seq_ls_idx[i] + 1, sub_span[0] + sub_seq_ls_idx[i + 1])
for i in range(len(sub_seq_ls_idx) - 1)
]
# read sub-trees
res[w] = []
for s_sub_span in sub_span_ls:
sub_seq = seq[s_sub_span[0] : s_sub_span[1]]
res[w] += [
seq_to_tree(
sub_full_tree,
sub_seq,
idx_rev_map,
span_dict,
start_id=start_id + s_sub_span[0],
)[0]
]
idx = sub_span[1]
# failure case??? TODO: raise error
else:
idx += 1
return (res, well_formed)
# returns empty tree if ta and tb are the same tree
def compare_tree(ta, tb):
res = {}
# internal node
if is_int(ta) or is_int_list(ta):
if is_int_list(ta):
ta = ta[0]
tb = tb[0]
for a in ta:
if a in tb:
comp = compare_tree(ta[a], tb[a])
if len(comp) > 0:
res[a] = comp
else:
res[a] = (ta[a], "")
for b in tb:
if b not in ta:
res[b] = ("", tb[b])
elif ta != tb:
res = (ta, tb)
return res
##################
# torch Dataset
##################
# helper function to align word indices before and after applying BPE
def align_post_tok(pre_tok, post_tok, seen_toks=0):
i, j, ci, cj = [0] * 4
idx_map = [[seen_toks, seen_toks] for _ in range(len(pre_tok.split()))]
while ci < len(pre_tok) and cj < len(post_tok):
if pre_tok[ci] == post_tok[cj]:
if pre_tok[ci] == " ":
i += 1
j += 1
if i > 0:
idx_map[i - 1][1] = j - 1 + seen_toks
idx_map[i][0] = j + seen_toks
ci += 1
cj += 1
elif post_tok[cj] == " ":
j += 1
cj += 1
elif pre_tok[ci] == " ":
i += 1
if i > 0:
idx_map[i - 1][0] = j - 1 + seen_toks
idx_map[i][1] = j + seen_toks
ci += 1
else:
cj += 1
idx_map[i][-1] = j + seen_toks
return idx_map
# applies BPE to input and creates mapping of span indices before and after BPE
def tokenize_mapidx(text, tokenizer):
# re-order lines: last chat in multi-chat is first in the list
# rev_lines = [line.strip() for line in text.split('<SEP>')]
# text_lines = [rev_lines[i - 1] for i in range(len(rev_lines), 0, -1)]
text_lines = [line.strip() for line in text.split("<SEP>")]
# tokenize text and linearize tree
seen_toks = 1
idx_maps = [[] for _ in text_lines]
res_toks = ["[CLS]"]
for lid, line in enumerate(text_lines):
tok_line = tokenizer.tokenize(line)
tok_join = " ".join(tok_line)
idx_maps[-1 - lid] = align_post_tok(line, tok_join, seen_toks)
res_toks += tok_line[:] + ["[SEP]"]
seen_toks += len(tok_line) + 1
return (" ".join(res_toks), idx_maps)
# takes raw text and tree, returns BPE-ed text and linearized tree
def tokenize_linearize(text, tree, tokenizer, full_tree, word_noise=0.0):
tok_text, idx_maps = tokenize_mapidx(text, tokenizer)
tokenized = " ".join(
[
"[UNK]" if w not in ["[CLS]", "[SEP]"] and random.random() < word_noise else w
for w in tok_text.split()
]
)
lin_tree = tree_to_seq(full_tree, tree, idx_maps)
return (tokenized, lin_tree)
# torch Dataset for the CAIP format, applies BPE and linearizes trees on-the-fly
class CAIPDataset(Dataset):
"""
CAIP: CraftAssist Instruction Parsing
"""
def __init__(
self,
tokenizer,
args,
prefix="train",
dtype="templated",
sampling=False,
word_noise=0.0,
full_tree_voc=None,
):
assert isdir(args.data_dir)
self.tokenizer = tokenizer
self.tree_to_text = args.tree_to_text
# We load the (input, tree) pairs for all data types and
# initialize the hard examples buffer
self.data = {}
self.sampling = sampling
self.word_noise = word_noise
dtype_samples = json.loads(args.dtype_samples)
self.dtype = dtype
self.dtypes = [t for t, p in dtype_samples]
self.sample_probas = np.array([p for t, p in dtype_samples])
self.sample_probas /= self.sample_probas.sum()
if prefix == "train":
for k in self.dtypes:
fname = pjoin(args.data_dir, prefix, k + ".txt")
assert isfile(fname)
print("loading {}".format(fname))
self.data[k] = process_txt_data(fname)
self.hard_buffer_size = 1024
self.hard_buffer_counter = 0
else:
fname = pjoin(args.data_dir, prefix, dtype + ".txt")
if isfile(fname):
print("loading {}".format(fname))
self.data[dtype] = process_txt_data(fname)
else:
print("could not find dataset {}".format(fname))
self.data[dtype] = []
# load meta-tree and tree vocabulary
if full_tree_voc is None:
print("making tree")
ftr, tr_i2w = make_full_tree(
[
(self.data["humanbot"], 3e5),
(self.data["prompts"], 1e5),
(self.data["templated"][:100000], 1),
]
)
self.full_tree = ftr
else:
full_tree, tr_i2w = full_tree_voc
self.full_tree = full_tree
spec_tokens = ["[PAD]", "unused", "[UNK]", "[CLS]", "[SEP]", "[MASK]", "<S>", "</S>"]
self.tree_voc = spec_tokens[:] + tr_i2w
self.tree_idxs = dict([(w, i) for i, w in enumerate(self.tree_voc)])
self.dataset_length = max([len(v) for v in self.data.values()])
if args.examples_per_epoch > 0:
self.dataset_length = min(self.dataset_length, args.examples_per_epoch)
def _contains_span_indices(self, token_idx_list: list):
return token_idx_list[1] >= 0 and token_idx_list[2] >= 0
def __len__(self):
return self.dataset_length
def __getitem__(self, idx):
# sample data type and get example
if self.sampling:
dtype = np.random.choice(self.dtypes, p=self.sample_probas)
if len(self.data[dtype]) == 0:
dtype = self.dtype
else:
dtype = self.dtype
try:
t = self.data[dtype][idx % len(self.data[dtype])]
p_text, p_tree = t
except ValueError as e:
print(e)
text, tree = tokenize_linearize(
p_text, p_tree, self.tokenizer, self.full_tree, self.word_noise
)
text_idx_ls = [self.tokenizer._convert_token_to_id(w) for w in text.split()]
tree_idx_ls = [
[self.tree_idxs[w], bi, ei, text_span_start, text_span_end]
for w, bi, ei, text_span_start, text_span_end in [("<S>", -1, -1, -1, -1)]
+ tree
+ [("</S>", -1, -1, -1, -1)]
]
if self.tree_to_text:
stripped_tree_tokens = []
for w, bi, ei in tree:
tree_node = w.lower()
tree_node_processed = re.sub("[^0-9a-zA-Z]+", " ", tree_node)
tree_tokens = tree_node_processed.split(" ")
stripped_tree_tokens += [x for x in tree_tokens if x != ""]
extended_tree = ["[CLS]"] + stripped_tree_tokens + ["[SEP]"]
tree_idx_ls = [self.tokenizer._convert_token_to_id(w) for w in extended_tree]
return (text_idx_ls, tree_idx_ls, (text, p_text, p_tree))
def add_hard_example(self, exple):
if self.hard_buffer_counter < self.hard_buffer_size:
self.data["hard"] += [exple]
else:
self.data["hard"][self.hard_buffer_counter % self.hard_buffer_size] = exple
self.hard_buffer_counter += 1
# applies padding and makes batch tensors
def caip_collate(batch, tokenizer, tree_to_text=False):
# keep track of examples
pre_examples = [(p_text, p_tree) for x, y, (_, p_text, p_tree) in batch]
# input: text
batch_x_ls = [x for x, y, _ in batch]
x_len = max([len(x) for x in batch_x_ls])
x_mask_ls = [[1] * len(x) + [0] * (x_len - len(x)) for x in batch_x_ls]
batch_x_pad_ls = [x + [tokenizer.pad_token_id] * (x_len - len(x)) for x in batch_x_ls]
# output: linearized trees
batch_y_ls = [y for x, y, _ in batch]
y_len = max([len(y) for y in batch_y_ls])
y_mask_ls = [[1] * len(y) + [0] * (y_len - len(y)) for y in batch_y_ls]
if tree_to_text:
batch_y_pad_ls = [
y + [tokenizer.pad_token_id] * (y_len - len(y)) for y in batch_y_ls
] # 0 as padding idx
else:
batch_y_pad_ls = [
y + [[0, -1, -1, -1, -1]] * (y_len - len(y)) for y in batch_y_ls
] # 0 as padding idx
# tensorize
x = torch.tensor(batch_x_pad_ls)
x_mask = torch.tensor(x_mask_ls)
y = torch.tensor(batch_y_pad_ls)
y_mask = torch.tensor(y_mask_ls)
return (x, x_mask, y, y_mask, pre_examples)
| craftassist-master | python/base_agent/ttad/ttad_transformer_model/utils_caip.py |
import argparse
import os
import random
import math
from typing import *
def partition_dataset(k: int, data_path: str, output_dir: str):
"""
Split dataset into k partitions.
"""
# Read in annotated dataset
full_dataset = open(data_path + "annotated_data_text_spans.txt").readlines()
print("Length of dataset: {} lines".format(len(full_dataset)))
# shuffle
random.shuffle(full_dataset)
chunk_size = int(math.ceil(len(full_dataset) / float(k)))
print("k is {}".format(k))
print("Chunk size: {}".format(chunk_size))
start_idx = 0
# Split into k chunks
for i in range(k):
end_idx = start_idx + chunk_size
chunk_i = full_dataset[start_idx : min(end_idx, len(full_dataset))]
print("Length of chunk {}: {}".format(i, len(chunk_i)))
partition_path = output_dir + "chunk_{}/".format(i)
if not os.path.isdir(partition_path):
os.mkdir(partition_path)
with open(partition_path + "annotated.txt", "w") as fd:
for line in chunk_i:
fd.write(line)
start_idx += chunk_size
def create_train_valid_split(chunk_index: int, k: int, data_dir: str, output_dir: str):
"""Create partitions for k fold Cross Validation
Given a chunk index for the valid set, create train and valid split from k chunks of the dataset.
Chunk index is a an index in the range 0 to k.
"""
# Read from other chunks and write txt file to train/ dir
train_dataset: List[Dict] = []
valid_dataset: List[Dict] = []
for i in range(k):
# Use this as the validation set
if i == chunk_index:
valid_dataset += open(data_dir + "chunk_{}/annotated.txt".format(i)).readlines()
else:
train_dataset += open(data_dir + "chunk_{}/annotated.txt".format(i)).readlines()
# Write to train and valid directories
directories: List[str] = ["/", "train/", "valid/"]
for d in directories:
if not os.path.isdir(output_dir + d):
os.mkdir(output_dir + d)
print(
"Writing {} entries to {}".format(len(train_dataset), output_dir + "train/annotated.txt")
)
with open(output_dir + "train/annotated.txt", "w") as fd:
for line in train_dataset:
fd.write(line)
print(
"Writing {} entries to {}".format(len(valid_dataset), output_dir + "valid/annotated.txt")
)
with open(output_dir + "valid/annotated.txt", "w") as fd:
for line in valid_dataset:
fd.write(line)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--data_dir",
default="/checkpoint/rebeccaqian/datasets/06_24/",
type=str,
help="Contains the full dataset to partition",
)
parser.add_argument(
"--output_dir",
default="/checkpoint/rebeccaqian/datasets/06_24/",
type=str,
help="Directory to write data partitions for CV runs",
)
parser.add_argument(
"-k", default=10, type=int, help="Number of partitions in leave-k-out-cross-validation."
)
args = parser.parse_args()
partition_dataset(args.k, args.data_dir, args.output_dir)
for valid_partition_idx in range(args.k):
chunk_path = args.output_dir + "run_{}/".format(valid_partition_idx)
if not os.path.isdir(chunk_path):
os.mkdir(chunk_path)
output_dir = chunk_path
create_train_valid_split(valid_partition_idx, args.k, args.data_dir, output_dir)
if __name__ == "__main__":
main()
| craftassist-master | python/base_agent/ttad/ttad_transformer_model/gen_cross_valid_chunks.py |
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam, Adagrad
from transformers.modeling_bert import BertModel, BertOnlyMLMHead
from utils_caip import *
# --------------------------
# Transformer-based decoder module for sequence ans span prediction, computes the loss
# --------------------------
def my_xavier_init(m, gain=1):
for p in m.parameters():
if p.dim() > 1:
nn.init.xavier_uniform_(p, gain)
else:
nn.init.constant_(p, 0)
class HighwayLayer(torch.nn.Module):
def __init__(self, dim):
super(HighwayLayer, self).__init__()
self.gate_proj = nn.Linear(dim, dim, bias=True)
self.nlin_proj = nn.Linear(dim, dim, bias=True)
my_xavier_init(self.nlin_proj)
my_xavier_init(self.gate_proj)
nn.init.constant_(self.gate_proj.bias, -1)
def forward(self, x):
gate = torch.sigmoid(self.gate_proj(x))
nlin = torch.tanh(self.nlin_proj(x))
res = gate * nlin + (1 - gate) * x
return res
# single module to predict the output sequence and compute the
# loss if the target sequence is provided for convenience
class DecoderWithLoss(nn.Module):
def __init__(self, config, args, tokenizer):
super(DecoderWithLoss, self).__init__()
# model components
print("initializing decoder with params {}".format(args))
self.bert = BertModel(config)
self.lm_head = BertOnlyMLMHead(config)
self.span_b_proj = nn.ModuleList([HighwayLayer(768) for _ in range(args.num_highway)])
self.span_e_proj = nn.ModuleList([HighwayLayer(768) for _ in range(args.num_highway)])
# TODO: check dimensions for span head
# predict text span beginning and end
self.text_span_start_head = nn.Linear(768, 768)
self.text_span_end_head = nn.Linear(768, 768)
# loss functions
if args.node_label_smoothing > 0:
self.lm_ce_loss = LabelSmoothingLoss(
args.node_label_smoothing, config.vocab_size, ignore_index=tokenizer.pad_token_id
)
else:
self.lm_ce_loss = torch.nn.CrossEntropyLoss(
ignore_index=tokenizer.pad_token_id, reduction="none"
)
self.span_ce_loss = torch.nn.CrossEntropyLoss(ignore_index=-1, reduction="none")
self.span_loss_lb = args.lambda_span_loss
self.text_span_loss = torch.nn.CrossEntropyLoss(ignore_index=-1, reduction="none")
self.tree_to_text = args.tree_to_text
# without loss, use at prediction time
# TODO: add previously computed y_rep
# y only has the node indices (not the spans)
# Used in eval only
def step(self, y, y_mask, x_reps, x_mask):
y_rep = self.bert(
input_ids=y,
attention_mask=y_mask,
encoder_hidden_states=x_reps,
encoder_attention_mask=x_mask,
)[0]
y_mask_target = y_mask
lm_scores = self.lm_head(y_rep)
y_span_pre_b = y_rep
for hw in self.span_b_proj:
y_span_pre_b = hw(y_span_pre_b)
span_b_scores = (x_reps[:, None, :, :] * y_span_pre_b[:, :, None, :]).sum(dim=-1)
span_b_scores = (
span_b_scores + (1 - y_mask_target.type_as(span_b_scores))[:, :, None] * 1e9
)
y_span_pre_e = y_rep
for hw in self.span_e_proj:
y_span_pre_e = hw(y_span_pre_e)
span_e_scores = (x_reps[:, None, :, :] * y_span_pre_e[:, :, None, :]).sum(dim=-1)
span_e_scores = (
span_e_scores + (1 - y_mask_target.type_as(span_e_scores))[:, :, None] * 1e9
)
# text span prediction
# detach head
text_span_start_hidden_z = y_rep.detach()
text_span_end_hidden_z = y_rep.detach()
# get predicted values
text_span_start_out = self.text_span_start_head(text_span_start_hidden_z)
text_span_start_scores = (x_reps[:, None, :, :] * text_span_start_out[:, :, None, :]).sum(
dim=-1
)
text_span_start_scores = (
text_span_start_scores
+ (1 - y_mask_target.type_as(text_span_start_scores))[:, :, None] * 1e9
)
# text span end prediction
text_span_end_out = self.text_span_end_head(text_span_end_hidden_z)
text_span_end_scores = (x_reps[:, None, :, :] * text_span_end_out[:, :, None, :]).sum(
dim=-1
)
text_span_end_scores = (
text_span_end_scores
+ (1 - y_mask_target.type_as(text_span_end_scores))[:, :, None] * 1e9
)
res = {
"lm_scores": torch.log_softmax(lm_scores, dim=-1).detach(),
"span_b_scores": torch.log_softmax(span_b_scores, dim=-1).detach(),
"span_e_scores": torch.log_softmax(span_e_scores, dim=-1).detach(),
"text_span_start_scores": torch.log_softmax(text_span_start_scores, dim=-1).detach(),
"text_span_end_scores": torch.log_softmax(text_span_end_scores, dim=-1).detach(),
}
return res
def forward(self, y, y_mask, x_reps, x_mask):
if self.tree_to_text:
bert_model = self.bert(
input_ids=y,
attention_mask=y_mask,
encoder_hidden_states=x_reps,
encoder_attention_mask=x_mask,
)
y_rep = bert_model[0]
y_mask_target = y_mask.contiguous()
# language modeling
lm_scores = self.lm_head(y_rep)
lm_lin_scores = lm_scores.view(-1, lm_scores.shape[-1])
lm_lin_targets = y.contiguous().view(-1)
lm_lin_loss = self.lm_ce_loss(lm_lin_scores, lm_lin_targets)
lm_lin_mask = y_mask_target.view(-1)
lm_loss = lm_lin_loss.sum() / lm_lin_mask.sum()
res = {"lm_scores": lm_scores, "loss": lm_loss}
else:
model_out = self.bert(
input_ids=y[:, :-1, 0],
attention_mask=y_mask[:, :-1],
encoder_hidden_states=x_reps,
encoder_attention_mask=x_mask,
)
y_rep = model_out[0]
y_rep.retain_grad()
self.bert_final_layer_out = y_rep
y_mask_target = y_mask[:, 1:].contiguous()
# language modeling
lm_scores = self.lm_head(y_rep)
lm_lin_scores = lm_scores.view(-1, lm_scores.shape[-1])
lm_lin_targets = y[:, 1:, 0].contiguous().view(-1)
lm_lin_loss = self.lm_ce_loss(lm_lin_scores, lm_lin_targets)
lm_lin_mask = y_mask_target.view(-1)
lm_loss = lm_lin_loss.sum() / lm_lin_mask.sum()
# span prediction
## beginning of spans
y_span_pre_b = y_rep
for hw in self.span_b_proj:
y_span_pre_b = hw(y_span_pre_b)
span_b_scores = (x_reps[:, None, :, :] * y_span_pre_b[:, :, None, :]).sum(dim=-1)
span_b_scores = (
span_b_scores + (1 - y_mask_target.type_as(span_b_scores))[:, :, None] * 1e9
)
span_b_lin_scores = span_b_scores.view(-1, x_reps.shape[1])
span_b_lin_targets = y[:, 1:, 1].contiguous().view(-1)
span_b_lin_loss = self.span_ce_loss(span_b_lin_scores, span_b_lin_targets)
## end of spans
y_span_pre_e = y_rep
for hw in self.span_e_proj:
y_span_pre_e = hw(y_span_pre_e)
span_e_scores = (x_reps[:, None, :, :] * y_span_pre_e[:, :, None, :]).sum(dim=-1)
span_e_scores = (
span_e_scores + (1 - y_mask_target.type_as(span_e_scores))[:, :, None] * 1e9
)
span_e_lin_scores = span_e_scores.view(-1, span_e_scores.shape[-1])
span_e_lin_targets = y[:, 1:, 2].contiguous().view(-1)
span_e_lin_loss = self.span_ce_loss(span_e_lin_scores, span_e_lin_targets)
## joint span prediction
# TODO: predict full spans, enforce order
# combine
span_lin_loss = span_b_lin_loss + span_e_lin_loss
span_loss = span_lin_loss.sum() / (y[:, :, 1] >= 0).sum()
tot_loss = (1 - self.span_loss_lb) * lm_loss + self.span_loss_lb * span_loss
# text span prediction
# detach head
y_rep.retain_grad()
self.text_span_start_hidden_z = y_rep.detach()
self.text_span_end_hidden_z = y_rep.detach()
self.text_span_start_hidden_z.requires_grad = True
self.text_span_end_hidden_z.requires_grad = True
self.text_span_start_hidden_z.retain_grad()
self.text_span_end_hidden_z.retain_grad()
# get predicted values
self.text_span_start_out = self.text_span_start_head(self.text_span_start_hidden_z)
text_span_start_scores = (
x_reps[:, None, :, :] * self.text_span_start_out[:, :, None, :]
).sum(dim=-1)
text_span_start_lin_scores = text_span_start_scores.view(
-1, text_span_start_scores.shape[-1]
)
text_span_start_targets = y[:, 1:, 3].contiguous().view(-1)
text_span_start_lin_loss = self.text_span_loss(
text_span_start_lin_scores, text_span_start_targets
)
text_span_start_loss = text_span_start_lin_loss.sum() / (y[:, :, 3] >= 0).sum()
# text span end prediction
text_span_end_out = self.text_span_end_head(self.text_span_end_hidden_z)
text_span_end_scores = (x_reps[:, None, :, :] * text_span_end_out[:, :, None, :]).sum(
dim=-1
)
text_span_end_lin_scores = text_span_end_scores.view(
-1, text_span_end_scores.shape[-1]
)
text_span_end_targets = y[:, 1:, 4].contiguous().view(-1)
text_span_end_lin_loss = self.text_span_loss(
text_span_end_lin_scores, text_span_end_targets
)
text_span_end_loss = text_span_end_lin_loss.sum() / (y[:, :, 4] >= 0).sum()
text_span_lin_loss = text_span_start_loss + text_span_end_loss
text_span_loss = text_span_lin_loss.sum() / (y[:, :, 3] >= 0).sum()
res = {
"lm_scores": lm_scores,
"span_b_scores": span_b_scores,
"span_e_scores": span_e_scores,
"loss": tot_loss,
# TODO: placeholder for now
"text_span_start_scores": text_span_start_scores,
"text_span_end_scores": text_span_end_scores,
"text_span_loss": text_span_loss,
}
return res
# combines DecoderWithLoss with pre-trained BERT encoder
class EncoderDecoderWithLoss(nn.Module):
def __init__(self, encoder, decoder, args):
super(EncoderDecoderWithLoss, self).__init__()
self.encoder = encoder
self.decoder = decoder
self.train_encoder = args.train_encoder
def forward(self, x, x_mask, y, y_mask, x_reps=None):
if x_reps is None:
model = self.encoder(input_ids=x, attention_mask=x_mask)
x_reps = model[0]
if not self.train_encoder:
x_reps = x_reps.detach()
outputs = self.decoder(y, y_mask, x_reps, x_mask)
return outputs
# raw text input, tree output
# DEPRECATED: use beam search
def predict_tree(txt, model, tokenizer, dataset, ban_noop=False, noop_threshold=0.0):
model_device = model.decoder.lm_head.predictions.decoder.weight.device
# prepare batch
text, idx_maps = tokenize_mapidx(txt, tokenizer)
tree = [("<S>", -1, -1)]
text_idx_ls = [dataset.tokenizer._convert_token_to_id(w) for w in text.split()]
tree_idx_ls = [[dataset.tree_idxs[w], bi, ei] for w, bi, ei in tree]
pre_batch = [(text_idx_ls, tree_idx_ls, (text, txt, {}))]
batch = caip_collate(pre_batch, tokenizer)
batch = [t.to(model_device) for t in batch[:4]]
x, x_mask, y, y_mask = batch
y = y[:, :, 0]
x_reps = model.encoder(input_ids=x, attention_mask=x_mask)[0].detach()
res = [("<S>", -1, -1)]
next_id = -1
noop_predicted = False
for i in range(100):
if i > 0:
y = torch.cat([y, torch.LongTensor([[next_id]]).to(model_device)], dim=1)
y_mask = torch.cat(
[y_mask, torch.LongTensor([1]).unsqueeze(dim=0).to(model_device)], dim=1
)
outputs = model.decoder.step(y, y_mask, x_reps, x_mask)
# next word
lm_scores = outputs["lm_scores"]
s_lm_scores, s_lm_ids = lm_scores[0, -1].sort(dim=-1, descending=True)
next_id = s_lm_ids[0].item()
if "NOOP" in dataset.tree_voc[next_id]:
if ban_noop or s_lm_scores[0].item() < noop_threshold:
next_id = s_lm_ids[1].item()
noop_predicted = True
print("---- replacing NOOP with", dataset.tree_voc[next_id])
next_w = dataset.tree_voc[next_id]
# predicted span
span_b_scores = outputs["span_b_scores"]
span_e_scores = outputs["span_e_scores"]
_, s_sb_ids = span_b_scores[0, -1].sort(dim=-1, descending=True)
_, s_se_ids = span_e_scores[0, -1].sort(dim=-1, descending=True)
b_id = s_sb_ids[0].item()
e_id = s_se_ids[0].item()
res += [(next_w, b_id, e_id)]
if next_w == "</S>":
break
# only keep span predictions for span nodes, then map back to tree
res = [(w, b, e) if w.startswith("BE:") else (w, -1, -1) for w, b, e in res]
idx_rev_map = [(0, 0)] * len(text.split())
for line_id, idx_map in enumerate(idx_maps):
for pre_id, (a, b) in enumerate(idx_map):
idx_rev_map[a] = (line_id, pre_id)
idx_rev_map[b] = (line_id, pre_id)
idx_rev_map[-1] = idx_rev_map[-2]
res_tree, _ = seq_to_tree(dataset.full_tree, res[1:-1], idx_rev_map)
return (res_tree, noop_predicted, (text, res))
# beam prediction. Only uses node prediction scores (not the span scores)
def beam_search(txt, model, tokenizer, dataset, beam_size=5, well_formed_pen=1e2):
model_device = model.decoder.lm_head.predictions.decoder.weight.device
# prepare batch
text, idx_maps = tokenize_mapidx(txt, tokenizer)
idx_rev_map = [(0, 0)] * len(text.split())
for line_id, idx_map in enumerate(idx_maps):
for pre_id, (a, b) in enumerate(idx_map):
idx_rev_map[a] = (line_id, pre_id)
idx_rev_map[b] = (line_id, pre_id)
idx_rev_map[-1] = idx_rev_map[-2]
tree = [("<S>", -1, -1, -1, -1)]
text_idx_ls = [dataset.tokenizer._convert_token_to_id(w) for w in text.split()]
tree_idx_ls = [
[dataset.tree_idxs[w], bi, ei, text_span_bi, text_span_ei]
for w, bi, ei, text_span_bi, text_span_ei in tree
]
pre_batch = [(text_idx_ls, tree_idx_ls, (text, txt, {}))]
batch = caip_collate(pre_batch, tokenizer)
batch = [t.to(model_device) for t in batch[:4]]
x, x_mask, y, y_mask = batch
x_reps = model.encoder(input_ids=x, attention_mask=x_mask)[0].detach()
x_mask = x_mask.expand(beam_size, -1)
x_reps = x_reps.expand(beam_size, -1, -1)
# start decoding
y = torch.LongTensor([[dataset.tree_idxs["<S>"]] for _ in range(beam_size)]).to(
model_device
) # B x 1
beam_scores = torch.Tensor([-1e9 for _ in range(beam_size)]).to(model_device) # B
beam_scores[0] = 0
beam_seqs = [[("<S>", -1, -1, -1, -1)] for _ in range(beam_size)]
finished = [False for _ in range(beam_size)]
pad_scores = torch.Tensor([-1e9] * len(dataset.tree_voc)).to(model_device)
pad_scores[dataset.tree_idxs["[PAD]"]] = 0
for i in range(100):
outputs = model.decoder.step(y, y_mask, x_reps, x_mask)
# next word
lm_scores = outputs["lm_scores"][:, -1, :] # B x V
for i, fshed in enumerate(finished):
if fshed:
lm_scores[i] = pad_scores
beam_lm_scores = lm_scores + beam_scores[:, None] # B x V
beam_lm_lin = beam_lm_scores.view(-1)
s_scores, s_ids = beam_lm_lin.sort(dim=-1, descending=True)
s_beam_ids = s_ids // beam_lm_scores.shape[-1]
s_word_ids = s_ids % beam_lm_scores.shape[-1]
# re-order and add next token
beam_scores = s_scores[:beam_size]
n_beam_ids = s_beam_ids[:beam_size]
n_word_ids = s_word_ids[:beam_size]
n_words = [dataset.tree_voc[nw_id.item()] for nw_id in n_word_ids]
y = torch.cat([y[n_beam_ids], n_word_ids[:, None]], dim=1)
# find out which of the beams are finished
pre_finished = [finished[b_id.item()] for b_id in n_beam_ids]
new_finished = [w_id.item() == dataset.tree_idxs["</S>"] for w_id in n_word_ids]
finished = [p or n for p, n in zip(pre_finished, new_finished)]
n_mask = 1 - torch.Tensor(finished).type_as(y_mask)
y_mask = torch.cat([y_mask[n_beam_ids], n_mask[:, None]], dim=1)
# predicted span
span_b_scores = outputs["span_b_scores"][:, -1, :][n_beam_ids] # B x T
span_e_scores = outputs["span_e_scores"][:, -1, :][n_beam_ids] # B x T
span_be_scores = span_b_scores[:, :, None] + span_e_scores[:, None, :]
invalid_scores = torch.tril(torch.ones(span_be_scores.shape), diagonal=-1) * -1e9
span_be_scores += invalid_scores.type_as(span_be_scores)
span_be_lin = span_be_scores.view(span_be_scores.shape[0], -1)
_, s_sbe_ids = span_be_lin.sort(dim=-1, descending=True)
s_sb_ids = s_sbe_ids[:, 0] // span_b_scores.shape[-1]
s_se_ids = s_sbe_ids[:, 0] % span_b_scores.shape[-1]
beam_b_ids = [bb_id.item() for bb_id in s_sb_ids]
beam_e_ids = [be_id.item() for be_id in s_se_ids]
# predict text spans
text_span_start_scores = outputs["text_span_start_scores"][:, -1, :][n_beam_ids] # B x T
text_span_end_scores = outputs["text_span_end_scores"][:, -1, :][n_beam_ids] # B x T
text_span_scores = text_span_start_scores[:, :, None] + text_span_end_scores[:, None, :]
invalid_text_span_scores = (
torch.tril(torch.ones(text_span_scores.shape), diagonal=-1) * -1e9
)
text_span_scores += invalid_text_span_scores.type_as(text_span_scores)
text_span_lin_scores = text_span_scores.view(text_span_scores.shape[0], -1)
_, text_span_ids = text_span_lin_scores.sort(dim=-1, descending=True)
text_span_start_ids = text_span_ids[:, 0] // text_span_start_scores.shape[-1]
text_span_end_ids = text_span_ids[:, 0] % text_span_start_scores.shape[-1]
text_span_beam_start_ids = [bb_id.item() for bb_id in text_span_start_ids]
text_span_beam_end_ids = [be_id.item() for be_id in text_span_end_ids]
# update beam_seq
beam_seqs = [
beam_seqs[n_beam_ids[i].item()]
+ [
(
n_words[i],
beam_b_ids[i],
beam_e_ids[i],
text_span_beam_start_ids[i],
text_span_beam_end_ids[i],
)
]
for i in range(beam_size)
]
# penalize poorly formed trees
for i, seq in enumerate(beam_seqs):
if seq[-1][0] == "</S>":
_, well_formed = select_spans(seq)
if not well_formed:
beam_scores[i] -= well_formed_pen
# check whether all beams have reached EOS
if all(finished):
break
# only keep span predictions for span nodes, then map back to tree
beam_seqs = [
[
(w, b, e, -1, -1)
if w.startswith("BE:")
else (w, -1, -1, text_span_start, text_span_end)
for w, b, e, text_span_start, text_span_end in res
if w != "[PAD]"
]
for res in beam_seqs
]
beam_seqs = [
[
(w, -1, -1, text_span_start, text_span_end)
if w.startswith("TBE:")
else (w, b, e, -1, -1)
for w, b, e, text_span_start, text_span_end in res
if w != "[PAD]"
]
for res in beam_seqs
]
# delinearize predicted sequences into tree
beam_trees = [seq_to_tree(dataset.full_tree, res[1:-1], idx_rev_map)[0] for res in beam_seqs]
pre_res = [
(tree, score.item(), seq) for tree, score, seq in zip(beam_trees, beam_scores, beam_seqs)
]
# sort one last time to have well-formed trees on top
res = sorted(pre_res, key=lambda x: x[1], reverse=True)
return res
# util function for validation and selecting hard examples
def compute_accuracy(outputs, y):
if len(y.shape) == 2:
lm_targets = y
else:
lm_targets = y[:, 1:, 0]
lm_preds = outputs["lm_scores"].max(dim=-1)[1]
lm_acc = ((lm_preds == lm_targets) * (lm_targets > 6)).sum(dim=1) == (lm_targets > 6).sum(
dim=1
)
if "span_b_scores" in outputs:
sb_targets = y[:, 1:, 1]
sb_preds = outputs["span_b_scores"].max(dim=-1)[1]
sb_acc = ((sb_preds == sb_targets) * (sb_targets >= 0)).sum(dim=1) == (
sb_targets >= 0
).sum(dim=1)
se_targets = y[:, 1:, 2]
se_preds = outputs["span_e_scores"].max(dim=-1)[1]
se_acc = ((se_preds == se_targets) * (se_targets >= 0)).sum(dim=1) == (
se_targets >= 0
).sum(dim=1)
sp_acc = sb_acc * se_acc
full_acc = lm_acc * sp_acc
if "text_span_start_scores" in outputs:
text_span_b_targets = y[:, 1:, 3]
text_span_e_targets = y[:, 1:, 4]
text_span_b_pred = outputs["text_span_start_scores"].max(dim=-1)[1]
text_span_e_pred = outputs["text_span_end_scores"].max(dim=-1)[1]
text_span_b_acc = (
(text_span_b_pred == text_span_b_targets) * (text_span_b_targets >= 0)
).sum(dim=1) == (text_span_b_targets >= 0).sum(dim=1)
text_span_e_acc = (
(text_span_e_pred == text_span_e_targets) * (text_span_e_targets >= 0)
).sum(dim=1) == (text_span_e_targets >= 0).sum(dim=1)
text_span_acc = text_span_b_acc * text_span_e_acc
return (lm_acc, sp_acc, text_span_acc, full_acc)
else:
return (lm_acc, sp_acc, full_acc)
else:
return lm_acc
# --------------------------
# Custom wrapper for Adam optimizer,
# handles lr warmup and smaller lr for encoder fine-tuning
# --------------------------
class OptimWarmupEncoderDecoder(object):
def __init__(self, model, args):
self.encoder = model.encoder
self.decoder = model.decoder
self.lr = {
"encoder": args.encoder_learning_rate,
"decoder": args.decoder_learning_rate,
"text_span_decoder": args.decoder_learning_rate,
}
self.warmup_steps = {
"encoder": args.encoder_warmup_steps,
"decoder": args.decoder_warmup_steps,
"text_span_decoder": args.decoder_warmup_steps,
}
if args.optimizer == "adam":
self.optimizers = {
"encoder": Adam(model.encoder.parameters(), lr=self.lr["encoder"]),
"decoder": Adam(model.decoder.parameters(), lr=self.lr["decoder"]),
"text_span_decoder": Adam(
model.decoder.parameters(), lr=self.lr["text_span_decoder"]
),
}
elif args.optimizer == "adagrad":
self.optimizers = {
"encoder": Adagrad(model.encoder.parameters(), lr=self.lr["encoder"]),
"decoder": Adagrad(model.decoder.parameters(), lr=self.lr["decoder"]),
"text_span_decoder": Adam(
model.decoder.parameters(), lr=self.lr["text_span_decoder"]
),
}
else:
raise NotImplementedError
self._step = 0
def _update_rate(self, stack):
return self.lr[stack] * min(
(self._step / self.warmup_steps[stack]), (self._step / self.warmup_steps[stack]) ** 0.5
)
def zero_grad(self):
self.optimizer_decoder.zero_grad()
self.optimizer_encoder.zero_grad()
def step(self):
self._step += 1
for stack, optimizer in self.optimizers.items():
new_rate = self._update_rate(stack)
for param_group in optimizer.param_groups:
param_group["lr"] = new_rate
optimizer.step()
# --------------------------
# Label smoothing loss
# --------------------------
class LabelSmoothingLoss(nn.Module):
"""
With label smoothing,
KL-divergence between q_{smoothed ground truth prob.}(w)
and p_{prob. computed by model}(w) is minimized.
"""
def __init__(self, label_smoothing, tgt_vocab_size, ignore_index=-1):
assert 0.0 <= label_smoothing <= 1.0
super(LabelSmoothingLoss, self).__init__()
self.ignore_index = ignore_index
self.voc_size = tgt_vocab_size
if ignore_index >= 0:
self.smoothing = label_smoothing / (tgt_vocab_size - 2)
else:
self.smoothing = label_smoothing / (tgt_vocab_size - 1)
self.confidence = 1.0 - label_smoothing
def forward(self, output, target):
"""
output (FloatTensor): batch_size x n_classes
target (LongTensor): batch_size
"""
with torch.no_grad():
s_target = torch.zeros_like(output)
s_target.fill_(self.smoothing)
if self.ignore_index >= 0:
s_target[:, self.ignore_index] = 0
t_cap = target.masked_fill(target == self.ignore_index, 0)
s_target.scatter_(1, t_cap.unsqueeze(1), self.confidence)
kl_div = F.kl_div(output.log_softmax(dim=-1), s_target, reduction="none")
kl_mask = (target != self.ignore_index).type_as(kl_div).unsqueeze(1)
return (kl_div * kl_mask).sum(dim=-1)
| craftassist-master | python/base_agent/ttad/ttad_transformer_model/utils_parsing.py |
import json
import math
import pickle
import torch
from transformers import AutoModel, AutoTokenizer, BertConfig
from utils_parsing import *
from utils_caip import *
from train_model import *
class TTADBertModel(object):
def __init__(self, model_dir, data_dir, model_name="caip_test_model"):
model_name = model_dir + model_name
args = pickle.load(open(model_name + "_args.pk", "rb"))
args.data_dir = data_dir
self.tokenizer = AutoTokenizer.from_pretrained(args.pretrained_encoder_name)
full_tree, tree_i2w = json.load(open(model_name + "_tree.json"))
self.dataset = CAIPDataset(
self.tokenizer, args, prefix="", full_tree_voc=(full_tree, tree_i2w)
)
enc_model = AutoModel.from_pretrained(args.pretrained_encoder_name)
bert_config = BertConfig.from_pretrained("bert-base-uncased")
bert_config.is_decoder = True
bert_config.vocab_size = len(tree_i2w) + 8
bert_config.num_hidden_layers = args.num_decoder_layers
dec_with_loss = DecoderWithLoss(bert_config, args, self.tokenizer)
self.encoder_decoder = EncoderDecoderWithLoss(enc_model, dec_with_loss, args)
map_location = None if torch.cuda.is_available() else torch.device("cpu")
self.encoder_decoder.load_state_dict(
torch.load(model_name + ".pth", map_location=map_location), strict=False
)
self.encoder_decoder = (
self.encoder_decoder.cuda()
if torch.cuda.is_available()
else self.encoder_decoder.cpu()
)
self.encoder_decoder.eval()
def parse(self, chat, noop_thres=0.95, beam_size=5, well_formed_pen=1e2):
btr = beam_search(
chat, self.encoder_decoder, self.tokenizer, self.dataset, beam_size, well_formed_pen
)
if btr[0][0].get("dialogue_type", "NONE") == "NOOP" and math.exp(btr[0][1]) < noop_thres:
tree = btr[1][0]
else:
tree = btr[0][0]
return tree
| craftassist-master | python/base_agent/ttad/ttad_transformer_model/query_model.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import os
from emnlp_model import *
from typing import Sequence, Dict
THIS_DIR = os.path.dirname(__file__)
class ActionDictBuilder(object):
def __init__(
self,
model_path=THIS_DIR + "/../../models/semantic_parser/ttad/ttad.pth",
embeddings_path=THIS_DIR + "/../../models/semantic_parser/ttad/ttad_ft_embeds.pth",
action_tree_path=THIS_DIR + "/../../models/semantic_parser/ttad/dialogue_grammar.json",
cuda=False,
):
model, loss, w2i, args = load_model(
model_path=model_path,
embeddings_path=embeddings_path,
action_tree_path=action_tree_path,
use_cuda=cuda,
)
self.model = model
self.loss = loss
self.w2i = w2i
self.args = args
def parse(self, chat_list: Sequence[str]):
action_dict = predict_tree(self.model, chat_list, self.w2i, self.args)
self._remove_not_implemented(action_dict)
return action_dict
def _remove_not_implemented(self, d: Dict):
c = d.copy()
for k, v in c.items():
if v == "NOT_IMPLEMENTED":
del d[k]
elif type(v) == dict:
self._remove_not_implemented(v)
| craftassist-master | python/base_agent/ttad/ttad_model/ttad_model_wrapper.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import argparse
import logging
import logging.handlers
import os
import pickle
TTAD_MODEL_DIR = os.path.dirname(os.path.realpath(__file__))
TTAD_DATA_DIR = os.path.join(TTAD_MODEL_DIR, "../data/ttad_model/")
from time import time
import torch.optim as optim
from emnlp_model import *
from ttad_model_wrapper import *
def main():
parser = argparse.ArgumentParser(description="Train text to action dictionary model")
parser.add_argument("-cuda", "--cuda", action="store_true", help="use GPU to train")
parser.add_argument(
"-mn",
"--model_name",
default=TTAD_DATA_DIR + "models/tree_model",
type=str,
metavar="S",
help="torch formatted model file to save",
)
parser.add_argument(
"-rp",
"--rephrase_proba",
default=0.4,
type=float,
metavar="D",
help="proportion of rephrased training data 0 <= r <= 1",
)
# data sampling arguments
parser.add_argument(
"-rsm",
"--resample_mode",
default="action-type",
type=str,
metavar="S",
help="re-sample train and valid data to match [none|action-type|tree-internal|tree-full] distribution",
)
parser.add_argument(
"-rst",
"--resample_type",
default="humanbot",
type=str,
metavar="S",
help="re-sample train and valid data to match [rephrased|prompts|humanbot|templated] distribution",
)
parser.add_argument(
"-hbp",
"--hard_buffer_proba",
default=0.3,
type=float,
metavar="D",
help="proportion of training batch examples from hard examples buffer 0 <= r <= 1",
)
parser.add_argument(
"-hbs",
"--hard_buffer_size",
default=2048,
type=int,
metavar="N",
help="proportion of training batch examples from hard examples buffer 0 <= r <= 1",
)
# file locations
parser.add_argument(
"-toe",
"--train_on_everything",
action="store_true",
help="train on validation and test set too",
)
parser.add_argument(
"-df",
"--data_file",
default=TTAD_DATA_DIR + "dialogue_data.json",
type=str,
metavar="S",
help="location of json file with all taining, valid and test data",
)
parser.add_argument(
"-atf",
"--action_tree_file",
default=TTAD_DATA_DIR + "dialogue_grammar.json",
type=str,
metavar="S",
help="action tree that covers all of the data (including OtherAction)",
)
parser.add_argument(
"-ftmf",
"--ft_model_file",
default=TTAD_DATA_DIR + "minecraft_newdct_ft_embeds.pth",
type=str,
metavar="S",
help="pre-trained pre-computed subword-aware fasttext embeddings and vocabulary",
)
# model arguments
parser.add_argument("-cn", "--collapse_nodes", action="store_true", help="parameter sharing")
parser.add_argument(
"-led",
"--learn_embed_dim",
default=0,
type=int,
metavar="N",
help="concatenate learned embeddings to FastText pretained of dimension",
)
parser.add_argument(
"-learn_embeds",
"--learn_embeds",
action="store_true",
help="learn word embeddings from scratch",
)
parser.add_argument(
"-rec",
"--recursion",
default="sentence-rec",
type=str,
help="type of recursion for the prediction model in"
"[none|top-down|dfs-intern|dfs-all|sentence-rec]",
)
parser.add_argument(
"-md", "--model_dim", default=256, type=int, metavar="N", help="model dimension"
)
parser.add_argument(
"-sh",
"--sent_heads",
default=4,
type=int,
metavar="N",
help="number of sentence attention heads",
)
parser.add_argument(
"-th",
"--tree_heads",
default=4,
type=int,
metavar="N",
help="number of tree context attention heads",
)
parser.add_argument(
"-sec",
"--sentence_encoder",
default="bigru",
type=str,
help="type of sentence encoder [convolution|bigru]",
)
parser.add_argument(
"-scl",
"--sent_conv_layers",
default=3,
type=int,
metavar="N",
help="convolutional layers for sentence encoder",
)
parser.add_argument(
"-scw",
"--sent_conv_window",
default=1,
type=int,
metavar="N",
help="window size (2k+1) for sentence encoder convolutions",
)
parser.add_argument(
"-sgl",
"--sent_gru_layers",
default=2,
type=int,
metavar="N",
help="BiGRU layers for sentence encoder",
)
# optimization arguments
parser.add_argument(
"-bs", "--batch_size", default=128, type=int, metavar="N", help="batch size"
)
parser.add_argument(
"-lr",
"--learning_rate",
default=5e-3,
type=float,
metavar="D",
help="learning rate factor",
)
parser.add_argument(
"-le", "--learning_epochs", default=10, type=int, metavar="N", help="number of epochs"
)
parser.add_argument(
"-nbpe",
"--batches_per_epoch",
default=1000,
type=int,
metavar="N",
help="number of batches per epoch",
)
parser.add_argument(
"-ls",
"--label_smoothing",
default=0.0,
type=float,
metavar="D",
help="label smoothing regularizer",
)
parser.add_argument(
"-do", "--dropout", default=0.3, type=float, metavar="D", help="dropout value in [0,1]"
)
parser.add_argument(
"-sn",
"--sentence_noise",
default=0.0,
type=float,
metavar="D",
help="train time probability of masking a word in [0,1]",
)
# continue training
parser.add_argument("-lm", "--load_model", action="store_true")
parser.add_argument(
"-lmf",
"--load_model_file",
default="",
type=str,
metavar="S",
help="torch formatted model file to load",
)
args = parser.parse_args()
# TODO: add print_freq to arguments
args.print_freq = 100
# short-hand for no pre-trained word embeddings
if args.learn_embed_dim < 0:
args.learn_embed_dim *= -1
args.learn_embeds = True
pickle.dump(args, open("%s.args.pk" % (args.model_name,), "wb"))
### set up logging
l_handler = logging.handlers.WatchedFileHandler(
os.environ.get("LOGFILE", "logs/%s.log" % args.model_name.split("/")[-1])
)
l_format = logging.Formatter(fmt="%(asctime)s - %(message)s", datefmt="%d-%b-%y %H:%M:%S")
l_handler.setFormatter(l_format)
l_root = logging.getLogger()
l_root.setLevel(os.environ.get("LOGLEVEL", "INFO"))
l_root.addHandler(l_handler)
### Training data loading and training code
st_time = time()
# load make data
print("starting %.1f" % (time() - st_time,))
a_tree_pred, a_tree_loss, w2i = make_model(
args, args.ft_model_file, args.action_tree_file, args.cuda
)
optimizer = optim.Adagrad(a_tree_pred.parameters(), lr=args.learning_rate)
print("made model %.1f" % (time() - st_time,))
# load data
data_loader = DataLoader(args)
print("loaded training data: %.1f" % (time() - st_time,))
if args.load_model_file:
print("loading model to test....")
a_tree_pred.load_state_dict(torch.load(args.load_model_file))
a_tree_pred.eval()
# get numbers for validation set
for valid_type in data_loader.data["valid"]:
# accuracy
print(valid_type)
acc1 = compute_accuracy(a_tree_pred, data_loader.data["valid"][valid_type], w2i, args)
# # accuracy per action type
# acc2 = compute_accuracy_per_action_type(
# a_tree_pred, data_loader.data["valid"][valid_type], w2i, args
# )
# # precision, recall, f1
# precision_recall_stats = compute_precision_recall(
# a_tree_pred, data_loader.data["valid"][valid_type][:10], w2i, args
# )
print("----- VALID_FINAL_ACCURACIES %s %s" % (valid_type, str(acc1)))
# pprint(str(acc2))
# pprint(str(precision_recall_stats))
# print("-------" * 10)
print("----- TEST")
for test_type in data_loader.data["test"]:
# for internal only accuracy -> give : only_internal=True
# get accuracy
acc1 = compute_accuracy(a_tree_pred, data_loader.data["test"][test_type], w2i, args)
# # get accuracy per action type
# acc2 = compute_accuracy_per_action_type(
# a_tree_pred, data_loader.data["test"][test_type], w2i, args
# )
# # precision, recall, f1 stats
# precision_recall_stats = compute_precision_recall(
# a_tree_pred, data_loader.data["test"][test_type], w2i, args
# )
print("----- TEST_FINAL_ACCURACIES %s %s" % (test_type, str(acc1)))
# pprint(str(acc2))
# pprint(str(precision_recall_stats))
# print("------" * 10)
else:
# start training
for e in range(args.learning_epochs):
model_file_name = "%s_%d.pth" % (args.model_name, e)
# train on current slice
a_tree_pred.train()
print("----- TRAIN GENERATED", e)
logging.info("----- TRAIN GENERATED %d" % (e,))
run_epoch(
data_loader,
a_tree_pred,
a_tree_loss,
w2i,
args,
mode="train",
data_type="",
optimizer=optimizer,
)
# DEBUG
torch.save(a_tree_pred.to("cpu").state_dict(), model_file_name)
a_tree_pred.to("cuda:0")
a_tree_pred.eval()
# hard_buf_acc = compute_accuracy(a_tree_pred, data_loader.hard_buffer[:512], w2i, args)
# print("---- HARD_BUFFER_ACCURACY %s %s " % (e, hard_buf_acc))
# compute accuracy on valid
data_loader.reset_valid()
for valid_type in data_loader.data["valid"]:
print("----- VALID %s" % valid_type, e)
logging.info("----- VALID %s %d" % (valid_type, e))
run_epoch(
data_loader,
a_tree_pred,
a_tree_loss,
w2i,
args,
mode="valid",
data_type=valid_type,
optimizer=None,
)
acc = compute_accuracy(
a_tree_pred, data_loader.data["valid"][valid_type][:256], w2i, args
)
logging.info("----- VALID_ACCURACIES %d %s %.2f" % (e, valid_type, acc))
if __name__ == "__main__":
main()
| craftassist-master | python/base_agent/ttad/ttad_model/train_model.py |
import os
import sys
sys.path.append(os.path.dirname(__file__))
| craftassist-master | python/base_agent/ttad/ttad_model/__init__.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import json
import sys
import spacy
from spacy.lang.en import English
tokenizer = English().Defaults.create_tokenizer()
def tokenize(st):
return " ".join([str(x) for x in tokenizer(st)])
data_in_text_file = sys.argv[1]
data_out_json_file = sys.argv[2]
print("parsing text file")
res = []
exple = []
f_text = open(data_in_text_file)
for i, line in enumerate(f_text):
if line.strip() == "":
res += [(exple[:-1], json.loads(exple[-1]))]
exple = []
else:
if line.startswith('"'):
text = tokenize(line.strip()[1:-1])
exple += [text]
else:
exple += [line.strip()]
if i % 100000 == 0:
print("read %d lines, found %d examples" % (i, len(res)))
f_text.close()
# n_train = (9 * len(res)) // 10
n_train = len(res) - 10000
n_valid = 5000
# n_valid = len(res) // 20
data = {
"train": {"templated": res[:n_train]},
"valid": {"templated": res[n_train : n_train + n_valid]},
"test": {"templated": res[n_train + n_valid :]},
}
print("saving data dict")
json.dump(data, open(data_out_json_file, "w"))
| craftassist-master | python/base_agent/ttad/ttad_model/make_dataset.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import json
import sys
from pprint import pprint
from emnlp_model import *
data_file = sys.argv[1]
grammar_file = sys.argv[2]
print("loading", data_file)
data_dct = json.load(open(data_file))
print("loaded data")
a_tree = ActionTree()
for spl, spl_dct in data_dct.items():
for d_type, ls in spl_dct.items():
print("reading", spl, d_type)
a_tree.build_from_list([t for d, t in ls])
a_tree_dct = a_tree.to_dict()
json.dump(a_tree_dct, open(grammar_file, "w"))
pprint(a_tree_dct)
| craftassist-master | python/base_agent/ttad/ttad_model/make_action_grammar.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import copy
import math
import torch
import torch.nn as nn
##### Utility modules
# Produce n identical layers.
def clones(module, n):
return nn.ModuleList([copy.deepcopy(module) for _ in range(n)])
def xavier_init(module, mul=1.0):
for p in module.parameters():
if p.dim() > 1:
torch.nn.init.xavier_normal_(p, mul)
else:
torch.nn.init.constant_(p, 0)
# Compute 'Scaled Dot Product Attention'
def attention(query, key, value, mask=None, dropout=None):
dim = query.size(-1)
scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(dim)
if mask is not None:
scores = scores.masked_fill(mask.unsqueeze(1) == 0, -1e9)
p_attn = torch.softmax(scores, dim=-1)
if dropout is not None:
p_attn = dropout(p_attn)
return torch.matmul(p_attn, value), p_attn
class MultiHeadedAttention(nn.Module):
def __init__(self, h, d_model, dropout=0.1):
"Take in model size and number of heads."
super(MultiHeadedAttention, self).__init__()
assert d_model % h == 0
# We assume d_v always equals d_k
self.d_k = d_model // h
self.h = h
self.linears = clones(nn.Linear(d_model, d_model), 4)
self.attn = None
self.dropout = nn.Dropout(p=dropout)
def forward(self, query, key, value, mask=None):
if mask is not None:
# Same mask applied to all h heads.
mask = mask.unsqueeze(1)
nbatches = query.size(0)
# 1) Do all the linear projections in batch from d_model => h x d_k
query, key, value = [
l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)
for l, x in zip(self.linears, (query, key, value))
]
# 2) Apply attention on all the projected vectors in batch.
x, self.attn = attention(query, key, value, mask=mask, dropout=self.dropout)
# 3) "Concat" using a view and apply a final linear.
x = x.transpose(1, 2).contiguous().view(nbatches, self.h * self.d_k)
return self.linears[-1](x)
def initialize(self, mul):
for lin in self.linears:
xavier_init(lin, mul)
# node sub-modules
# NodeSentRep attends to sentence representation (and possibly previously visited nodes)
# to get contextual representation vector for current node
# used to predict the presence of an internal node or the value of a categorical node
class NodeSentenceRep(nn.Module):
def __init__(self, tree, sent_attn, tree_attn, rec_cell):
super(NodeSentenceRep, self).__init__()
self.dim = tree.dim
self.do = nn.Dropout(tree.dropout)
# attending over the tree context first
self.tree_attn = tree_attn
self.sent_attn = sent_attn
self.rec_proj = nn.Linear(2 * self.dim, self.dim)
self.rec_cell = rec_cell
def initialize(self, mul):
self.tree_attn.initialize(mul)
self.sent_attn.initialize(mul)
xavier_init(self.rec_cell, mul)
xavier_init(self.rec_proj, mul)
def forward(self, node_vec, sentence_rep, tree_context):
sent_vecs, sent_mask = sentence_rep
prev_h, parent_h, context_rep, context_mask = tree_context
if prev_h is not None:
node_vec = node_vec + prev_h
if context_rep is not None:
node_rep = self._apply_tree_attn(node_vec, context_rep, context_mask)
else:
node_rep = node_vec
node_rep = self._apply_sen_attn(node_rep, sent_vecs, sent_mask)
return node_rep
# our (sentence + tree)-attention baseline
def _apply_tree_attn(self, node_vec, context_rep, context_mask):
# if recursive: attend over provided context
# to compute node representaiton
# else: just use node parameter
# attend over context
context_h = self.tree_attn(node_vec, context_rep, context_rep, mask=context_mask)
node_tree_rep = self.do(context_h + node_vec)
return node_tree_rep
# inplementing Seq2Tree from Dong & Lapata
def _apply_sen_attn(self, node_vec, sent_rep, sent_mask):
# predict presence and value based on previous hidden space
node_rep = self.sent_attn(node_vec, sent_rep, sent_rep, mask=sent_mask)
node_pred = self.do(node_vec + node_rep)
return node_pred
def _apply_recurrence(self, node_rep, prev_h, parent_h, on_mask):
# update hidden space based on node vector and previous and parent hidden space
if parent_h is None:
node_vec = node_rep
else:
node_vec = self.rec_proj(torch.cat([node_rep, parent_h], dim=-1))
node_h = self.rec_cell(node_vec, prev_h)
# only update hidden state for active nodes
node_h = on_mask[:, None] * node_h + (1 - on_mask[:, None]) * prev_h
return node_h
# Various internal node and leaf prediction heads
# sigmoid for presence scores
class PredictPresence(nn.Module):
def __init__(self, dim):
super(PredictPresence, self).__init__()
self.score_pres = nn.Linear(dim, 1)
def initialize(self, mul):
xavier_init(self.score_pres, mul)
def forward(self, x):
scores = self.score_pres(x).squeeze(dim=-1)
return scores
# softmax over class scores
class PredictCategorySingle(nn.Module):
def __init__(self, dim, n_vals):
super(PredictCategorySingle, self).__init__()
self.score_vals = nn.Linear(dim, n_vals)
def initialize(self, mul):
xavier_init(self.score_vals, mul)
def forward(self, x):
scores = self.score_vals(x)
scores = torch.log_softmax(scores, dim=-1)
return scores
# sigmoid for each class score
class PredictCategorySet(nn.Module):
def __init__(self, dim, n_vals):
super(PredictCategorySet, self).__init__()
self.score_vals = nn.Linear(dim, n_vals)
def initialize(self, mul):
xavier_init(self.score_vals, mul)
def forward(self, x):
scores = self.score_vals(x)
return scores
# softmax over indexes for start and end
class PredictSpanSingle(nn.Module):
def __init__(self, dim):
super(PredictSpanSingle, self).__init__()
self.score_start = nn.Linear(dim, dim)
self.score_end = nn.Linear(dim, dim)
def initialize(self, mul):
xavier_init(self.score_start, mul)
xavier_init(self.score_end, mul)
def forward(self, x, sentence_rep):
sen_vecs, sen_mask = sentence_rep
sen_start = self.score_start(sen_vecs) # B x T x D
scores_start = torch.matmul(sen_start, x.unsqueeze(-1)).squeeze(-1) # B x T
scores_start = scores_start.masked_fill(sen_mask == 0, -1e6)
sen_end = self.score_end(sen_vecs) # B x T x D
scores_end = torch.matmul(sen_end, x.unsqueeze(-1)).squeeze(-1) # B x T
scores_end = scores_end.masked_fill(sen_mask == 0, -1e6)
scores = scores_start.unsqueeze(-1) + scores_end.unsqueeze(-2) # B x T x T
bs, t = scores.shape[:2]
scores += torch.tril(-1e6 * torch.ones(t, t), diagonal=-1).unsqueeze(0).type_as(sen_vecs)
scores = scores.view(bs, -1)
scores = torch.log_softmax(scores, dim=-1)
scores = scores.view(bs, t, t)
return scores
# BIO tagging
# (no transition scores in thids implementation, TODO)
def log_sum_exp(bx):
bm = bx.max(dim=-1)[0]
return bm + torch.log(torch.exp(bx - bm.unsqueeze(-1)).sum(dim=-1))
class PredictSpanSet(nn.Module):
def __init__(self, dim):
super(PredictSpanSet, self).__init__()
self.score_b = nn.Linear(dim, dim)
self.score_i = nn.Linear(dim, dim)
self.score_o = nn.Linear(dim, dim)
def initialize(self, mul):
xavier_init(self.score_b, mul)
xavier_init(self.score_i, mul)
xavier_init(self.score_o, mul)
def forward(self, x, sentence_rep):
sen_vecs, sen_mask = sentence_rep
sen_b = self.score_b(sen_vecs) # B x T x D
scores_b = torch.matmul(sen_b, x.unsqueeze(-1)).squeeze(-1) # B x T
scores_b = scores_b.masked_fill(sen_mask == 0, -1e6)
sen_i = self.score_i(sen_vecs) # B x T x D
scores_i = torch.matmul(sen_i, x.unsqueeze(-1)).squeeze(-1) # B x T
scores_i = scores_i.masked_fill(sen_mask == 0, -1e6)
sen_o = self.score_o(sen_vecs) # B x T x D
scores_o = torch.matmul(sen_o, x.unsqueeze(-1)).squeeze(-1) # B x T
scores_o = scores_o.masked_fill(sen_mask == 0, 0)
scores_bio = torch.cat(
[scores_b.unsqueeze(-1), scores_i.unsqueeze(-1), scores_o.unsqueeze(-1)], dim=-1
) # B x T x 3
# alpha beta recursion
bs, bt = scores_o.shape
forward_scores = torch.zeros(bs, bt + 1).type_as(scores_o)
backward_scores = torch.zeros(bs, bt + 1).type_as(scores_o)
for t in range(1, bt + 1):
forward_scores[:, t] = log_sum_exp(
forward_scores[:, t - 1].unsqueeze(dim=-1) + scores_bio[:, t - 1]
)
backward_scores[:, -t - 1] = log_sum_exp(
backward_scores[:, -t].unsqueeze(dim=-1) + scores_bio[:, -t]
)
full_scores = forward_scores[:, -1]
span_scores = torch.zeros(bs, bt, bt).type_as(sen_vecs)
for s in range(bt):
for e in range(s, bt):
span_scores[:, e, s] = -1e3
span_scores[:, s, e] = (
scores_b[:, s]
+ scores_i[:, s:e].sum(dim=-1)
+ forward_scores[:, s]
+ backward_scores[:, e + 1]
- full_scores
)
if e < bt:
span_scores[:, s, e] += scores_o[:, e]
return span_scores
| craftassist-master | python/base_agent/ttad/ttad_model/emnlp_model/model_utils.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import math
import torch
import torch.nn as nn
class HighwayNetwork(nn.Module):
def __init__(self, in_dim, out_dim):
super(HighwayNetwork, self).__init__()
self.gate_proj = nn.Linear(in_dim, out_dim)
self.lin_proj = nn.Linear(in_dim, out_dim)
self.nonlin_proj = nn.Linear(in_dim, out_dim)
for p in self.parameters():
if p.dim() > 1:
torch.nn.init.xavier_normal_(p)
else:
torch.nn.init.constant_(p, 0)
def forward(self, x):
gate = torch.sigmoid(self.gate_proj(x) - 2)
lin = self.lin_proj(x)
nonlin = torch.relu(self.nonlin_proj(x))
res = gate * nonlin + (1 - gate) * lin
return res
# simple sentence embedding usinf pre-trained fastText
# for debugging
class FastTextSentenceEmbedding(nn.Module):
def __init__(self, dim, l_dim, n_words, ft_embeds, init_embeds=True):
super(FastTextSentenceEmbedding, self).__init__()
self.dim = dim
self.ft_dim = 0 if ft_embeds is None else 300
self.l_dim = l_dim
self.ft_embed = False if ft_embeds is None else nn.Embedding.from_pretrained(ft_embeds)
if l_dim > 0:
self.learn_embed = nn.Embedding(n_words, l_dim)
for p in self.learn_embed.parameters():
torch.nn.init.constant_(p, 0)
self.proj = HighwayNetwork(self.ft_dim + self.l_dim, self.dim)
for p in self.proj.parameters():
if p.dim() > 1:
torch.nn.init.xavier_normal_(p)
else:
torch.nn.init.constant_(p, 0)
if l_dim > 0:
if self.ft_embed:
for p in self.learn_embed.parameters():
torch.nn.init.constant_(p, 0)
else:
for p in self.learn_embed.parameters():
if p.dim() > 1:
torch.nn.init.xavier_normal_(p)
else:
torch.nn.init.constant_(p, 0)
def forward(self, sent_ids, sent_mask=None, sent_len=None):
if self.ft_embed:
ft_embed = self.ft_embed(sent_ids).detach()
if self.l_dim > 0:
l_embed = self.learn_embed(sent_ids)
if self.ft_embed and self.l_dim > 0:
pre_embed = torch.cat([ft_embed, l_embed], dim=-1)
elif self.ft_embed:
pre_embed = ft_embed
else:
pre_embed = l_embed
return self.proj(pre_embed)
# Sinusoidal position encodings
class PositionalEncoding(nn.Module):
def __init__(self, dim, dropout, max_len=320):
super(PositionalEncoding, self).__init__()
self.dropout = nn.Dropout(dropout)
# Compute the positional encodings once in log space.
pe = torch.zeros(max_len, dim)
position = torch.arange(0, max_len).float().unsqueeze(1)
div_term = torch.exp(torch.arange(0, dim, 2).float() * -(math.log(10000.0) / dim))
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
pe = pe.unsqueeze(0)
def forward(self, x):
x = x + self.pe[:, : x.size(1)].detach()
return self.dropout(x)
# convolutional sentence encoder
class SentenceConvEncoder(nn.Module):
def __init__(self, word_embed, dim, k, n_layers, dropout=0.1):
super(SentenceConvEncoder, self).__init__()
self.word_embed = word_embed
self.conv_layers = nn.ModuleList(
[nn.Conv1d(dim, 2 * dim, 2 * k + 1, padding=k) for _ in range(n_layers)]
)
self.glu = nn.GLU()
self.do = nn.Dropout(dropout)
for p in self.parameters():
if p.dim() > 1:
torch.nn.init.xavier_normal_(p)
else:
torch.nn.init.constant_(p, 0)
# don't initialize PE!
self.pe = PositionalEncoding(dim, dropout)
def forward(self, sent_ids, sent_mask, sent_len):
x = self.word_embed(sent_ids)
x = self.do(x)
for layer in self.conv_layers:
residual = x
x = layer(x.transpose(1, 2)).transpose(1, 2)
x = self.glu(x) + residual
x = x.masked_fill(sent_mask.unsqueeze(-1) == 0, 0)
x = self.do(x)
return x
# BiGRU sentence encoder
class SentenceBiGRUEncoder(nn.Module):
def __init__(self, word_embed, dim, n_layers, dropout=0.1):
super(SentenceBiGRUEncoder, self).__init__()
self.word_embed = word_embed
self.bigru = nn.GRU(
dim, dim, n_layers, batch_first=True, bidirectional=True, dropout=dropout
)
self.final_proj = nn.Linear(2 * dim, dim)
self.do = nn.Dropout(dropout)
for p in self.parameters():
if p.dim() > 1:
torch.nn.init.xavier_normal_(p)
else:
torch.nn.init.constant_(p, 0)
def forward(self, sent_ids, sent_mask, sent_len):
x = self.word_embed(sent_ids)
x = self.do(x)
lengths = sent_len
# TODO this is a temporary hotfix for unsorted padded sequence
if sent_mask.shape[0] > 1:
packed_x = nn.utils.rnn.pack_padded_sequence(
x, lengths, batch_first=True, enforce_sorted=False
)
else:
packed_x = nn.utils.rnn.pack_padded_sequence(x, lengths, batch_first=True)
packed_h, _ = self.bigru(packed_x)
h, _ = nn.utils.rnn.pad_packed_sequence(packed_h, batch_first=True)
h = self.do(h)
h = self.final_proj(h)
return h
| craftassist-master | python/base_agent/ttad/ttad_model/emnlp_model/sentence_encoder.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
# define the grammar
from collections import OrderedDict
#####
## define node types
class SpanSingleLeaf:
def __init__(self, node_id, name):
self.node_type = "span-single"
self.name = name
self.node_id = node_id
def is_span(val):
try:
# previous version
# (b, c) = val
# return all([type(v) == int for v in [b, c]])
a, (b, c) = val
return all([type(v) == int for v in [a, b, c]])
except (ValueError, TypeError):
return False
def is_span_dialogue(val):
try:
a, (b, c) = val
return all([type(v) == int for v in [a, b, c]])
except (ValueError, TypeError):
return False
class SpanSetLeaf:
def __init__(self, node_id, name):
self.node_type = "span-set"
self.name = name
self.node_id = node_id
def is_span_list(val):
res = type(val) == list and len(val) > 0 and all([is_span(v) for v in val])
return res
class CategoricalSingleLeaf:
def __init__(self, node_id, name, choices=None):
self.node_type = "categorical-single"
self.name = name
self.node_id = node_id
self.choices = [] if choices is None else choices[:]
def is_cat(val):
return type(val) == str or val is True or val is False
class CategoricalSetLeaf:
def __init__(self, node_id, name, choices=None):
self.node_type = "categorical-set"
self.name = name
self.node_id = node_id
self.choices = [] if choices is None else choices[:]
def is_cat_list(val):
res = type(val) == list and len(val) > 0 and all([is_cat(v) for v in val])
return res
def make_leaf(node_id, name, value=None, node_type=""):
if (
type(value) == list
and len(value) == 2
and (type(value[0]) == int and type(value[1]) == int)
):
value = [0, value]
if node_type == "span-single" or is_span(value):
return SpanSingleLeaf(node_id, name)
elif node_type == "span-set" or is_span_list(value):
return SpanSetLeaf(node_id, name)
elif node_type == "categorical-single" or is_cat(value):
return CategoricalSingleLeaf(node_id, name)
elif node_type == "categorical-set" or is_cat_list(value):
return CategoricalSetLeaf(node_id, name)
else:
print("M", value)
raise NotImplementedError
class InternalNode:
def __init__(self, node_id, name):
self.node_type = "internal"
self.node_id = node_id
self.name = name
self.internal_children = OrderedDict()
self.leaf_children = OrderedDict()
self.children = OrderedDict()
def add_int_node(self, name):
new_node = InternalNode(self.node_id + "-" + name, name)
node = self.internal_children.get(name, new_node)
self.internal_children[name] = node
self.children[name] = node
return node
def add_leaf_node(self, name, value):
node_id = self.node_id + ":" + name
new_node = make_leaf(node_id, name, value=value)
node = self.leaf_children.get(name, new_node)
if is_cat(value) and value not in node.choices:
node.choices += [value]
elif is_cat_list(value):
for v in value:
if v not in node.choices:
node.choices += [v]
self.leaf_children[name] = node
self.children[name] = node
return node
def is_sub_tree(val):
return type(val) == dict
####
# make full tree
class ActionTree:
def __init__(self):
self.root = InternalNode("root", "root")
def _add_subtree_dict(self, node, sub_tree):
for k, val in sub_tree.items():
if is_sub_tree(val):
child_node = node.add_int_node(k)
self._add_subtree_dict(child_node, val)
else:
if k == "location":
print(sub_tree)
raise NotImplementedError
node.add_leaf_node(k, val)
def build_from_list(self, tree_list):
for i, parse_tree in enumerate(tree_list):
self._add_subtree_dict(self.root, parse_tree)
def _sub_to_dict(self, node):
res = OrderedDict()
for k, val in node.internal_children.items():
res[k] = (val.node_type, val.node_id, self._sub_to_dict(val))
for k, val in node.leaf_children.items():
res[k] = (
val.node_type,
val.node_id,
val.choices if "categorical" in val.node_type else "",
)
return res
def to_dict(self):
return self._sub_to_dict(self.root)
def _sub_from_dict(self, node, sub_tree):
for name, (node_type, node_id, value) in sub_tree.items():
if node_type == "internal":
child_node = node.add_int_node(name)
assert node_id == child_node.node_id
self._sub_from_dict(child_node, value)
else:
new_node = make_leaf(node_id, name, node_type=node_type)
if "categorical" in node_type:
new_node.choices = value
node.leaf_children[name] = new_node
node.children[name] = new_node
def from_dict(self, a_tree):
self._sub_from_dict(self.root, a_tree)
| craftassist-master | python/base_agent/ttad/ttad_model/emnlp_model/action_tree.py |
from .action_tree import *
from .data import *
from .sentence_encoder import *
from .prediction_model import *
from .my_optim import *
| craftassist-master | python/base_agent/ttad/ttad_model/emnlp_model/__init__.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import json
import math
import pickle
import torch
import torch.nn as nn
from .action_tree import *
from .model_utils import *
from .my_optim import *
from .sentence_encoder import *
##### Define tree modules
# Each node module computes a contextual node representation
# and predicts whether the node is present, as we as its
# categorical or span value for leaves
class NodePrediction(nn.Module):
def __init__(self, node_sen_rep, node, args):
super(NodePrediction, self).__init__()
self.dim = args.model_dim
self.dropout = nn.Dropout(args.dropout)
self.node_type = node.node_type
self.node_vec = nn.Parameter(torch.zeros(self.dim))
self.node_sen_rep = node_sen_rep
self.node_score_pres = PredictPresence(self.dim)
# have to define module outside of loop for pytorch reasons
n_values = len(node.choices) if "categorical" in self.node_type else 1
self.nsv_s_sin = PredictSpanSingle(self.dim)
self.nsv_s_set = PredictSpanSet(self.dim)
self.nsv_c_sin = PredictCategorySingle(self.dim, n_values)
self.nsv_c_set = PredictCategorySet(self.dim, n_values)
self.nvv = nn.Embedding(n_values, self.dim)
self.module_list = nn.ModuleList(
[
self.node_score_pres,
self.nsv_s_sin,
self.nsv_s_set,
self.nsv_c_sin,
self.nsv_c_set,
self.nvv,
]
)
if self.node_type == "internal":
self.node_score_val = None
elif self.node_type == "span-single":
self.node_score_val = self.nsv_s_sin
elif self.node_type == "span-set":
self.node_score_val = self.nsv_s_set
elif self.node_type == "categorical-single":
self.node_val_vec = self.nvv
self.node_score_val = self.nsv_c_sin
elif self.node_type == "categorical-set":
self.node_val_vec = self.nvv
self.node_score_val = self.nsv_c_set
else:
raise NotImplementedError
def forward(self, sentence_rep, tree_context, recursion, active, labels):
# compute node representation to be used in prediction
sent_rep, sent_mask = sentence_rep
node_vec = self.node_vec[None, :].expand(active.shape[0], self.dim).type_as(sent_rep)
node_rep = self.node_sen_rep(node_vec, sentence_rep, tree_context)
node_rep = self.dropout(node_rep)
if recursion == "seq2tree-rec":
node_x = node_vec
else:
node_x = node_rep
# predict whether the node is on
# uses labels if available or predicted value otherwise
# for recurrence / recursion update
pres_score = self.node_score_pres(node_rep)
if labels is None:
on_mask = ((pres_score > 0).long() * active).type_as(sent_rep)
else:
on_mask = (labels["pres_labels"] * active).type_as(sent_rep)
on_mask *= active.type_as(sent_rep)
# predict node value for leaves
span_score = None
cat_score = None
if self.node_type == "internal":
pass
elif self.node_type in ["span-single", "span-set"]:
span_score = self.node_score_val(node_rep, sentence_rep)
elif self.node_type in ["categorical-single", "categorical-set"]:
cat_score = self.node_score_val(node_rep)
if self.node_type == "categorical-single":
if labels is None:
cat_val = cat_score.max(dim=-1)[1]
else:
cat_val = labels["cat_labels"].type_as(sent_mask)
cat_rep = self.node_val_vec(cat_val)
node_x = node_x + cat_rep
else:
print(self.node_type)
raise NotImplementedError
# if using recurrence, update hidden state
if recursion in ["seq2tree-rec", "sentence-rec"]:
prev_h, parent_h, _, _ = tree_context
node_h = self.node_sen_rep._apply_recurrence(node_x, prev_h, parent_h, on_mask)
elif recursion in ["none", "top-down", "dfs-intern", "dfs-all"]:
node_h = None
else:
raise NotImplementedError
return {
"pres_score": pres_score,
"cat_score": cat_score,
"span_score": span_score,
"node_rep": node_rep,
"node_h": node_h,
}
def to(self, *args, **kwargs):
self = super().to(*args, **kwargs)
self.node_vec = self.node_vec.to(*args, **kwargs)
self.node_score_pres = self.node_score_pres.to(*args, **kwargs)
if self.node_score_val is not None:
self.node_score_val = self.node_score_val.to(*args, **kwargs)
return self
# xavier initialization for most parameters
def initialize(self, mul=1.0):
torch.nn.init.normal_(self.node_vec, mul / math.sqrt(self.dim))
self.node_score_pres.initialize(mul)
if self.node_score_val is not None:
self.node_score_val.initialize(mul)
##### Define full tree
class ActionTreePrediction(nn.Module):
def __init__(self, sentence_embed, action_tree_path, args):
super(ActionTreePrediction, self).__init__()
self.args = args
self.dim = args.model_dim
self.dropout = args.dropout
action_tree = ActionTree()
action_tree.from_dict(json.load(open(action_tree_path)))
self.action_tree = action_tree
self.root_node = self.action_tree.root
self.sentence_rep = sentence_embed
# make tree-wide module parameters
sent_attn = MultiHeadedAttention(args.sent_heads, self.dim, self.dropout)
tree_attn = MultiHeadedAttention(args.tree_heads, self.dim, self.dropout)
rec_cell = nn.GRUCell(self.dim, self.dim)
self.node_sen_rep = NodeSentenceRep(self, sent_attn, tree_attn, rec_cell)
self.start_h = nn.Parameter(torch.zeros(self.dim))
# initialize list of nodes
self.module_dict = {}
self.collapse = args.collapse_nodes # use same parameters for nodes with the same name
self.node_list = []
self.make_modules()
self.module_list = nn.ModuleList([node.predictor for node in self.node_list])
# index node to easily access representation and mask
for i, node in enumerate(self.node_list):
node.tree_index = i + 1
self.tree_size = len(self.node_list) + 1
self.context_rep = None
self.context_mask = None
def to(self, *args, **kwargs):
self = super().to(*args, **kwargs)
self.start_h = self.start_h.to(*args, **kwargs)
self.node_sen_rep = self.node_sen_rep.to(*args, **kwargs)
for node in self.node_list:
node.predictor = node.predictor.to(*args, **kwargs)
return self
def initialize(self, mul=1.0):
torch.nn.init.constant_(self.start_h, 0)
self.node_sen_rep.initialize(mul)
for node in self.node_list:
node.predictor.initialize(mul)
return self
def device(self):
return self.start_h.device
# create Internal-, Categorical-, and Span-Prediction
# modules to match the structure of self.action_tree
def make_modules(self):
self._make_modules_recursion(self.root_node)
def _make_modules_recursion(self, node):
# print(len(self.node_list), node.name, node.node_type, node.node_id)
if self.collapse and node.name in self.module_dict:
node.predictor = self.module_dict[node.name]
else:
node.predictor = NodePrediction(self.node_sen_rep, node, self.args)
if self.collapse:
self.module_dict[node.name] = node.predictor
self.node_list.append(node)
for k, chld in node.leaf_children.items():
if self.collapse and chld.name in self.module_dict:
chld.predictor = self.module_dict[chld.name]
else:
chld.predictor = NodePrediction(self.node_sen_rep, chld, self.args)
if self.collapse:
self.module_dict[chld.name] = chld.predictor
self.node_list.append(chld)
for k, chld in node.internal_children.items():
self._make_modules_recursion(chld)
def _make_tree_context(self, node_h, node_path):
prev_h, parent_h = node_h
if node_path:
c_rep = torch.cat([node.out["node_rep"].unsqueeze(dim=1) for node in node_path], dim=1)
c_mask = torch.cat([node.mask.unsqueeze(dim=1) for node in node_path], dim=1)
return (prev_h, parent_h, c_rep, c_mask)
else:
return (prev_h, parent_h, None, None)
# compute internal, categorical and span scores
# (they have different losses, hence the split)
# stores scores in the node.out field
def forward(self, sent_ids, sent_mask, sent_len, recursion="none", prediction=False):
# compute sentence representation
sent_rep = self.sentence_rep(sent_ids, sent_mask, sent_len)
sentence_rep = (sent_rep, sent_mask)
# initialize root node
if prediction:
for node in self.node_list:
node.active = torch.zeros(sent_rep.shape[0]).type_as(sent_mask)
self.root_node.active = torch.ones(sent_rep.shape[0]).type_as(sent_mask)
self.root_node.mask = torch.ones(sent_rep.shape[0]).type_as(sent_mask)
self.root_node.out = {}
self.root_node.out["node_rep"] = self.start_h[None, :].expand(sent_rep.shape[0], self.dim)
self.root_node.labels = {"pres_labels": self.root_node.mask}
# prepare node path and recurrent state
node_path = None
prev_h = None
parent_h = None
context_rep = None
context_mask = None
if recursion in ["top-down", "dfs-intern", "dfs-all"]:
node_path = [self.root_node]
if recursion in ["seq2tree-rec", "sentence-rec"]:
prev_h = torch.zeros(sent_rep.shape[0], self.dim).type_as(sent_rep)
# prev_h = prev_h + self.start_h
parent_h = torch.zeros(sent_rep.shape[0], self.dim).type_as(sent_rep)
node_h = (prev_h, parent_h)
# launch recursion
_ = self._forward_recursion(
self.root_node, sentence_rep, node_h, node_path, recursion, prediction
)
# TODO: add set prediction leaves
node_scores = [
node.out for node in self.node_list if any(node.active) and node.name != "root"
]
return node_scores
# different types of recursion:
# - 'none': no tree context
# - 'top-down': only see context from ancestors
# - 'dfs-intern': sees all internal nodes in DFS order
# - 'dfs-all': sees all nodes in DFS order
# - 'seq2tree-rec': Recurrent model following Dong&Lapata
# - 'sentence-rec': same but recurrent update depends on sentence
def _forward_recursion(self, node, sentence_rep, node_h, node_path, recursion, prediction):
prev_h, parent_h = node_h
# start by predicting presence of current node
node.out = node.predictor(
sentence_rep,
self._make_tree_context(node_h, node_path),
recursion,
node.active,
None if prediction and node.name != "root" else node.labels,
)
if recursion == "dfs-all":
node_path += [node]
if prediction and node.name != "root":
node.mask = node.active * (node.out["pres_score"] > 0).type_as(node.active)
else:
node.mask = node.active * node.labels["pres_labels"].type_as(node.active)
if node.node_type == "internal":
# don't waste time on inactive nodes
if node.mask.sum().item() == 0:
node_h = (node.out["node_h"], parent_h)
return (node_path, node_h)
# add current node to path for attention-based recursion
if recursion in ["top-down", "dfs-intern"]:
node_path += [node]
# predict the state of all children in DFS order
node_h = (node.out["node_h"], node.out["node_h"])
for k, chld in node.children.items():
chld.active = node.mask
if recursion in ["dfs-intern", "dfs-all", "seq2tree-rec", "sentence-rec"]:
node_path, node_h = self._forward_recursion(
chld, sentence_rep, node_h, node_path, recursion, prediction
)
elif recursion in ["none", "top-down"]:
_, _ = self._forward_recursion(
chld, sentence_rep, node_h, node_path, recursion, prediction
)
else:
raise NotImplementedError
node_h = (node.out["node_h"], parent_h)
return (node_path, node_h)
# run through the batch of trees (list of dicts) once to identify nodes that
# are active in this batch and create labels
# results are stored in the node.labels and node.active fields
def make_labels(self, tree_list, cuda=False):
batch_size = len(tree_list)
# initialize context_rep and context_mask
for node in self.node_list:
node.active = torch.LongTensor([0 for _ in tree_list]).to(self.device())
self.root_node.active = torch.LongTensor([1 for _ in tree_list]).to(self.device())
self.root_node.mask = torch.LongTensor([1 for _ in tree_list]).to(self.device())
self._make_labels_recursion(self.root_node, tree_list, self.root_node.active)
# FIXME: set nodes
active_node_list = [
node
for node in self.node_list
if node.active.sum().item() > 0
and node.name != "root"
and node.node_type != "span-set"
]
return active_node_list
def _make_labels_recursion(self, node, sub_tree_list, active):
# aggregate subtrees
node.active = active
node.mask = torch.LongTensor([1 if st else 0 for st in sub_tree_list]).to(self.device())
cat_labels = None
span_labels = None
if node.node_type == "internal":
pass
elif node.node_type == "categorical-single":
cat_labels = torch.LongTensor(
[node.choices.index(val) if val else 0 for val in sub_tree_list]
).to(self.device())
elif node.node_type == "categorical-set":
# TODO: FIXME
# currently predicting one value at random
cat_labels = torch.LongTensor(
[
node.choices.index(val[0]) if val and len(val) > 0 else 0
for val in sub_tree_list
]
).to(self.device())
elif node.node_type == "span-single":
span_labels = torch.LongTensor(
[(val[0], val[1]) if val else (0, 0) for val in sub_tree_list]
).to(self.device())
node.labels = {
"pres_labels": node.mask,
"cat_labels": cat_labels,
"span_labels": span_labels,
}
# check whether we even need to go down and continue
if node.node_type == "internal" and any(sub_tree_list):
for k, chld in node.children.items():
st_list = [t.get(k, False) if t else False for t in sub_tree_list]
self._make_labels_recursion(chld, st_list, node.mask)
# predict tree for single-sentence batch
def predict_tree(self, sent_ids, sent_mask, sent_len, recursion):
for node in self.node_list:
node.active = torch.LongTensor([0 for _ in range(sent_ids.shape[0])]).to(self.device())
self.root_node.active = torch.LongTensor([1 for _ in range(sent_ids.shape[0])]).to(
self.device()
)
self.root_node.mask = torch.LongTensor([1 for _ in range(sent_ids.shape[0])]).to(
self.device()
)
self.root_node.labels = {
"pres_labels": torch.LongTensor([1 for _ in range(sent_ids.shape[0])]).to(
self.device()
)
}
_ = self.forward(sent_ids, sent_mask, sent_len, recursion=recursion, prediction=True)
res = self._predict_tree_recursion(self.root_node)
return res
def _predict_tree_recursion(self, node):
res = {}
for k, chld in node.children.items():
if chld.node_type == "internal":
if chld.mask.item() == 1:
res[k] = self._predict_tree_recursion(chld)
elif chld.node_type == "categorical-single":
if chld.mask.item() == 1:
cat_index = chld.out["cat_score"].max(dim=-1)[1][0].item()
res[k] = chld.choices[cat_index]
elif chld.node_type == "categorical-set":
# FIXME: currently only / always predicting one
if chld.mask.item() == 1:
cat_index = chld.out["cat_score"].max(dim=-1)[1][0].item()
res[k] = [chld.choices[cat_index]]
elif chld.node_type == "span-single":
if chld.mask.item() == 1:
sp_index = chld.out["span_score"].view(1, -1).max(dim=-1)[1][0].item()
start_index = sp_index // chld.out["span_score"].shape[-1]
end_index = sp_index % chld.out["span_score"].shape[-1]
res[k] = (0, (start_index, end_index))
else:
# TODO: add set prediction
# raise NotImplementedError
res[k] = "NOT_IMPLEMENTED"
return res
################# utility
def make_model(args, embeddings_path, action_tree_path, use_cuda):
map_location = "cpu" if not torch.cuda.is_available() else None
ft_dict = torch.load(embeddings_path, map_location=map_location)
i2w = [w for w, c in ft_dict["vocabulary"]]
w2i = dict([(w, i) for i, w in enumerate(i2w)])
# make model
if args.learn_embeds:
word_embed = FastTextSentenceEmbedding(
args.model_dim, args.learn_embed_dim, len(i2w), None
)
else:
word_embed = FastTextSentenceEmbedding(
args.model_dim, args.learn_embed_dim, len(i2w), ft_dict["embeddings"]
)
if args.sentence_encoder == "convolution":
sent_embed = SentenceConvEncoder(
word_embed, args.model_dim, args.sent_conv_window, args.sent_conv_layers, args.dropout
)
elif args.sentence_encoder == "bigru":
sent_embed = SentenceBiGRUEncoder(
word_embed, args.model_dim, args.sent_gru_layers, args.dropout
)
else:
raise NotImplementedError
# load action tree
# TODO: add initializer multiplier to arguments
a_tree_pred = ActionTreePrediction(sent_embed, action_tree_path, args)
a_tree_pred.initialize(mul=1.0)
a_tree_loss = TreeLoss(args)
if use_cuda:
print("moving to cuda")
a_tree_pred.to("cuda:0")
a_tree_loss.to("cuda:0")
return (a_tree_pred, a_tree_loss, w2i)
def load_model(model_path, embeddings_path=None, action_tree_path=None, use_cuda=False, epoch=-1):
model_name = model_path.split(".pth")[0].strip()
with open("%s.args.pk" % (model_name,), "rb") as f:
args = pickle.load(f)
args.cuda = use_cuda
args.collapse_nodes = False # TODO fix
a_tree_pred, a_tree_loss, w2i = make_model(args, embeddings_path, action_tree_path, use_cuda)
map_location = None if use_cuda and torch.cuda.is_available() else "cpu"
if epoch < 0:
a_tree_pred.load_state_dict(
torch.load("%s.pth" % (model_name,), map_location=map_location)
)
print("loaded %s.pth" % (model_name,))
else:
a_tree_pred.load_state_dict(
torch.load("%s_%d.pth" % (model_name, epoch), map_location=map_location)
)
print("loaded %s_%d.pth" % (model_name, epoch))
a_tree_pred = a_tree_pred.eval()
return (a_tree_pred, a_tree_loss, w2i, args)
| craftassist-master | python/base_agent/ttad/ttad_model/emnlp_model/prediction_model.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import json
import numpy as np
from random import choice, random, randint, seed, shuffle
import torch
from .action_tree import *
def tree_to_action_type(tr):
a_type = tr["action_type"]
if a_type == "Build" and "reference_object" in tr:
return "Build-Copy"
else:
return a_type
def tree_to_nodes(tr, all_nodes=False):
if "action" in tr:
return "++".join(
[tr["action"]["action_type"]] + sorted(set(tree_to_nodes_rec(tr, all_nodes, "")))
)
else:
return "++".join([tr["dialogue_type"]] + sorted(set(tree_to_nodes_rec(tr, all_nodes, ""))))
def tree_to_nodes_rec(tr, all_nodes, ancestor_path):
res = []
for k, v in tr.items():
if type(v) == dict:
node_path = ancestor_path + "-" + k
res += [node_path] + tree_to_nodes_rec(v, all_nodes, node_path)
elif all_nodes:
node_path = ancestor_path + ":" + k
res += [node_path]
return res
# data loader that samples training and validation examples
# according to test distribution
class DataLoader:
def __init__(self, args):
seed(1111)
np.random.seed(1111)
# load data
# self.data is a mapping of data split and data type to list of examples
# e.g. self.data['train']['templated'] = [(description, tree) for _ in range(#train_templated)]
# it needs to have at least 'train'-'templated' and 'train'-'rephrased' if args.rephrase_proba > 0
self.data = json.load(open(args.data_file))
if args.train_on_everything:
for spl in ["valid", "test"]:
for data_type in self.data[spl]:
self.data["train"]["rephrases"] += self.data[spl][data_type][:]
self.data["train"]["templated"] += self.data[spl][data_type][:]
print("loaded data")
# organize data so we can resample training set
self.resample_base = "templated"
self.resample_mode = args.resample_mode
self.resample_target = args.resample_type
if args.resample_mode == "none":
self.tree_rep = lambda tr: "CONST"
elif args.resample_mode == "action-type":
self.tree_rep = lambda tr: tree_to_action_type(tr)
elif args.resample_mode == "tree-internal":
self.tree_rep = lambda tr: tree_to_nodes(tr, all_nodes=False)
elif args.resample_mode == "tree-full":
self.tree_rep = lambda tr: tree_to_nodes(tr, all_nodes=True)
else:
raise NotImplementedError
self.data_map = {}
for spl, spl_dict in self.data.items():
self.data_map[spl] = {}
for d_type, d_list in spl_dict.items():
print("mapping", spl, d_type)
self.data_map[spl][d_type] = {}
self.data_map[spl][d_type]["<ALL>"] = d_list[:]
for desc, tr in d_list:
trep = self.tree_rep(tr)
self.data_map[spl][d_type][trep] = self.data_map[spl][d_type].get(trep, [])
self.data_map[spl][d_type][trep] += [(desc, tr)]
# prepare for sampling without replacement
all_keys = [
trep
for spl, spl_dict in self.data_map.items()
for d_type, t_reps in spl_dict.items()
for trep in t_reps
]
all_keys = sorted(set(all_keys))
base_probas = [
len(self.data_map["train"][self.resample_base].get(k, []))
for i, k in enumerate(all_keys)
]
base_probas = [x / sum(base_probas) for x in base_probas]
target_probas = [
len(self.data_map["valid"][self.resample_target].get(k, []))
if base_probas[i] > 0
else 0
for i, k in enumerate(all_keys)
]
target_probas = [x / sum(target_probas) for x in target_probas]
self.sample_keys = all_keys
self.sample_prob = 0.2 * np.array(base_probas) + 0.8 * np.array(target_probas)
self.buffer_size = args.hard_buffer_size
self.buffer_prob = args.hard_buffer_proba
self.hard_buffer = self.data["train"]["templated"][: self.buffer_size]
self.rephrase_prob = args.rephrase_proba
# keep track of which examples have been used
self.data_log = {}
for spl, spl_dict in self.data_map.items():
self.data_log[spl] = {}
for d_type, trep_to_list in spl_dict.items():
self.data_log[spl][d_type] = {}
for trep in trep_to_list:
self.data_log[spl][d_type][trep] = 0
# pre-sample keys
print("pre-computing samples")
self.pre_sampled = np.random.choice(self.sample_keys, 128000, p=self.sample_prob)
self.sample_id = 0
print("pre-computed samples")
def next_batch(self, batch_size, mode, src, resample=False):
batch = []
for i in range(batch_size):
if mode == "train":
if random() < self.buffer_prob:
batch += [choice(self.hard_buffer)]
continue
elif random() < self.rephrase_prob:
src_choice = "rephrases"
else:
src_choice = "templated"
else:
src_choice = src
if mode == "train" or resample:
key_choice = self.pre_sampled[self.sample_id]
self.sample_id = (self.sample_id + 1) % len(self.pre_sampled)
if key_choice not in self.data_log[mode][src_choice]:
key_choice = "<ALL>"
if self.sample_id == 0:
self.pre_sampled = np.random.choice(
self.sample_keys, 128000, p=self.sample_prob
)
else:
key_choice = "<ALL>"
key_index = self.data_log[mode][src_choice][key_choice]
batch += [self.data_map[mode][src_choice][key_choice][key_index]]
# cycle through data and shuffle training data when it runs out
self.data_log[mode][src_choice][key_choice] += 1
if self.data_log[mode][src_choice][key_choice] >= len(
self.data_map[mode][src_choice][key_choice]
):
if mode == "train":
shuffle(self.data_map[mode][src_choice][key_choice])
self.data_log[mode][src_choice][key_choice] = 0
# print('restarts', src_choice, act_choice)
return batch
def update_buffer(self, mistakes):
for i, mistake in enumerate(mistakes):
b_idx = randint(0, self.buffer_size - 1)
self.hard_buffer[b_idx] = mistake
# always use the same resampled validation set
def reset_valid(self):
seed(1111)
np.random.seed(1111)
for d_type, trep_map in self.data_log["valid"].items():
for trep in trep_map:
self.data_log["valid"][d_type][trep] = 0
# utility functions to concatenate chats
def join_chats(desc_action_list):
res = []
for c_ls_ordered, tree in desc_action_list:
if type(c_ls_ordered) == str: # for other data sources
c_list = [c_ls_ordered]
else:
# NOTE: this will be deprectaed soon
# c_list = [" ".join(c_ls_ordered[-i - 1].split()[1:]) for i in range(len(c_ls_ordered))]
c_list = [c_ls_ordered[-i - 1] for i in range(len(c_ls_ordered))]
index_map = {}
tot_words = 0
for c_idx, c in enumerate(c_list):
for w_idx, w in enumerate(c.split()):
index_map[(c_idx, w_idx)] = tot_words
tot_words += 1
tot_words += 1
joined_c = " <s> ".join(c_list)
mapped_tree = map_spans(tree, index_map)
res += [(joined_c, mapped_tree)]
return res
def map_spans(tree, index_map):
for k, v in tree.items():
if is_span(v):
l, (s, e) = v
tree[k] = (index_map[(l, s)], index_map[(l, e)])
elif is_span_list(v):
tree[k] = [(index_map[(l, s)], index_map[(l, e)]) for l, (s, e) in v]
elif is_sub_tree(v):
tree[k] = map_spans(v, index_map)
else:
continue
return tree
# takes list of (description, action_tree) pairs and makes a batch to send to the model
def make_batch(desc_action_list, w2i, cuda=False, sentence_noise=0.0):
processed_list = join_chats(desc_action_list)
sentences = [s.strip() for s, a_tree in processed_list]
tree_list = [a_tree for s, a_tree in processed_list]
# sen_tabs = [['<s>'] + s.split() + ['</s>'] for s in sentences]
sen_tabs = [s.split() for s in sentences]
max_s_len = max([len(s) for s in sen_tabs])
sen_tabs_padded = [s + ["<pad>"] * (max_s_len - len(s)) for s in sen_tabs]
unk_id = w2i["<unk>"]
# each word is replaced by <unk> with probability sentence_noise
sent_ids = torch.LongTensor(
[
[w2i.get(w, unk_id) if random() >= sentence_noise else unk_id for w in s]
for s in sen_tabs_padded
]
)
sent_mask = torch.LongTensor([[0 if w == "<pad>" else 1 for w in s] for s in sen_tabs_padded])
sent_lengths = torch.LongTensor([len(s) for s in sen_tabs])
if cuda:
sent_ids = sent_ids.cuda()
sent_mask = sent_mask.cuda()
sent_lengths = sent_lengths.cuda()
return sent_ids, sent_mask, sent_lengths, tree_list
| craftassist-master | python/base_agent/ttad/ttad_model/emnlp_model/data.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import logging
from collections import OrderedDict
from time import time
import torch
import torch.nn as nn
import copy
from torch.nn.modules.loss import _Loss
from .data import *
class LabelSmoothingBCE(nn.Module):
def __init__(self, smoothing=0.0):
super(LabelSmoothingBCE, self).__init__()
self.criterion = nn.BCEWithLogitsLoss(reduction="none")
self.confidence = 1.0 - smoothing
self.smoothing = smoothing
def forward(self, x, target):
smooth_target = target.clone().masked_fill(target == 1, self.confidence)
smooth_target = smooth_target.masked_fill(target == 0, self.smoothing)
return self.criterion(x, smooth_target)
class LabelSmoothingCE(nn.Module):
def __init__(self, smoothing=0.0):
super(LabelSmoothingCE, self).__init__()
self.smoothing = smoothing
def forward(self, x, target):
lprobs = torch.log_softmax(x, dim=-1)
nll_loss = -lprobs.gather(dim=-1, index=target.unsqueeze(-1)).squeeze(-1)
smooth_loss = -lprobs.clamp(0, 100).sum(
dim=-1
) # hacky way to deal with sentence position padding
smooth_val = self.smoothing / x.size(-1)
loss = (1.0 - self.smoothing) * nll_loss + smooth_val * smooth_loss
scores = loss
return scores
class TreeLoss(_Loss):
def __init__(self, args):
super(TreeLoss, self).__init__()
self.label_smoothing = args.label_smoothing
if args.label_smoothing > 0:
self.bce_loss = LabelSmoothingBCE(args.label_smoothing)
self.ce_loss = LabelSmoothingCE(args.label_smoothing)
else:
self.bce_loss = nn.BCEWithLogitsLoss(reduction="none")
self.ce_loss = nn.CrossEntropyLoss(reduction="none")
def forward(self, node_list):
# go through list of node scores, labels, and per-batch activity
# to compute loss and accuracy
# internal nodes: (node_scores, (node_labels, node_active))
pres_list = []
span_list = []
cat_list = []
for node in node_list:
pres_scores = node.out["pres_score"]
pres_labels = node.labels["pres_labels"].type_as(pres_scores)
node_active = node.active.type_as(pres_scores)
pres_loss = self.bce_loss(pres_scores, pres_labels) * node_active
# print('>>>>>>', node.name)
# print(node.name, pres_scores, pres_labels)
pres_accu = ((pres_scores > 0) == (pres_labels > 0.5)).type_as(pres_scores)
# print(pres_accu)
pres_list += [(pres_loss, pres_accu, node_active)]
if node.node_type == "internal":
continue
elif node.node_type in ["categorical-single", "categorical-set"]:
# FIXME: currently predicting single value for set
cat_scores = node.out["cat_score"]
cat_labels = node.labels["cat_labels"]
cat_loss = self.ce_loss(cat_scores, cat_labels) * node_active * pres_labels
cat_accu = (1 - pres_labels) + pres_labels * (
cat_scores.argmax(dim=-1) == cat_labels
).type_as(pres_scores)
cat_list += [(cat_loss, cat_accu, node_active)]
elif node.node_type == "span-single":
span_pre_scores = node.out["span_score"] # B x T x T
span_pre_labels = node.labels["span_labels"] # B x 2
span_scores = span_pre_scores.view(span_pre_scores.shape[0], -1)
span_labels = (
span_pre_scores.shape[-1] * span_pre_labels[:, 0] + span_pre_labels[:, 1]
)
span_loss = self.ce_loss(span_scores, span_labels) * node_active * pres_labels
span_accu = (1 - pres_labels) + pres_labels * (
span_scores.argmax(dim=-1) == span_labels
).type_as(pres_scores)
span_list += [(span_loss, span_accu, node_active)]
else:
# continue
# TODO fix span-set and categorical-set
raise NotImplementedError
# from pprint import pprint
# pprint(pres_list, width=230)
pres_loss = torch.cat([l.unsqueeze(1) for l, a, act in pres_list], dim=1)
pres_loss = pres_loss.sum(dim=1)
pres_accu = torch.cat(
[((a * act) == act).unsqueeze(1).type_as(a) for l, a, act in pres_list], dim=1
)
pres_accu = pres_accu.sum(dim=1) == len(pres_list)
# categorical
cat_loss = torch.cat([l.unsqueeze(1) for l, a, act in cat_list], dim=1)
cat_loss = cat_loss.sum(dim=1)
cat_accu = torch.cat(
[((a * act) == act).unsqueeze(1).type_as(a) for l, a, act in cat_list], dim=1
)
cat_accu = cat_accu.sum(dim=1) == len(cat_list)
# spans
span_loss = torch.cat([l.unsqueeze(1) for l, a, act in span_list], dim=1)
span_loss = span_loss.sum(dim=1)
span_accu = torch.cat(
[((a * act) == act).unsqueeze(1).type_as(a) for l, a, act in span_list], dim=1
)
span_accu = span_accu.sum(dim=1) == len(span_list)
# aggregate
res = OrderedDict()
res["loss"] = span_loss + pres_loss + cat_loss
res["accuracy"] = (span_accu.long() + pres_accu.long() + cat_accu.long()) == 3
res["presence_loss"] = pres_loss
res["categorical_loss"] = cat_loss
res["span_loss"] = span_loss
res["presence_accuracy"] = pres_accu
res["categorical_accuracy"] = cat_accu
res["span_accuracy"] = span_accu
# from pprint import pprint
# pprint(res, width=230)
return res
# send a tensor or nested lists of tensors to cpu
def to_cpu(obj):
if type(obj) in [list, tuple]:
return [to_cpu(o) for o in obj]
else:
return obj.detach().cpu()
# runs the model over provided data. trains if optimizer is not None
def run_epoch(data_loader, model, loss, w2i, args, mode="train", data_type="", optimizer=None):
st_time = time()
n_batches = args.batches_per_epoch if mode == "train" else 4
tot_ct = 0
acc_ct = 0
global_dct = OrderedDict()
local_dct = OrderedDict()
res_list = []
for i in range(n_batches):
st_time = time()
batch_list = data_loader.next_batch(args.batch_size, mode, data_type)
# print("time for next batch: %r" % (time() - st_time))
st_time = time()
batch_list_cp = copy.deepcopy(batch_list)
# print("time for copy: %r" % (time() - st_time))
st_time = time()
# make batch on the deepcopy
s_ids, s_mask, s_len, t_list = make_batch(
batch_list_cp,
w2i,
args.cuda,
sentence_noise=args.sentence_noise if mode == "train" else 0.0,
)
# print("time for make batch: %r" % (time() - st_time))
st_time = time()
# make labels and active mask
active_nodes = model.make_labels(t_list, args.cuda)
# print("time for make labels: %r" % (time() - st_time))
st_time = time()
# run model
active_nodes_scores = model(s_ids, s_mask, s_len, recursion=args.recursion)
# print("time for fwd pass: %r" % (time() - st_time))
st_time = time()
# compute loss
loss_dct = loss(active_nodes)
# print("time for computing loss: %r" % (time() - st_time))
st_time = time()
loss_val = loss_dct["loss"].sum() / loss_dct["loss"].shape[0]
# print("time for computing loss val: %r" % (time() - st_time))
st_time = time()
if optimizer is not None:
optimizer.zero_grad()
loss_val.backward(retain_graph=True)
# print("time for loss backward: %r" % (time() - st_time))
st_time = time()
optimizer.step()
# print("time for opt step: %r" % (time() - st_time))
st_time = time()
data_loader.update_buffer(
[
example
for j, example in enumerate(batch_list)
if loss_dct["accuracy"][j].item() == 0
]
)
# print("time for update buffer: %r" % (time() - st_time))
for k, v in loss_dct.items():
global_dct[k] = global_dct.get(k, 0.0) + v.sum().item()
local_dct[k] = local_dct.get(k, 0.0) + v.sum().item()
tot_ct += loss_dct["loss"].shape[0]
acc_ct += loss_dct["loss"].shape[0]
# print the stats
if i % args.print_freq == 0:
tot_loss = global_dct["loss"]
tot_accu = global_dct["accuracy"]
logging.info("---- %d" % (i,))
print("---- %d" % (i,))
print(
"GLOBAL --- loss %.2f --- accu %d of %d --- time %.1f"
% (global_dct["loss"] / tot_ct, global_dct["accuracy"], tot_ct, time() - st_time)
)
print(
"LOCAL --- loss %.2f --- accu: full %d of %d -- intern %d -- cat %d -- span %d"
% (
local_dct["loss"] / acc_ct,
local_dct["accuracy"],
acc_ct,
local_dct["presence_accuracy"],
local_dct["categorical_accuracy"],
local_dct["span_accuracy"],
)
)
acc_ct = 0
for k in local_dct:
local_dct[k] = 0.0
print(
"EPOCH GLOBAL --- loss %.2f --- accu %d of %d = %.2f --- time %.1f"
% (
global_dct["loss"] / tot_ct,
global_dct["accuracy"],
tot_ct,
global_dct["accuracy"] / tot_ct,
time() - st_time,
)
)
logging.info(
"EPOCH GLOBAL --- loss %.2f --- accu %d of %d = %.2f --- time %.1f"
% (
global_dct["loss"] / tot_ct,
global_dct["accuracy"],
tot_ct,
global_dct["accuracy"] / tot_ct,
time() - st_time,
)
)
# end-to-end prediction
def predict_tree(model, sentence_list, w2i, args):
s_ids, s_mask, s_len, t_list = make_batch(
[(sentence_list, {})], w2i, args.cuda, sentence_noise=0.0
)
tree = model.predict_tree(s_ids, s_mask, s_len, args.recursion)
# map span indices back
if type(sentence_list) == str:
c_list = [sentence_list]
else:
# c_list = [" ".join(sentence_list[-i - 1].split()[1:]) for i in range(len(sentence_list))]
c_list = [sentence_list[-i - 1] for i in range(len(sentence_list))]
index_map = {}
tot_words = 0
for c_idx, c in enumerate(c_list):
for w_idx, w in enumerate(c.split()):
index_map[tot_words] = (c_idx, w_idx)
tot_words += 1
tot_words += 1
tree = reverse_map_spans(tree, index_map)
return tree
def reverse_map_spans(tree, span_map):
for k, v in tree.items():
if is_span(v):
l, (s, e) = v
l1, ls = span_map[s] if s in span_map else span_map[s + 1]
l2, le = span_map[e] if e in span_map else span_map[e - 1]
if l2 > l1:
le = ls + 1
tree[k] = (l1, (ls, le))
elif is_sub_tree(v):
tree[k] = reverse_map_spans(v, span_map)
else:
continue
return tree
def tree_equal(ground_truth, prediction, only_internal=False):
ground_truth.pop("has_attribute", None)
prediction.pop("has_attribute", None)
is_eq = all([k in ground_truth for k in prediction]) and all(
[k in prediction for k in ground_truth]
)
if not is_eq:
return is_eq
for k, v in ground_truth.items():
if only_internal:
if type(v) == dict: # internal node accuracy
is_eq = is_eq and tree_equal(v, prediction[k], only_internal)
else:
if type(v) == dict: # internal node accuracy
is_eq = is_eq and tree_equal(v, prediction[k])
elif type(v) == str:
is_eq = is_eq and (v == prediction[k])
elif type(v) in [list, tuple]:
if len(v) == 2 and type(v[0]) == int:
a, (b, c) = prediction[k] # prediction
# y, z = v
x, (y, z) = v # ground truth
is_eq = is_eq and ((a, b, c) == (x, y, z))
return is_eq
def compute_accuracy(model, examples, w2i, args, only_internal=False):
predicted = [
(sentence, ground_truth, predict_tree(model, sentence, w2i, args))
for sentence, ground_truth in examples
]
num_correct = len(
[
sentence
for sentence, ground_truth, prediction in predicted
if tree_equal(ground_truth, prediction, only_internal)
]
)
return num_correct / len(predicted)
def compute_accuracy_per_action_type(model, examples, w2i, args, only_internal=False):
predicted = [
(sentence, ground_truth, predict_tree(model, sentence, w2i, args))
for sentence, ground_truth in examples
]
action_type_stats = {}
for sentence, ground_truth, prediction in predicted:
action_type = ground_truth["action_type"]
# compute accuracy for each action type
if action_type not in action_type_stats:
action_type_stats[action_type] = [0.0, 0.0]
action_type_stats[action_type][1] += 1 # total
if tree_equal(ground_truth, prediction, only_internal):
action_type_stats[action_type][0] += 1 # correct
out = {}
for key in action_type_stats.keys():
val = action_type_stats[key][0] / action_type_stats[key][1]
out[key] = "{0:.3f}".format(val)
return out
def compute_stats(
ground_truth,
prediction,
total_internal,
correct_internal,
total_str,
correct_str,
total_span,
correct_span,
):
# only by value type
for k, v in ground_truth.items():
if type(v) == dict: # internal node accuracy
total_internal += 1
if k in prediction:
if type(prediction[k]) == dict:
# true positive
correct_internal += 1
(
total_internal,
correct_internal,
total_str,
correct_str,
total_span,
correct_span,
) = compute_stats(
v,
prediction[k],
total_internal,
correct_internal,
total_str,
correct_str,
total_span,
correct_span,
)
else:
(
total_internal,
correct_internal,
total_str,
correct_str,
total_span,
correct_span,
) = compute_stats(
v,
{},
total_internal,
correct_internal,
total_str,
correct_str,
total_span,
correct_span,
)
elif type(v) == str:
total_str += 1
if k not in prediction:
continue
if type(prediction[k]) == str:
correct_str += 1
elif type(v) in [list, tuple]:
total_span += 1
if k not in prediction:
continue
if type(prediction[k]) in [list, tuple]:
correct_span += 1
return total_internal, correct_internal, total_str, correct_str, total_span, correct_span
def compute_precision_recall(model, examples, w2i, args):
predicted = [
(sentence, ground_truth, predict_tree(model, sentence, w2i, args))
for sentence, ground_truth in examples
]
final_stats = {}
final_stats["intern"] = [0.0, 0.0, 0.0]
final_stats["str"] = [0.0, 0.0, 0.0]
final_stats["span"] = [0.0, 0.0, 0.0]
micro_stats_total = {}
micro_stats_total["intern"] = [0.0, 0.0, 0.0]
micro_stats_total["str"] = [0.0, 0.0, 0.0]
micro_stats_total["span"] = [0.0, 0.0, 0.0]
for sentence, ground_truth, prediction in predicted: # each example
(
total_intern_recall,
tp_intern_recall,
total_str_recall,
tp_str_recall,
total_span_recall,
tp_span_recall,
) = compute_stats(ground_truth, prediction, 0, 0, 0, 0, 0, 0)
(
total_intern_prec,
tp_intern_prec,
total_str_prec,
tp_str_prec,
total_span_prec,
tp_span_prec,
) = compute_stats(prediction, ground_truth, 0, 0, 0, 0, 0, 0)
stats_map = {}
stats_map["intern"] = [
tp_intern_prec,
total_intern_prec,
tp_intern_recall,
total_intern_recall,
]
stats_map["str"] = [tp_str_prec, total_str_prec, tp_str_recall, total_str_recall]
stats_map["span"] = [tp_span_prec, total_span_prec, tp_span_recall, total_span_recall]
# compute prec, recall and f1
vals = [0, 0, 0]
for key, val in stats_map.items():
# sum up tp, fp and fn for each key
tp = val[0] # or val[2]
fp = val[1] - val[0] # total_prec - tp
fn = val[3] - val[0] # total_recall - tp
micro_stats_total[key] = [x + y for x, y in zip(micro_stats_total[key], [tp, fp, fn])]
# now compute macro stats
if val[0] == 0 and val[1] == 0 and val[3] == 0:
vals = [1.0, 1.0, 1.0]
elif val[0] == 0 and (val[1] > 0 or val[3] > 0):
vals = [0.0, 0.0, 0.0]
else:
precision = val[0] / val[1]
recall = val[2] / val[3]
f1 = (2 * precision * recall) / (precision + recall)
vals = [precision, recall, f1]
final_stats[key] = [x + y for x, y in zip(final_stats[key], vals)]
macro_stats = {
key: ["{0:.3f}".format(item / len(examples)) for item in val]
for key, val in final_stats.items()
}
# compute micro stats
micro_stats = {}
for key, val in micro_stats_total.items():
tp, fp, fn = val
if tp == 0 and fp == 0 and fn == 0:
vals = [1.0, 1.0, 1.0]
elif tp == 0.0 and (fp > 0 or fn > 0):
vals = [0.0, 0.0, 0.0]
else:
precision = tp / (tp + fp)
recall = tp / (tp + fn)
f1 = (2 * precision * recall) / (precision + recall)
vals = [precision, recall, f1]
micro_stats[key] = ["{0:.3f}".format(x) for x in vals]
return macro_stats, micro_stats
| craftassist-master | python/base_agent/ttad/ttad_model/emnlp_model/my_optim.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
from copy import deepcopy
# from pprint import pprint
import csv
import json
from spacy.lang.en import English
tokenizer = English().Defaults.create_tokenizer()
def word_tokenize(st):
return [(x.text, x.idx) for x in tokenizer(st)]
rephrases = []
for j in range(5):
with open("rephrase_%d.csv" % (j,)) as csvfile:
g_reader = csv.reader(csvfile)
for i, row in enumerate(g_reader):
if i > 0:
rephrases += [row[-2:]]
brackets = [("(", ")"), ("{", "}"), ("[", "]"), ("*", "*"), ("$", "$"), ("#", "#")]
bracket_chars = ["(", ")", "{", "}", "[", "]", "*", "$", "#"]
def remove_brackets(br_sen):
br_found = []
for bs, be in brackets:
if bs in br_sen:
idx_s = br_sen.index(bs)
br_right = br_sen[idx_s + 1 :]
# idx_s -= sum([c in bracket_chars for c in br_sen[:idx_s]])
idx_e = br_right.index(be)
# idx_e -= sum([c in bracket_chars for c in br_sen[:idx_e]])
br_pre = br_right[:idx_e]
if False:
br_str = " ".join([x[0] for x in word_tokenize(br_pre)])
else:
br_str = br_pre
br_found += [(idx_s + 1, idx_s + 1 + idx_e, br_str, bs)]
no_br = br_sen
for c in bracket_chars:
no_br = no_br.replace(c, " ")
sen_ls = [x for x in word_tokenize(no_br) if x[0].strip() != ""]
word_spans = []
for id_s, id_e, br_st, b in br_found:
idw_s = [n for w, n in sen_ls].index(id_s)
if sen_ls[-1][1] <= id_e:
idw_e = len(sen_ls) - 1
else:
idw_e = [n > id_e for w, n in sen_ls].index(True) - 1
word_spans += [(idw_s, idw_e, b, br_st)]
return (" ".join([w for w, n in sen_ls]), word_spans)
rep_processed = []
for i, (orig, rep) in enumerate(rephrases):
try:
rep_processed += [(orig, remove_brackets(orig), remove_brackets(rep))]
except:
print("MISSED", i)
# make trees for rephrased data
orig_valid = json.load(open("../bracketted_valid.json"))
rephrases = rep_processed
orig_dict = dict([(x[1], x) for x in orig_valid])
rephrase_trees = []
for i, (orig_br, (orig_nobr, orig_br_lst), (rep_nobr, rep_br_lst)) in enumerate(rephrases):
try:
orig_valid_nobr, orig_valid_br, orig_valid_br_lst, orig_valid_tree = orig_dict[orig_br]
rep_tree = deepcopy(orig_valid_tree)
list(rep_tree.values())[0]["description"] = rep_nobr
br_to_span = dict([(b, (id_b, id_e)) for id_b, id_e, b, _ in rep_br_lst])
for b, (node_path, span) in orig_valid_br_lst:
node = rep_tree
tag_path = node_path.split(" > ")
for k in tag_path[:-1]:
node = node[k]
node[tag_path[-1]] = br_to_span[b]
rephrase_trees += [(rep_nobr, rep_tree)]
except:
print("MISSED", i)
json.dump(rephrase_trees, open("../valid_rephrase_02_15.json", "w"))
| craftassist-master | python/base_agent/ttad/ttad_model/processing_scripts/read_rephrased.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import json
from pprint import pprint
from random import choice
from models import *
def read_generations(f_name):
res = []
f = open(f_name)
for line in f:
if line[0] == "{":
try:
a_tree = ActionTree()
a_tree_dict = json.loads(line.strip())
a_desc = list(a_tree_dict.values())[0]["description"]
del list(a_tree_dict.values())[0]["description"]
a_tree.read_tree_dict(a_tree_dict)
a_node = a_tree.root
read_dict(a_node, a_tree)
a_td = sorted(
write_top_down(a_node, len(a_desc.split())), key=lambda x: len(x["context"])
)
a_dfs = write_dfs(a_node)
a_mrf = write_mrf(a_node)
res += [
{
"action_description": a_desc,
"action_tree_dict": a_tree_dict,
"action_tree": a_tree,
"action_top_down": a_td,
"action_s2s_dfs": a_dfs,
"action_global_mrf": a_mrf,
}
]
except Exception as e:
print(e)
print(line)
break
f.close()
return res
generated_data = read_generations("example_trees.txt")
pprint(choice(generated_data), width=248)
| craftassist-master | python/base_agent/ttad/ttad_model/processing_scripts/read_data.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import json
import matplotlib.pyplot
import numpy as np
from scipy.ndimage import imread
import visdom
import pickle
# vis = visdom.Visdom(server ='http://localhost')
home_dir = '/private/home/aszlam'
f = open(home_dir + '/minecraft_specs/block_images/css_chunk.txt')
r = f.readlines()
l = r[0]
q = l.split('.items-28-')
g = open(home_dir + '/minecraft_specs/block_images/html_chunk.txt')
s = g.readlines()
name_to_bid = {}
bid_to_name = {}
for line in s:
c = line.find('"id">')
if c > 0:
d = line.find('<', c)
idlist = line[c+5:d].split(':')
if len(idlist) == 1:
idlist.append('0')
c = line.find('"name">')
if c > 0:
d = line.find('<', c)
name = line[c+7:d].lower()
bid = (int(idlist[0]), int(idlist[1]))
name_to_bid[name] = bid
bid_to_name[bid] = name
bid_to_offsets = {}
for line in q:
s = line.find('png)')
if s > 0:
t = line.find('no-')
offsets = line[s+5:t].replace('px','').split()
int_offsets = [int(offsets[0]), int(offsets[1])]
t = line.find('{')
ids = line[:t].split('-')
bid = (int(ids[0]), int(ids[1]))
bid_to_offsets[bid] = int_offsets
big_image = matplotlib.pyplot.imread(home_dir + '/minecraft_specs/block_images/all_blocks')
bid_to_image = {}
name_to_image = {}
for name in name_to_bid:
bid = name_to_bid[name]
offsets = bid_to_offsets[bid]
small_image = big_image[-offsets[1]:-offsets[1]+32,
-offsets[0]:-offsets[0]+32, :].copy()
bid_to_image[bid] = small_image
name_to_image[name] = small_image
out = {'bid_to_image':bid_to_image,
'name_to_image':name_to_image,
'bid_to_name':bid_to_name,
'name_to_bid':name_to_bid}
f.close()
g.close()
f = open(home_dir + '/minecraft_specs/block_images/block_data','wb')
pickle.dump(out, f)
f.close()
COLOR_NAMES = ['aqua', 'black', 'blue', 'fuchsia', 'green', 'gray', 'lime',
'maroon', 'navy', 'olive', 'purple', 'red', 'silver', 'teal',
'white', 'yellow', 'orange', 'brown', 'sienna', 'pink','light yellow',
'dark yellow','dark yellow', 'gold', 'gold']
COLORS = np.array((
(0.0, 1.0, 1.0),
(0.0, 0.0, 0.0),
(0.0, 0.0, 1.0),
(1.0, 0.0, 1.0),
(0.0, .5, 0.0),
(.5, .5, .5),
(0.0, 1.0, 0.0),
(.5, 0.0, 0.0),
(0.0, 0.0, .5),
(.5, .5, 0.0),
(.5, 0, .5),
(1.0, 0.0, 0.0),
(.75, .75, .75),
(0.0, .5, .5),
(1.0, 1.0, 1.0),
(1.0, 1.0, 0.0),
(1.0, .65, 0.0),
(139/255, 69/255, 19/255),
(160/255, 82/255, 45/255),
(255/255, 192/255, 203/255),
(200/255, 200/255, 50/255),
(200/255, 200/255, 50/255),
(255/255, 255/255, 130/255),
(255/255, 215/255, 40/255),
(255/255, 215/255, 0/255)))
COLOR_NORMS = np.linalg.norm(COLORS, axis=1)**2
CMAP = {
'aqua': 'blue',
'black': 'black',
'blue': 'blue',
'fuchsia': 'purple',
'green': 'green',
'gray': 'gray',
'lime': 'green',
'maroon': 'red',
'navy': 'blue',
'olive': 'green',
'purple': 'purple',
'red': 'red',
'pink': 'pink',
'silver': 'silver',
'teal': 'blue',
'white': 'white',
'yellow': 'yellow',
'orange': 'orange',
'brown': 'brown',
'sienna': 'brown',
'gold': 'yellow',
'light yellow':'yellow',
'dark yellow':'yellow'
}
def get_colors(im):
cim = im[:,:,:3].astype('float32')
cim = cim.reshape(1024,3)
alpha = im[:,:,3].astype('float32')
alpha = alpha.reshape(1024)
cim /= 255
alpha /= 255
dists = np.zeros((1024, COLORS.shape[0]))
for i in range(1024):
for j in range(COLORS.shape[0]):
dists[i,j] = ((COLORS[j] - cim[i])**2).sum()
idx = dists.argmin(axis=1)
colors = {}
for i in range(1024):
if alpha[i] >.2:
if colors.get(COLOR_NAMES[idx[i]]) is None:
colors[COLOR_NAMES[idx[i]]] = 1
else:
colors[COLOR_NAMES[idx[i]]] += 1
if alpha.mean() < .4:
colors['translucent'] = True
return colors
name_to_colors = {}
colors_to_name = {}
name_to_simple_colors = {}
simple_colors_to_name = {}
# for i in name_to_image:
# c = get_colors(name_to_image[i])
# for j in c:
# if c[j] > 100:
# if name_to_colors.get(i) is None:
# name_to_colors[i] = [j]
# else:
# name_to_colors[i].append(j)
# if name_to_simple_colors.get(i) is None:
# name_to_simple_colors[i] = [CMAP[j]]
# else:
# name_to_simple_colors[i].append(CMAP[j])
# if colors_to_name.get(j) is None:
# colors_to_name[j] = [i]
# else:
# colors_to_name[j].append(i)
# if simple_colors_to_name.get(CMAP[j]) is None:
# simple_colors_to_name[CMAP[j]] = [i]
# else:
# simple_colors_to_name[CMAP[j]].append(i)
# out = {'name_to_colors':name_to_colors,
# 'name_to_simple_colors':name_to_simple_colors,
# 'colors_to_name':colors_to_name,
# 'simple_colors_to_name':simple_colors_to_name,
# 'cmap':CMAP}
# f = open(home_dir + '/minecraft_specs/block_images/color_data','wb')
# pickle.dump(out, f)
# f.close()
with open(home_dir + '/minecraft_specs/block_images/block_property_data.json') as f:
block_property_data = json.load(f)
name_to_properties = {}
properties_to_name = {}
for name in name_to_image:
if name in block_property_data:
properties = block_property_data[name]['properties']
for property in properties:
if name_to_properties.get(name) is None:
name_to_properties[name] = [property]
else:
name_to_properties[name].append(property)
if properties_to_name.get(property) is None:
properties_to_name[property] = [name]
else:
properties_to_name[property].append(name)
out = {'name_to_properties': name_to_properties,
'properties_to_name': properties_to_name}
f = open(home_dir + '/minecraft_specs/block_images/block_property_data','wb')
pickle.dump(out, f)
f.close()
with open(home_dir + '/minecraft_specs/block_images/mob_property_data.json') as f:
mob_property_data = json.load(f)
name_to_properties = {}
properties_to_name = {}
for name in name_to_image:
if name in mob_property_data:
properties = mob_property_data[name]['properties']
for property in properties:
if name_to_properties.get(name) is None:
name_to_properties[name] = [property]
else:
name_to_properties[name].append(property)
if properties_to_name.get(property) is None:
properties_to_name[property] = [name]
else:
properties_to_name[property].append(name)
out = {'name_to_properties': name_to_properties,
'properties_to_name': properties_to_name}
f = open(home_dir + '/minecraft_specs/block_images/mob_property_data','wb')
pickle.dump(out, f)
f.close()
'''
COLORS = {
'aqua': np.array((0.0, 1.0, 1.0)),
'black': np.array((0.0, 0.0, 0.0)),
'blue': np.array((0.0, 0.0, 1.0)),
'fuchsia': np.array((1.0, 0.0, 1.0)),
'green': np.array((0.0, .5, 0.0)),
'gray': np.array((.5, .5, .5)),
'lime': np.array((0.0, 1.0, 0.0)),
'maroon': np.array((.5, 0.0, 0.0)),
'navy': np.array((0.0, 0.0, .5)),
'olive': np.array((.5, .5, 0.0)),
'purple': np.array((.5, 0, .5)),
'red': np.array((1.0, 0.0, 0.0)),
'silver': np.array((.75, .75, .75)),
'teal': np.array((0.0, .5, .5)),
'white': np.array((1.0, 1.0, 1.0)),
'yellow': np.array((1.0, 1.0, 0.0)),
'orange': np.array((1.0, .65, 0.0)),
'brown': np.array((139/255 69/255 19/255)),
'sienna': np.array((160/255, 82/255, 45/255)),
'pink': np.array((255/255, 192/255, 203/255))
}
'''
| craftassist-master | minecraft_specs/block_images/read_images.py |
# define the grammar
# cf https://docs.google.com/presentation/d/1gzC878kkIgDL015c-kLFXEBc1SAuq_XOsheQowsyIEA/edit?usp=sharing
#####
## define node types
class InternalNode(Object):
def __init__(self, name):
self.name = name
self.node_choices = []
self.intern_node_children = {}
self.categorical_children = {}
seld.span_children = {}
self.node_value = False
class SpanLeaf(Object):
def __init__(self):
self.span_value = False
class CategoricalLeaf(Object):
def __init__(self):
self.choices = []
self.cat_value = False
#####
# define leaves
class LocationTypeLeaf(CategoricalLeaf):
def __init__(self, absolute):
super(LocationTypeLeaf).__init__(self)
self.choices += ['Coordinates', 'AgentPos',
'SpeakerPos', 'SpeakerLook']
if not self.absolute:
self.choices += ['BlockObject', 'Mob']
class ConditionTypeLeaf(CategoricalLeaf):
def __init__(self):
super(ConditionTypeLeaf).__init__(self)
self.choices += ['AdjacentToBlockType', 'Never']
class RepeatTypeLeaf(CategoricalLeaf):
def __init__(self):
super(RepeatTypeLeaf).__init__(self)
self.choices += ['FOR', 'ALL']
class RepeatDirectionLeaf(CategoricalLeaf):
def __init__(self):
super(RepeatDirectionLeaf).__init__(self)
self.choices += ['RIGHT', 'UP'] # TODO: check with Kavya
class RelativeDirectionLeaf(CategoricalLeaf):
def __init__(self):
super(RelativeDirectionLeaf).__init__(self)
self.choices += ['LEFT' , 'RIGHT', 'UP', 'DOWN',
'FRONT', 'BACK', 'AWAY']
#####
# build tree
def make_repeat_node(name):
repeat = InternalNode(name)
repeat.node_choices = [True, False]
repeat.categorical_children['repeat_type'] = RepeatTypeLeaf()
repeat.categorical_children['repeat_dir'] = RepeatTypeLeaf()
repeat.span_children['repeat_count'] = SpanLeaf()
return repeat
def make_location_node(loc_name, ref_name,
ref_loc_name, repeat_name):
repeat = make_repeat_node(repeat_name)
lr_location = InternalNode(ref_loc_name)
lr_location.node_choices = [True, False]
lr_location.categorical_children['location_type'] = LocationTypeLeaf(True)
lr_location.span_children['coordinates'] = SpanLeaf()
l_ref_object = InternalNode(ref_name)
l_ref_object.node_choices = [True, False]
l_ref_object.intern_node_children[ref_loc_name] = lr_location
l_ref_object.intern_node_children[repeat_name] = lr_repeat
l_ref_object.span_children['has_name_'] = SpanLeaf()
l_ref_object.span_children['has_colour_'] = SpanLeaf()
l_ref_object.span_children['has_size_'] = SpanLeaf()
location = InternalNode(loc_name)
location.node_choices = [True, False]
location.intern_node_children[ref_name] = l_ref_object
location.categorical_children['location_type'] = LocationTypeLeaf(False)
location.categorical_children['relative_direction'] = RelativeDirectionLeaf()
location.span_children['coordinates'] = SpanLeaf()
return location
def make_full_action()
# ACTION_LOCATION
action_location = make_location_node('action_location', 'al_ref_object',
'alr_location', 'alr_repeat')
# STOP_CONDITION
stop_condition = InternalNode('stop_condition')
stop_condition.node_choices = [True, False]
stop_condition.categorical_children['condition_type'] = ConditionTypeLeaf(True)
stop_condition.span_children['block_type'] = SpanLeaf()
# SCHEMATIC
s_repeat = make_repeat_node('s_repeat')
schematic = InternalNode('schematic')
schematic.node_choices = [True, False]
schematic.intern_node_children['s_repeat'] = s_repeat
for k in ["has_block_type_" , "has_name_", "has_attribute_", "has_size_" , "has_orientation_",
"has_thickness_", "has_colour_", "has_height_", "has_length_", "has_radius_",
"has_slope_", "has_width_", "has_base_", "has_distance_"]:
schematic.span_children[k] = SpanLeaf()
# ACTION_REPEAT
action_repeat = make_repeat_node('action_repeat')
# ACTION_REF_OBJECT
ar_location = make_location_node('ar_location', 'arl_ref_object',
'arlr_location', 'arlr_repeat')
ar_repeat = InternalNode('ar_repeat')
ar_repeat.node_choices = [True, False]
ar_repeat.categorical_children['repeat_type'] = RepeatTypeLeaf()
ar_repeat.categorical_children['repeat_dir'] = RepeatTypeLeaf()
ar_repeat.span_children['repeat_count'] = SpanLeaf()
action_ref_object = InternalNode('action_ref_object')
action_ref_object.node_choices = [True, False]
action_ref_object.intern_node_children['ar_location'] = ar_location
action_ref_object.intern_node_children['ar_repeat'] = ar_repeat
action_ref_object.span_children['has_name_'] = SpanLeaf()
action_ref_object.span_children['has_colour_'] = SpanLeaf()
action_ref_object.span_children['has_size_'] = SpanLeaf()
# ROOT
action = InternalNode('action')
action.node_value = "Noop"
action.node_choices = ["Build", "Noop", "Span", "Fill",
"Destroy", "Move", "Undo", "Stop",
"Dig", "Tag", "FreeBuild", "Answer"]
action.intern_node_children['action_location'] = action_location
action.intern_node_children['stop_condition'] = stop_condition
action.intern_node_children['schematic'] = schematic
action.intern_node_children['action_repeat'] = action_repeat
action.intern_node_children['action_ref_object'] = action_ref_object
action.span_children['tag'] = SpanLeaf()
action.span_children['has_size_'] = SpanLeaf()
action.span_children['has_length_'] = SpanLeaf()
action.span_children['has_depth_'] = SpanLeaf()
action.span_children['has_width_'] = SpanLeaf()
return action
| craftassist-master | acl2020_submission/writeup/figures/acl_tree.py |
# 'location', 'move'
# 'reference_object', 'spawn'
# 'reference_object', 'destroy'
# 'schematic', 'dig'
# 'reference_object', fill
# 'reference_object', 'OtherAction'
# 'location', 'OtherAction'
# 'target_action_type', 'stop'
# 'target_action_type', 'resume'
# 'target_action_type', 'undo'
LOCATION_RADIO = [
{"text": "Not specified", "key": None, "tooltip": "The location information is missing."},
{
"text": "The location is represented using an indefinite noun like 'there' or 'over here'",
"key": "CONTAINS_COREFERENCE",
"tooltip": "e.g. 'there', 'here', 'over there' etc",
},
{
"text": "Exact numerical coordinates are given",
"key": "coordinates_check",
"tooltip": "Exact numeric coordinates are specified.",
"next": [
{
"text": "Click on all words representing the coordinates",
"key": "yes.coordinates",
"span": True,
"tooltip": "e.g. in 'make a box at 4 , 5 , 6' select all: '4 , 5 , 6'",
}
],
},
{
"text": "Where the speaker is looking",
"key": "SPEAKER_LOOK",
"tooltip": "e.g. 'where I am looking'",
},
{
"text": "Somewhere relative to where the speaker is looking",
"key": "SPEAKER_LOOK_REL",
"tooltip": "e.g. 'in front of where I am looking'",
"next": [
{
"text": "Where (which direction) in relation to where the speaker is looking?",
"key": "relative_direction",
"radio": [
{"text": "Left", "key": "LEFT"},
{"text": "Right", "key": "RIGHT"},
{"text": "Above", "key": "UP"},
{"text": "Below", "key": "DOWN"},
{"text": "In front", "key": "FRONT"},
{"text": "Behind", "key": "BACK"},
{"text": "Away from", "key": "AWAY"},
{"text": "Nearby or close to", "key": "NEAR"},
{"text": "Around", "key": "AROUND"},
{"text": "Exactly at", "key": "EXACT"},
],
}
],
},
{
"text": "Where the speaker is standing",
"key": "SPEAKER_POS",
"tooltip": "e.g. 'by me', 'where I am', 'where I am standing'",
},
{
"text": "Somewhere relative to where the speaker is standing",
"key": "SPEAKER_POS_REL",
"tooltip": "e.g. 'in front of where I am', 'behind me'",
"next": [
{
"text": "Where (which direction) in relation to where the speaker is standing?",
"key": "relative_direction",
"radio": [
{"text": "Left", "key": "LEFT"},
{"text": "Right", "key": "RIGHT"},
{"text": "Above", "key": "UP"},
{"text": "Below", "key": "DOWN"},
{"text": "In front", "key": "FRONT"},
{"text": "Behind", "key": "BACK"},
{"text": "Away from", "key": "AWAY"},
{"text": "Nearby or close to", "key": "NEAR"},
{"text": "Around", "key": "AROUND"},
{"text": "Exactly at", "key": "EXACT"},
],
}
],
},
{
"text": "Where the assistant is standing",
"key": "AGENT_POS",
"tooltip": "e.g. 'by you', 'where you are', 'where you are standing'",
},
{
"text": "Somewhere relative to where the assistant is standing",
"key": "AGENT_POS_REL",
"tooltip": "e.g. 'in front of you', 'behind you'",
"next": [
{
"text": "Where (which direction) in relation to where the assistant is standing?",
"key": "relative_direction",
"radio": [
{"text": "Left", "key": "LEFT"},
{"text": "Right", "key": "RIGHT"},
{"text": "Above", "key": "UP"},
{"text": "Below", "key": "DOWN"},
{"text": "In front", "key": "FRONT"},
{"text": "Behind", "key": "BACK"},
{"text": "Away from", "key": "AWAY"},
{"text": "Nearby or close to", "key": "NEAR"},
{"text": "Around", "key": "AROUND"},
{"text": "Exactly at", "key": "EXACT"},
],
}
],
},
]
LOCATION_REL_OBJECT_QUESTIONS = [
{
"text": "Click on all words specifying the object / area relative of which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [{"text": "Yes", "key": "yes"}, {"text": "No", "key": "no"}],
},
# {
# "text": "Is the location of the reference object mentioned ? Select all words.",
# "key": "reference_object.location",
# "span": True,
# "optional": True,
# "tooltip": "e.g. in 'to the right of the cow behind the house' select 'behind the house'",
# # "radio": LOCATION_RADIO,
# },
]
LOCATION_REL_OBJECT = [
{
"text": "Somewhere relative to (or exactly at) another object(s) / area(s)",
"key": "REFERENCE_OBJECT",
"next": [
{
"text": "Where (which direction) in relation to the other object(s)?",
"key": "relative_direction",
"radio": [
{
"text": "Left or towards the west direction",
"key": "LEFT",
"next": [
{
"text": "Click on all words specifying the object / area to the left of which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "Right or towards the east direction",
"key": "RIGHT",
"next": [
{
"text": "Click on all words specifying the object / area to the right of which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "Above or towards the north direction",
"key": "UP",
"next": [
{
"text": "Click on all words specifying the object / area above which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "Below or towards the south direction",
"key": "DOWN",
"next": [
{
"text": "Click on all words specifying the object / area below which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "In front",
"key": "FRONT",
"next": [
{
"text": "Click on all words specifying the object / area in front of which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "Behind",
"key": "BACK",
"next": [
{
"text": "Click on all words specifying the object / area at the back of which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "Away from",
"key": "AWAY",
"next": [
{
"text": "Click on all words specifying the object / area away from which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "Inside",
"key": "INSIDE",
"next": [
{
"text": "Click on all words specifying the object / area inside which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "Outside",
"key": "OUTSIDE",
"next": [
{
"text": "Click on all words specifying the object / area outside which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "Between two object(s) / area(s)",
"key": "BETWEEN",
"next": [
{
"text": "Click on all words specifying the first object / area relative to which the location is given",
"key": "reference_object_1.has_name",
"tooltip": "e.g. in 'make 5 copies between the car and the house' select 'car'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the first relative object?",
"key": "reference_object_1.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
{
"text": "Click on all words specifying the second object / area relative to which the location is given",
"key": "reference_object_2.has_name",
"tooltip": "e.g. in 'make 5 copies between the car and the house' select 'house'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the second relative object?",
"key": "reference_object_2.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "Nearby or close to",
"key": "NEAR",
"next": [
{
"text": "Click on all words specifying the object / area close to which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "Around",
"key": "AROUND",
"next": [
{
"text": "Click on all words specifying the object / area around which the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
{
"text": "Exactly at",
"key": "EXACT",
"next": [
{
"text": "Click on all words specifying the object / area exactly where the location is given",
"key": "reference_object.has_name",
"tooltip": "e.g. in 'make 5 copies to the left of the cow' select 'cow'",
"span": True,
},
{
"text": "Are there indefinite nouns or pronouns specifying the relative object?",
"key": "reference_object.contains_coreference",
"tooltip": "e.g. 'to the right of this', 'near that', 'behind these', 'next to those', 'underneath it' etc",
"add_radio_other": False,
"radio": [
{"text": "Yes", "key": "yes"},
{"text": "No", "key": "no"},
],
},
],
},
],
}
],
}
]
REF_OBJECT_OPTIONALS = [
{
"text": "What is the building material?",
"key": "reference_object.has_block_type",
"span": True,
"tooltip": "e.g. in 'destroy the tiny blue glass cube' select 'glass'",
},
{
"text": "What is the color?",
"key": "reference_object.has_colour",
"span": True,
"tooltip": "e.g. in 'destroy the tiny blue glass cube' select 'blue'",
},
{
"text": "What is the size?",
"key": "reference_object.has_size",
"span": True,
"tooltip": "e.g. in 'destroy the tiny blue glass cube' select 'tiny'",
},
{
"text": "What is the width?",
"key": "reference_object.has_width",
"span": True,
"tooltip": "e.g. in 'next to the 5 step wide hole' select '5'",
},
{
"text": "What is the height?",
"key": "reference_object.has_height",
"span": True,
"tooltip": "e.g. in 'next to the tower that is 20 blocks high' select '20'",
},
{
"text": "What is the depth?",
"key": "reference_object.has_depth",
"span": True,
"tooltip": "e.g. in 'fill the 20 block deep hole for me' select '20'",
},
]
def get_questions(child, action, optional_words=None):
QUESTION = None
if child == "schematic":
if action == "build":
# add tooltip
QUESTION = {
"text": "Click on all properties of the thing to be built mentioned in the highlighted text.",
"key": "schematic",
"checkbox": True,
"tooltip": "e.g. in 'make a blue square' click on 'Name' as well as 'Colour' since both are specified in 'blue square'",
"add_radio_other": False,
"radio": [
{
"text": "Name",
"key": "name_check",
"tooltip": "Select this if the name of the thing to be built is mentioned",
"next": [
{
"text": "Select all words that indicate the name of the thing to be built",
"key": "has_name",
"tooltip": "e.g. in 'Build a big green wooden house there' select 'house'",
"span": True,
}
],
},
{
"text": "Abstract/non-numeric size (e.g. 'big', 'small', etc.)",
"key": "size_check",
"tooltip": "Select this if the size of the thing to be built is specified",
"next": [
{
"text": "Select all words that represent the size",
"key": "has_size",
"span": True,
"tooltip": "e.g. in 'Build a big green wooden house there' select 'big'",
}
],
},
{
"text": "Colour",
"key": "colour_check",
"tooltip": "Select this if the colour of what needs to be built is specified",
"next": [
{
"text": "Select all words that represent the colour.",
"key": "has_colour",
"span": True,
"tooltip": "e.g. in 'Build a big green wooden house there' select 'green'",
}
],
},
{
"text": "The building material",
"key": "block_type_check",
"tooltip": "Select this if the building material is mentioned",
"next": [
{
"text": "What should it be built out of? Select all words.",
"key": "has_block_type",
"tooltip": "e.g. in 'Build a big green wooden house there' select 'wooden'",
"span": True,
}
],
},
{
"text": "Height",
"key": "height_check",
"tooltip": "Select this if the height is explicitly specified",
"next": [
{
"text": "Select all number words for height.",
"key": "has_height",
"span": True,
"tooltip": "e.g. in 'make a 5 block tall tower here' select '5'",
}
],
},
{
"text": "Width",
"key": "width_check",
"tooltip": "Select this if the width is explicitly specified",
"next": [
{
"text": "Select all number words for width",
"key": "has_width",
"span": True,
"tooltip": "e.g. in 'make a 4 blocks wide square there' select '4'",
}
],
},
{
"text": "Length",
"key": "length_check",
"tooltip": "Select this if the length is explicitly specified",
"next": [
{
"text": "Select all number words for length",
"key": "has_length",
"span": True,
"tooltip": "e.g. in 'make a 4 blocks long square there' select '4'",
}
],
},
{
"text": "Thickness",
"key": "thickness_check",
"tooltip": "Select this if the thickness is explicitly specified",
"next": [
{
"text": "Select all number words for thickness",
"key": "has_thickness",
"span": True,
"tooltip": "e.g. in 'make a hollow rectangle of thickness 3' select '3'",
}
],
},
{
"text": "Some other property not mentioned above",
"key": "tag_check",
"tooltip": "Select this if any propoerty not explicitly mentioned above is given",
"next": [
{
"text": "Select all words for this property",
"key": "has_tag",
"span": True,
"tooltip": "e.g. in 'make a bright cabin' select 'bright'",
}
],
},
],
}
elif action == "dig":
# add tooltip
QUESTION = {
"text": "Click on all properties of the thing to be dug mentioned in the highlighted text.",
"key": "schematic",
"checkbox": True,
"tooltip": "e.g. in 'dig a 10 x 10 pool' click on 'Name' as well as 'length' and 'width' since all are specified in '10 x 10 pool'",
"add_radio_other": False,
"radio": [
{
"text": "Name",
"key": "name_check",
"tooltip": "Select this if the name of the thing to be dug is mentioned",
"next": [
{
"text": "Select all words that indicate the name of the thing to be dug",
"key": "has_name",
"tooltip": "e.g. in 'dig a 10 x 10 pool there' select 'pool'",
"span": True,
}
],
},
{
"text": "Length",
"key": "length_check",
"tooltip": "Select this if the length is explicitly specified",
"next": [
{
"text": "Select all number words for length.",
"key": "has_length",
"span": True,
"tooltip": "e.g. in 'dig a 5 feet by 5 feet hole here' select '5'",
}
],
},
{
"text": "Width",
"key": "width_check",
"tooltip": "Select this if the width is explicitly specified",
"next": [
{
"text": "Select all number words for width",
"key": "has_width",
"span": True,
"tooltip": "e.g. in 'dig a 2 by 3 hole there' select '3'",
}
],
},
{
"text": "Depth",
"key": "depth_check",
"tooltip": "Select this if the depth is explicitly specified",
"next": [
{
"text": "Select all number words for depth",
"key": "has_depth",
"span": True,
"tooltip": "e.g. in 'dig a 1 x 2 x 3 pool' select '3'",
}
],
},
{
"text": "Abstract/non-numeric size (e.g. 'big', 'small', etc.)",
"key": "size_check",
"tooltip": "Select this if the size of the thing to be dug is specified without number words",
"next": [
{
"text": "Select all words that describe the abstract size",
"key": "has_size",
"span": True,
"tooltip": "e.g. in 'dig a big hole' select 'big'",
}
],
},
{
"text": "Some other property not mentioned above",
"key": "tag_check",
"tooltip": "Select this if any propoerty not explicitly mentioned above is given",
"next": [
{
"text": "Select all words for this property",
"key": "has_tag",
"span": True,
"tooltip": "e.g. in 'make a bright cabin' select 'bright'",
}
],
},
],
}
elif child == "location":
# location_rel_obj = construct_location_rel(location_in_rel=True)
question_1 = None
if action in ["build", "copy", "spawn", "dig"]:
question_1 = "Where should the " + optional_words + " happen?"
elif action == "move":
question_1 = "Where should the assistant move to"
elif action == "dance":
question_1 = "Where should the assistant dance"
elif action == "otheraction":
question_1 = "Give us more details about the location"
QUESTION = [
{"text": question_1, "key": "location", "radio": LOCATION_RADIO + LOCATION_REL_OBJECT},
{
"text": "If a number of steps is specified, how many ?",
"key": "location.steps",
"span": True,
"optional": True,
"tooltip": "e.g. in 'make a square 5 steps behind that' select '5'",
},
]
return QUESTION
elif child == "tag_val":
QUESTION = {
"text": "Click on options below to determine the intent of the text.",
"key": "memory_data",
"tooltip": "e.g. in 'good job' click on 'Feedback to the assistant'",
"add_radio_other": False,
"radio": [
{
"text": "Feedback to the assistant",
"key": "memory_type.reward",
"tooltip": "e.g. select for 'that was nice' or 'no that's wrong' ",
"next": [
{
"text": "Select the kind of feedback",
"key": "reward_value",
"add_radio_other": False,
"tooltip": "e.g. 'Positive feedback' for good things like 'you did a good job', 'that was a nice",
"radio": [
{
"text": "Positive feedback",
"key": "POSITIVE",
"tooltip": "e.g. for good things like 'you did a good job', 'that was a nice'",
},
{
"text": "Negative feedback",
"key": "NEGATIVE",
"tooltip": "e.g. for corrections like 'that was wrong', 'you failed'",
},
],
}
],
},
{
"text": "To assign tag, name or description",
"key": "memory_type.triple",
"tooltip": "e.g. 'that looks nice', 'tag the house as bright' etc",
"radio": [
{
"text": "The highlighted word(s) is a kind of colour",
"key": "has_colour",
},
{"text": "The highlighted word(s) represents size", "key": "has_size"},
{"text": "The highlighted word(s) is something else", "key": "has_tag"},
],
},
],
}
elif child == "reference_object" or (child == "filters" and action == "tag"):
# location_rel_obj = construct_location_rel(location_in_rel=False)
word = ""
if action == "otheraction":
question_1 = "There are words or pronouns that refer to the object (e.g. 'this', 'that', 'these', 'those', 'it' etc)"
question_2 = "What is the name of the reference object"
else:
if action == "copy":
word = "copied"
elif action == "freebuild":
word = "completed"
elif action == "destroy":
word = "destroyed"
elif action == "fill":
word = "filled"
elif action == "spawn":
word = "spawned"
elif action == "tag":
word = "tagged"
question_1 = (
"There are words or pronouns that refer to the object to be "
+ word
+ " (e.g. 'this', 'that', 'these', 'those', 'it' etc)"
)
question_2 = "What is the name of the object that should be " + word + "?"
QUESTION = [
{
"text": "Click on all mentioned properties of the object in highlighted text.",
"key": "reference_object",
"checkbox": True,
"tooltip": "e.g. in 'destroy the blue square' click on 'Name' as well as 'Colour' since both are specified in 'blue square'",
"add_radio_other": False,
"radio": [
{
"text": "Name",
"key": "name_check",
"tooltip": "Select this if the name / word for the object is mentioned",
"next": [{"text": question_2, "key": "has_name", "span": True}],
},
{
"text": question_1,
"key": "contains_coreference.yes",
"tooltip": "e.g. 'this', 'that', 'these', 'those', 'it' etc",
"add_radio_other": False,
},
{
"text": "The building material",
"key": "block_type_check",
"tooltip": "Select this if the building material of the object is mentioned",
"next": [
{
"text": "What is the building material? Select all words.",
"key": "has_block_type",
"span": True,
"tooltip": "e.g. in 'destroy the tiny blue glass cube' select 'glass'",
}
],
},
{
"text": "Colour",
"key": "colour_check",
"tooltip": "Select this if the colour of the object is specified",
"next": [
{
"text": "What is the color?",
"key": "has_colour",
"span": True,
"tooltip": "e.g. in 'destroy the tiny blue glass cube' select 'blue'",
}
],
},
{
"text": "Abstract/non-numeric size (e.g. 'big', 'small', etc.)",
"key": "size_check",
"tooltip": "Select this if the abstract/non-numeric size of the object is specified",
"next": [
{
"text": "What is the size?",
"key": "has_size",
"span": True,
"tooltip": "e.g. in 'destroy the tiny blue glass cube' select 'tiny'",
}
],
},
{
"text": "Height",
"key": "height_check",
"tooltip": "Select this if the height is explicitly specified",
"next": [
{
"text": "What is the height?",
"key": "has_height",
"span": True,
"tooltip": "e.g. in 'complete the 20 blocks high tower' select '20'",
}
],
},
{
"text": "Length",
"key": "length_check",
"tooltip": "Select this if the length is explicitly specified",
"next": [
{
"text": "Select all number words for length.",
"key": "has_length",
"span": True,
"tooltip": "e.g. in 'dig a 5 feet by 5 feet hole here' select '5'",
}
],
},
{
"text": "Width",
"key": "width_check",
"tooltip": "Select this if the width is explicitly specified",
"next": [
{
"text": "Select all number words for width",
"key": "has_width",
"span": True,
"tooltip": "e.g. in 'dig a 2 by 3 hole there' select '3'",
}
],
},
{
"text": "Depth",
"key": "depth_check",
"tooltip": "Select this if the depth is explicitly specified",
"next": [
{
"text": "Select all number words for depth",
"key": "has_depth",
"span": True,
"tooltip": "e.g. in 'dig a 1 x 2 x 3 pool' select '3'",
}
],
},
{
"text": "Some other property not mentioned above",
"key": "tag_check",
"tooltip": "Select this if any property not explicitly mentioned above is given",
"next": [
{
"text": "Select all words for this property",
"key": "has_tag",
"span": True,
"tooltip": "e.g. in 'make a bright cabin' select 'bright'",
}
],
},
],
},
{
"text": "Is the location of the reference object mentioned ? Select all words.",
"key": "reference_object.location",
# "span": True,
"tooltip": "e.g. in 'destroy the house behind the tree' select 'behind the tree'",
"radio": LOCATION_RADIO + LOCATION_REL_OBJECT
# [
# {
# "text": "Not specified",
# "key": None,
# "tooltip": "The location information is missing.",
# },
# {
# "text": "The location is represented using an indefinite noun like 'there' or 'over here'",
# "key": "CONTAINS_COREFERENCE",
# "tooltip": "e.g. 'there', 'here', 'over there' etc",
# },
# {
# "text": "Exact coordinates are given",
# "key": "coordinates_check",
# "tooltip": "Exact coordinates are specified.",
# "next": [
# {
# "text": "Click on all words representing the coordinates",
# "key": "yes.coordinates",
# "span": True,
# "tooltip": "e.g. in 'make a box at 4 , 5 , 6' select all: '4 , 5 , 6'",
# }
# ],
# },
# {
# "text": "Where the speaker is looking",
# "key": "SPEAKER_LOOK",
# "tooltip": "e.g. 'where I am looking'",
# },
# {
# "text": "Where the speaker is standing",
# "key": "SPEAKER_POS",
# "tooltip": "e.g. 'by me', 'where I am', 'where I am standing'",
# },
# {
# "text": "Where the assistant is standing",
# "key": "AGENT_POS",
# "tooltip": "e.g. 'by you', 'where you are', 'where you are standing'",
# },
# ],
},
]
return QUESTION
return QUESTION
| craftassist-master | acl2020_submission/annotation_tools/tools/question_flow_for_step_2.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
MAX_WORDS = 30
CSS_SCRIPT = """
<script>
var node = document.createElement('style');
"""
for j in range(1, 4):
for i in range(MAX_WORDS):
CSS_SCRIPT += """
if (! "${{word{j}{i}}}") {{
node.innerHTML += '.word{j}{i} {{ display: none }} '
}}
""".format(
i=i, j=j
)
CSS_SCRIPT += """
document.body.appendChild(node);
</script>
"""
JS_SCRIPT = """
$(function () {
$('[data-toggle="tooltip"]').tooltip()
})
"""
BEFORE = """
<!-- Bootstrap v3.0.3 -->
<link href="https://s3.amazonaws.com/mturk-public/bs30/css/bootstrap.min.css" rel="stylesheet" />
<section class="container" id="Other" style="margin-bottom:15px; padding: 10px 10px;
font-family: Verdana, Geneva, sans-serif; color:#333333; font-size:0.9em;">
<div class="row col-xs-12 col-md-12">
<!-- Instructions -->
<div class="panel panel-primary">
<div class="panel-heading"><strong>Instructions</strong></div>
<div class="panel-body" style="font-size:14px;">
<p><b>Your HIT will will be rejected if you don't answer all three commands before submitting.</b></p>
<p>Please help us determine the exact meaning of the command shown to you.
The command is given to an AI assistant to help out a player in the game of Minecraft.</p>
<p>For each command, you will answer a series of questions. Each question is either multiple-choice,
or requires you to select which words in the sentence correspond to which components of the command.</p>
<p>
<b>1. Place your mouse arrow over the questions and options for detailed tips.</b></br>
<b>2. When selecting the words, please select all words (along with properties of the thing).</b> So in "destroy the blue house" select "blue house" and not just "house"</br>
<b>3. Please also note that: </b>some questions are optional, click on "Click if specified" if you think answers to those are mentioned in the command.
</p>
<p>Few examples below:</p>
<p><b>"come"</b>
<ul>
<li>For "What action is being requested?", the answer is "Move or walk somewhere"</li>
</ul></p>
<p><b>"make two small cubes here"</b>
<ul>
<li>"What action is being requested?" -> "Build, make a copy or complete something"</li>
<li>"Is this an exact copy or duplicate of an existing object?" -> "No". The assistant is asked to "Build a fresh complete, specific object"</li>
<li>For "Select words specifying what needs to be built" select the words: 'small cubes'</li>
<li>For "Select words specifying where the construction needs to happen", click on the word: 'here'</li>
<li>For "How many times should this action be performed?", select "Repeatedly, a specific number of times"
and then "two" for 'How many times'</li>
</ul>
</p>
<p><b>"dig until you reach water"</b>
<ul>
<li>"What action is being requested?" -> "Dig"</li>
<li>For "How many times should this action be performed?" -> 'Repeated until a certain condition is met'</li>
<li>For "Until the assistant reaches some object(s) /area" select: "water"</li>
</ul>
<b>Note that: repeats may be disguised, for example: 'follow the pig' should be interpreted as "repeat forever: move to the location of the pig".</b>
</p>
<p><b>"go to the large pole near the bridge"</b></br>
<ul>
<li>"What action is being requested?" -> "Move or walk somewhere"</li>
<li>"Select words specifying the location to which the agent should move" -> "the large pole near the bridge". </li>
</ul>
</p>
</div>
</div>
<!-- Content Body -->
<section>
"""
AFTER = """
</section>
<!-- End Content Body -->
</div>
</section>
<style type="text/css">
fieldset {{
padding: 10px;
font-family: Georgia;
font-size: 14px;
background: #fbfbfb;
border-radius: 5px;
margin-bottom: 5px;
}}
.tooltip {{
font-family: Georgia;
font-size: 18px;
}}
.tooltip .tooltip-inner {{
background-color: #ffc;
color: #c00;
min-width: 250px;
}}
</style>
{CSS_SCRIPT}
<script src="https://code.jquery.com/jquery.js"></script>
<script src="https://netdna.bootstrapcdn.com/bootstrap/3.0.3/js/bootstrap.min.js"></script>
<script>{JS_SCRIPT}</script>
""".format(
CSS_SCRIPT=CSS_SCRIPT, JS_SCRIPT=JS_SCRIPT
)
if __name__ == "__main__":
import render_questions
from question_flow_for_step_1 import *
print(BEFORE)
render_output = """<div style='font-size:16px;display:block' id='div_1'>"""
render_output += """<div class="well" style="position:sticky;position:-webkit-sticky;top:0;z-index:9999" id='cmd_1'>
<b>Command: ${command_1}</b></div>"""
render_output += render_questions.render_q(Q_ACTION, "root.1", show=True, sentence_id=1)
render_output += render_questions.render_q(Q_ACTION_LOOP, "root.1", show=True, sentence_id=1)
render_output += """</div><br><br>"""
render_output += """<br style=“line-height:50;”>"""
render_output += """<hr size="10">"""
render_output += """<div style='font-size:16px;display:block' id='div_2'>"""
render_output += """<div class="well" style="position:sticky;position:-webkit-sticky;top:0;z-index:9999">
<b>Command: ${command_2}</b></div> """
render_output += render_questions.render_q(Q_ACTION, "root.2", show=True, sentence_id=2)
render_output += render_questions.render_q(Q_ACTION_LOOP, "root.2", show=True, sentence_id=2)
render_output += """</div><br><br>"""
render_output += """<br style=“line-height:50;”>"""
render_output += """<hr size="10">"""
render_output += """<div style='font-size:16px;display:block' id='div_3'>"""
render_output += """<div class="well" style="position:sticky;position:-webkit-sticky;top:0;z-index:9999">
<b>Command: ${command_3}</b></div> """
render_output += render_questions.render_q(Q_ACTION, "root.3", show=True, sentence_id=3)
render_output += render_questions.render_q(Q_ACTION_LOOP, "root.3", show=True, sentence_id=3)
render_output += """</div><br><br>"""
print(render_output)
print(AFTER)
| craftassist-master | acl2020_submission/annotation_tools/tools/qualification_tool.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import re
def render_q(q, parent_id, show=True, show_siblings=True, sentence_id=""):
"""Return a fieldset for the given question"""
assert "key" in q, "Missing key for q: {}".format(q)
q_id = "{}.{}".format(parent_id, q["key"])
r = ""
r += '<fieldset id="{}" style="display:{}">'.format(q_id, "block" if show else "none")
r += label_tag(tooltip=q.get("tooltip")) + q["text"] + "</label>"
if "radio" in q:
r += render_radios(
q["radio"],
q_id,
add_other_opt=q.get("add_radio_other", True),
show_siblings=show_siblings,
sentence_id=sentence_id,
)
if "span" in q:
r += render_span(q_id, q.get("optional"), sentence_id=sentence_id)
r += "</fieldset>"
return r
def render_span(parent_id, optional=False, sentence_id=""):
r = ""
group_id = "{}.span".format(parent_id)
if optional:
onclick = """var x = document.getElementById('{}');
x.style.display = x.style.display == 'block' ? 'none' : 'block';""".format(
group_id
)
r += """<label class="btn btn-primary btn-sm" onclick="{}"
style="margin-left:10px">Click and select all words if specified</label>""".format(
onclick
)
r += '<div id="{}" class="btn-group" data-toggle="buttons" style="display:{}">'.format(
group_id, "none" if optional else "block"
)
for i in range(40):
input_id = "{}#{}".format(group_id, i)
r += """<label class="btn btn-default word{j}{i}"
name="{input_id}">""".format(
input_id=input_id, i=i, j=sentence_id
)
r += '<input type="checkbox" autocomplete="off" id="{input_id}" \
name="{input_id}">${{word{j}{i}}}'.format(
input_id=input_id, i=i, j=sentence_id
)
r += "</label>"
r += "</div>"
return r
def render_radios(opts, parent_id, add_other_opt=True, show_siblings=True, sentence_id=""):
if add_other_opt:
opts = opts + [{"text": "Other", "key": "Other"}]
r = ""
suffix = ""
for opt in opts:
opt_id = "{}.{}".format(parent_id, opt["key"])
nexts = opt.get("next", [])
# render child questions
suffix += (
'<div id="{}.next" style="display:none">'.format(opt_id)
+ "\n".join([render_q(n, opt_id, sentence_id=sentence_id) for n in nexts])
+ "</div>"
)
# get onchange function
sibling_ids = ["{}.{}".format(parent_id, o["key"]) for o in opts]
# child_ids = ["{}.{}".format(opt_id, n["key"]) for n in nexts]
onchange = "\n".join(
[
"""
console.log('Toggling {sid}');
if (document.getElementById('{sid}.next')) {{
document.getElementById('{sid}.next').style.display = \
document.getElementById('{sid}').checked ? 'block' : 'none';
}}
""".format(
sid=sid
)
for sid in sibling_ids
]
)
if not show_siblings:
onchange += "\n".join(
[
"""
console.log('Hiding siblings {sid}');
if (document.getElementById('div_{sid}')) {{
document.getElementById('div_{sid}').style.display = \
document.getElementById('{sid}').checked ? 'block' : 'none';
}}
""".format(
sid=sid
)
for sid in sibling_ids
]
)
# produce div for single option
r += '<div class="radio" id="div_{}">'.format(opt_id) + label_tag(opt.get("tooltip"))
r += """<input name="{}"
id="{}"
type="radio"
value="{}"
onchange="{}"
/>""".format(
parent_id, opt_id, opt["key"], onchange
)
r += opt["text"]
r += "</label></div>"
return r + suffix
def label_tag(tooltip=None):
if tooltip:
return '<label data-toggle="tooltip" data-placement="right" title="{}">'.format(tooltip)
else:
return "<label>"
def child_id(parent_id, text):
return parent_id + "." + re.sub(r"[^a-z]+", "-", text.lower().strip()).strip("-")
| craftassist-master | acl2020_submission/annotation_tools/tools/render_questions_tool_1.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
BEFORE = """
<!-- Bootstrap v3.0.3 -->
<link href="https://s3.amazonaws.com/mturk-public/bs30/css/bootstrap.min.css" rel="stylesheet" />
<section class="container" id="Other" style="margin-bottom:15px; padding: 10px 10px;
font-family: Verdana, Geneva, sans-serif; color:#333333; font-size:0.9em;">
<div class="row col-xs-12 col-md-12">
<!-- Instructions -->
<div class="panel panel-primary">
<div class="panel-heading"><strong>Instructions</strong></div>
<div class="panel-body" style="font-size:14px;">
<h1><strong>Split a composite command into individuals.</strong></h1>
<p>Please help us split a command into individual single commands.
The command shown to you here is given to an AI assistant to help out a player in the game of Minecraft.
You will be show a command that possibly implies a sequence or list of single commands and your task is to give us
single complete actions that are intended by the command shown to you.</p>
</br>
</br>
<p>Few valid examples below: </p>
<p>For <b>"hey bot please build a house and a cube"</b>
the answer is the following:
<ul>
<li>"hey bot please build a house" and </li>
<li>"hey bot please build a cube"</li>
</ul>
</p>
<p>For <b>"build a castle and then come back here"</b>
the answer is the following:
<ul>
<li>"build a castle" and </li>
<li>"come back here"</li>
</ul>
</p>
<p>For <b>"destroy the roof and build a stone ceiling in its place"</b>
the answer is the following:
<ul>
<li>"destroy the roof" and </li>
<li>"build a stone ceiling in its place"</li>
</ul>
</p>
<p>For <b>"move to the door and open it"</b>
the answer is the following:
<ul>
<li>"move to the door" and </li>
<li>"open the door"</li>
</ul>
</p>
<p>For <b>"i want you to undo the last two spawns and try again with new spawns" </b>
<ul>
<li>"undo the last two spawns" and </li>
<li>"do a new spawn"</li>
</ul>
<b>Note that: "do a new spawn" is a rewrite of "and try again with new spawns" to make that sub-command clear when seen in isolation.</b>
</p>
<p> Note that:</br>
<b>1. Some commands might have more than two splits. We've given you two more optional boxes.</b></br>
<b>2. Make sure that the commands you enter in text boxes are single and complete sentences by their own.</b></br>
<b>3. You might need to rewrite some commands when you split them, to make them clear in isolation.</b>
</p>
</div>
</div>
<div class="well" style="position:sticky;position:-webkit-sticky;top:0;z-index:9999">
<h2><strong>Command:</strong> ${sentence}</h2>
</div>
<!-- Content Body -->
<section>
"""
# AFTER = """
# </section>
# <!-- End Content Body -->
#
# </div>
# </section>
#
# <style type="text/css">
# fieldset {{
# padding: 10px;
# font-family: Georgia;
# font-size: 14px;
# background: #fbfbfb;
# border-radius: 5px;
# margin-bottom: 5px;
# }}
# .tooltip {{
# font-family: Georgia;
# font-size: 18px;
# }}
# .tooltip .tooltip-inner {{
# background-color: #ffc;
# color: #c00;
# min-width: 250px;
# }}
# </style>
#
# {CSS_SCRIPT}
#
# <script src="https://code.jquery.com/jquery.js"></script>
# <script src="https://netdna.bootstrapcdn.com/bootstrap/3.0.3/js/bootstrap.min.js"></script>
#
# <script>{JS_SCRIPT}</script>
# """.format(
# CSS_SCRIPT=CSS_SCRIPT, JS_SCRIPT=JS_SCRIPT
# )
BETWEEN = """
<section>
<fieldset>
<div class="input-group"><span style="font-family: verdana, geneva, sans-serif;font-size: 18px;">The individual commands. </span>
<p>Command 1 <textarea class="form-control" cols="150" name="command_1" rows="2"></textarea></p>
<p>Command 2 <textarea class="form-control" cols="150" name="command_2" rows="2"></textarea></p>
<p>Command 3 (optional)<textarea class="form-control" cols="150" name="command_3" rows="2"></textarea></p>
<p>Command 4 (optional)<textarea class="form-control" cols="150" name="command_4" rows="2"></textarea></p>
</div>
</fieldset>
</section>
<!-- End Content Body --></div>
</div>
</section>
<style type="text/css">fieldset { padding: 10px; background:#fbfbfb; border-radius:5px; margin-bottom:5px; }
</style>
"""
if __name__ == "__main__":
print(
BEFORE,
BETWEEN
# render_questions.render_q(Q_ACTION, "root", show=True),
# render_questions.render_q(Q_ACTION_LOOP, "root", show=True),
# AFTER,
)
| craftassist-master | acl2020_submission/annotation_tools/tools/composite_command_tool.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
from collections import Counter, defaultdict
import argparse
import ast
right_answer_count = Counter()
wrong_answer_count = Counter()
# compile sets of allowed answers
allowed_answers = defaultdict(set)
command = None
def read_gold_set(gold_set):
command = None
with open(gold_set, "r") as f:
for line in f:
line = line.strip()
if line == "":
continue
if line.startswith("{"):
try:
allowed_answers[command].add(line)
except:
print("Bad allowed answer:", line)
raise
else:
command = line
def compare_dicts(action_dict, allowed_dict):
# action_dict = ast.literal_eval(action_dict)
allowed_dict = ast.literal_eval(allowed_dict)
if "repeat" in allowed_dict:
if "repeat" not in action_dict:
return False
val = allowed_dict["repeat"]
val2 = action_dict["repeat"]
if val != val2:
if val[0] != val2[0]:
return False
val_dict1 = val[1]
val_dict2 = val2[1]
for k, v in val_dict2.items():
if k == "repeat_dir":
continue
if k not in val_dict1 or v != val_dict1[k]:
return False
for k, v in allowed_dict.items():
if k == "repeat":
continue
if k not in action_dict or action_dict[k] != v:
return False
return True
def get_wrong_stats(dict1, dict2):
""" {'repeat',
'schematic',
'dialogue_type',
'action_type',
'has_block_type',
'reference_object',
'tag_val',
'filters',
'location',
'target_action_type'}"""
st = {}
for k, v in dict2:
if k not in dict1:
print("missing key: %r" % (k))
if v != dict1[k]:
st[k] += 1
def evaluate_workers(worker_file):
worker_stats = {}
wrong_stats = {}
for k, v in allowed_answers.items():
wrong_stats[k] = {}
with open(worker_file) as f:
for line in f.readlines():
right_count = 0
wrong_count = 0
worker_id, answers = line.strip().split("\t")
answer_dicts = ast.literal_eval(answers)
# if worker didn't answer all questions, ignore
if len(answer_dicts.keys()) < 3:
print("Skipping: %r completed only %r" % (worker_id, len(answer_dicts.keys())))
continue
# otherwise read all answers
# k is sentence, v is dict
for k, v in answer_dicts.items():
# k has to be in allowed_answers
if k not in allowed_answers:
print("BADDDDDD")
# if answer doesn't match any allowed answer
if not any(compare_dicts(v, d) for d in allowed_answers[k]):
wrong_count += 1
for d in allowed_answers[k]:
stats = get_wrong_stats(v, d)
wrong_stats[k].update(stats)
return worker_stats
print(k, v)
else:
right_count += 1
# print("-" * 30)
worker_stats[worker_id] = int((right_count / (right_count + wrong_count)) * 100)
return worker_stats
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--gold_set", type=str, required=True)
parser.add_argument("--worker_file", type=str, required=True)
parser.add_argument("--worker_stats_out", type=str, required=True)
args = parser.parse_args()
read_gold_set(args.gold_set)
stats = evaluate_workers(args.worker_file)
with open(args.worker_stats_out, "w") as f:
for worker_id, val in stats.items():
f.write(worker_id + "\t" + str(val) + "\n")
| craftassist-master | acl2020_submission/annotation_tools/tools/evaluate_qualification.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
MAX_WORDS = 40
CSS_SCRIPT = """
<script>
var node = document.createElement('style');
"""
for i in range(MAX_WORDS):
CSS_SCRIPT += """
if (! "${{word{i}}}") {{
node.innerHTML += '.word{i} {{ display: none }} '
}}
""".format(
i=i
)
CSS_SCRIPT += """
document.body.appendChild(node);
</script>
"""
JS_SCRIPT = """
$(function () {
$('[data-toggle="tooltip"]').tooltip()
})
"""
BEFORE = """
<!-- Bootstrap v3.0.3 -->
<link href="https://s3.amazonaws.com/mturk-public/bs30/css/bootstrap.min.css" rel="stylesheet" />
<section class="container" id="Other" style="margin-bottom:15px; padding: 10px 10px;
font-family: Verdana, Geneva, sans-serif; color:#333333; font-size:0.9em;">
<div class="row col-xs-12 col-md-12">
<!-- Instructions -->
<div class="panel panel-primary">
<div class="panel-heading"><strong>Instructions</strong></div>
<div class="panel-body" style="font-size:14px;">
<p>Please help us determine the exact meaning of the command shown to you.
The command is given to an AI assistant to help out a player in the game of Minecraft.</p>
<p>You will answer a series of questions. Each question is either multiple-choice,
or requires you to select which words in the sentence correspond to which components of the command.</p>
<p>
<b>1. Place your mouse arrow over the questions and options for detailed tips.</b></br>
<b>2. When selecting the words, please select all words (along with properties of the thing).</b> So in "destroy the blue house" select "blue house" and not just "house"</br>
<b>3. Please also note that: </b>some questions are optional, click on "Click if specified" if you think those are mentioned in the command.
</p>
<p>Few examples below:</p>
<p><b>"come"</b>
<ul>
<li>For "What action is being requested?", the answer is "Move or walk somewhere"</li>
</ul></p>
<p><b>"make two small cubes here"</b>
<ul>
<li>"What action is being requested?" -> "Build, make a copy or complete something"</li>
<li>"Is this an exact copy or duplicate of an existing object?" -> "No". The assistant is asked to "Build a fresh complete, specific object"</li>
<li>For "Select words specifying what needs to be built" select the words: 'small cubes'</li>
<li>For "Select words specifying where the construction needs to happen", click on the word: 'here'</li>
<li>For "How many times should this action be performed?", select "Repeatedly, a specific number of times"
and then "two" for 'How many times'</li>
</ul>
</p>
<p><b>"dig until you reach water"</b>
<ul>
<li>"What action is being requested?" -> "Dig"</li>
<li>For "How many times should this action be performed?" -> 'Repeated until a certain condition is met'</li>
<li>For "Until the assistant reaches some object(s) /area" select: "water"</li>
</ul>
<b>Note that: repeats may be disguised, for example: 'follow the pig' should be interpreted as "repeat forever: move to the location of the pig".</b>
</p>
<p><b>"go to the large pole near the bridge"</b></br>
<ul>
<li>"What action is being requested?" -> "Move or walk somewhere"</li>
<li>"Select words specifying the location to which the agent should move" -> "the large pole near the bridge". </li>
</ul>
</p>
<p><b>"construct a 4 x 4 house"</b></br>
<ul>
<li>"What action is being requested?" -> "Build, make a copy or complete something"</li>
<li>"Is this an exact copy or duplicate of an existing object?" -> "No". The assistant is asked to "Build a fresh complete, specific object"</li>
<li>For "Select words specifying what needs to be built" select the words: '4 x 4 house'</li>
</ul>
<b>Note that: For build and dig actions, the words for size of the thing should be selected as a part of what needs to be built / dug. For example: in "construct a 4 x 4 house", select "4 x 4 house" as the thing to be built.</b>
</p>
</div>
</div>
<div class="well" style="position:sticky;position:-webkit-sticky;top:0;z-index:9999">
<b>Command: ${command}</b></div>
<!-- Content Body -->
<section>
"""
AFTER = """
</section>
<!-- End Content Body -->
</div>
</section>
<style type="text/css">
fieldset {{
padding: 10px;
font-family: Georgia;
font-size: 14px;
background: #fbfbfb;
border-radius: 5px;
margin-bottom: 5px;
}}
.tooltip {{
font-family: Georgia;
font-size: 18px;
}}
.tooltip .tooltip-inner {{
background-color: #ffc;
color: #c00;
min-width: 250px;
}}
</style>
{CSS_SCRIPT}
<script src="https://code.jquery.com/jquery.js"></script>
<script src="https://netdna.bootstrapcdn.com/bootstrap/3.0.3/js/bootstrap.min.js"></script>
<script>{JS_SCRIPT}</script>
""".format(
CSS_SCRIPT=CSS_SCRIPT, JS_SCRIPT=JS_SCRIPT
)
if __name__ == "__main__":
import render_questions_tool_1
from question_flow_for_step_1 import *
print(
BEFORE,
render_questions_tool_1.render_q(Q_ACTION, "root", show=True),
render_questions_tool_1.render_q(Q_ACTION_LOOP, "root", show=True),
AFTER,
)
| craftassist-master | acl2020_submission/annotation_tools/tools/annotation_tool_1.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import argparse
from annotation_tool_1 import MAX_WORDS
def print_csv_format(filename, option_num):
if option_num == 1:
# level 1
print("command", *["word{}".format(i) for i in range(MAX_WORDS)], sep=",")
with open(filename) as f:
for line in f.readlines():
command = line.replace(",", "").strip()
# This is default option for plain text to be rendered.
words = command.split()
print(command, *words, *([""] * (MAX_WORDS - len(words))), sep=",")
elif option_num == 2:
# level 2
print(
"command", "intent", "child", *["word{}".format(i) for i in range(MAX_WORDS)], sep=","
)
with open(filename) as f:
for line in f.readlines():
command = line.replace(",", "").strip()
# This option is if we need highlighted text to be rendered
# file will have : text + "\t" + text with spans in for highlighted words
parts = command.split("\t")
words = parts[0].split()
intent = parts[2]
child = parts[3]
print(parts[1], intent, child, *words, *([""] * (MAX_WORDS - len(words))), sep=",")
elif option_num == 3:
# qualification test
print(
"command_1",
*["word1{}".format(i) for i in range(MAX_WORDS)],
"command_2",
*["word2{}".format(i) for i in range(MAX_WORDS)],
"command_3",
*["word3{}".format(i) for i in range(MAX_WORDS)],
sep=","
)
with open(filename) as f:
l = []
for line in f.readlines():
command = line.replace(",", "").strip()
# This is default option for plain text to be rendered.
words = command.split()
l.append(",".join([command, *words, *([""] * (MAX_WORDS - len(words)))]))
print(",".join(l))
elif option_num == 4:
# composite command tool
print("sentence")
with open(filename) as f:
for line in f.readlines():
line = line.strip()
print(line)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--input_file", type=str, required=True)
parser.add_argument("--tool_num", type=int, default=1)
args = parser.parse_args()
print_csv_format(args.input_file, args.tool_num)
| craftassist-master | acl2020_submission/annotation_tools/tools/construct_input_for_turk.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
MAX_WORDS = 40
CSS_SCRIPT = """
<script>
var node = document.createElement('style');
"""
for i in range(MAX_WORDS):
CSS_SCRIPT += """
if (! "${{word{i}}}") {{
node.innerHTML += '.word{i} {{ display: none }} '
}}
""".format(
i=i
)
CSS_SCRIPT += """
document.body.appendChild(node);
</script>
"""
JS_SCRIPT = """
$(function () {
$('[data-toggle="tooltip"]').tooltip()
})
var child_name = document.getElementById("child_name_div").textContent;
var action_name = document.getElementById("intent_div").textContent;
var x = null;
var y = null;
var s = null;
x = action_name;
y = child_name;
s = action_name + "_" + child_name;
document.getElementById(s).style.display = "block";
"""
BEFORE = """
<!-- Bootstrap v3.0.3 -->
<link href="https://s3.amazonaws.com/mturk-public/bs30/css/bootstrap.min.css" rel="stylesheet" />
<section class="container" id="Other" style="margin-bottom:15px; padding: 10px 10px;
font-family: Verdana, Geneva, sans-serif; color:#333333; font-size:0.9em;">
<div class="row col-xs-12 col-md-12">
<!-- Instructions -->
<div class="panel panel-primary">
<div class="panel-heading"><strong>Instructions</strong></div>
<div class="panel-body" style="font-size:14px;">
<p>Please help us determine the exact meaning of the <span style='background-color: #FFFF00'>highlighted words</span> in the command shown below.
The command is given to an AI assistant to help a player in the game of Minecraft.</p>
<p>You will be answering a series of questions about the <span style='background-color: #FFFF00'><b>highlighted text</b></span>. Each question is either multiple-choice,
or requires you to select which words in the sentence correspond to which property of the thing.</p>
<p>
<b>1. Place your mouse arrow over the questions and options for detailed tips.</b></br>
<b>2. When selecting the words, please select all words (along with properties of the thing).</b> So in "destroy the blue house" select "blue house" and not just "house"</br>
<b>3. When answering the questions, remember that you are answering them to find more details about the highlighted words .</b>
</p>
<p>Few examples below:</p>
<p><b>"make a <span style='background-color: #FFFF00'>small red bright cube</span> there"</b>
<ul>
<li>Select 'Name', 'Abstract/non-numeric size' and 'Colour' properties from the radios.</li>
<li>For 'Select all words that indicate the name of the thing to be built' select 'cube'</li>
<li>For 'Select all words that represent the size' select 'small'</li>
<li>For 'Select all words that represent the colour' select 'red'</li>
<li>For 'Some other property not mentioned above' select 'bright'</li>
</ul></p>
<p><b>"destroy the house <span style='background-color: #FFFF00'>over there</span>"</b>
<li>For 'Where should the construction happen?' select "The location is represented using an indefinite noun like 'there' or 'over here'" </li>
</ul>
</p>
<p><b>"go to the cube <span style='background-color: #FFFF00'>behind me</span>"</b>
<li>For 'Where should the construction happen?' select "Somewhere relative to where the speaker is standing" </li>
<li>For 'Where (which direction) in relation to where the speaker is standing?' select 'Behind'</li>
</ul>
</p>
<p><b>"complete <span style='background-color: #FFFF00'>that</span>"</b>
<ul>
<li>Select "There are words or pronouns that refer to the object to be completed"</li>
</ul>
</p>
<p><b>"go <span style='background-color: #FFFF00'>behind the sheep</span>"</b>
<ul>
<li>Select "Somewhere relative to another object(s) / area(s)"</li>
<li>Select "Behind" for "Where (which direction) in relation to the other object(s)?"</li>
<li>Select "the sheep" for "Click on all words specifying the object / area relative to which location is given"</li>
</ul>
</p>
</div>
</div>
<div class="well" style="position:sticky;position:-webkit-sticky;top:0;z-index:9999">
<b>Command: ${command}</b></div>
<div id='intent_div' style='display:none'>${intent}</div>
<div id='child_name_div' style='display:none'>${child}</div>
<!-- Content Body -->
<section>
"""
AFTER = """
</section>
<!-- End Content Body -->
</div>
</section>
<style type="text/css">
fieldset {{
padding: 10px;
font-family: Georgia;
font-size: 14px;
background: #fbfbfb;
border-radius: 5px;
margin-bottom: 5px;
}}
.tooltip {{
font-family: Georgia;
font-size: 18px;
}}
.tooltip .tooltip-inner {{
background-color: #ffc;
color: #c00;
min-width: 250px;
}}
</style>
{CSS_SCRIPT}
<script src="https://code.jquery.com/jquery.js"></script>
<script src="https://netdna.bootstrapcdn.com/bootstrap/3.0.3/js/bootstrap.min.js"></script>
<script>{JS_SCRIPT}</script>
""".format(
CSS_SCRIPT=CSS_SCRIPT, JS_SCRIPT=JS_SCRIPT
)
if __name__ == "__main__":
import render_questions_tool_2
from question_flow_for_step_2 import *
initial_content = {
"build_schematic": "Please specify details of the thing that needs to be built.",
"build_location": "Please specify details of the location at which the construction will happen.",
"dig_schematic": "Please specify details of the thing that needs to be dug.",
"dig_location": "Please specify details of the location at which the digging will happen.",
"copy_reference_object": "Please specify details of the thing that needs to be copied.",
"copy_location": "Please specify details of the location at which the copy will be made.",
"freebuild_reference_object": "Please specify details of the thing that needs to be completed.",
"move_location": "Please specify details of where the assistant should move.",
"destroy_reference_object": "Please specify details of the thing that needs to be destroyed.",
"spawn_reference_object": "Please specify details of what the assistant should spawn / generate",
"spawn_location": "Please specify details of where the assistant should spawn / place",
"otheraction_reference_object": "Please specify details of the reference object",
"otheraction_location": "Please specify details of the location",
"fill_reference_object": "Please specify details of the thing that should be filled",
"tag_filters": "Please specify details of the thing that being tagged",
"tag_tag_val": "Please specify details of the tag",
"dance_location": "Please specify details of where the dance should happen.",
}
optional_words = {
"build": "construction",
"copy": "copying",
"spawn": "spawn",
"dig": "digging",
}
action_children = {
"build": ["schematic", "location"],
"copy": ["reference_object", "location"],
"freebuild": ["reference_object"],
"move": ["location"],
"spawn": ["reference_object", "location"],
"fill": ["reference_object"],
"destroy": ["reference_object"],
"dance": ["location"],
"dig": ["schematic", "location"],
"tag": ["filters", "tag_val"],
"otheraction": ["reference_object", "location"],
}
print(BEFORE)
for action in action_children.keys():
for child in action_children[action]:
question = get_questions(child, action, optional_words.get(action, None))
if question is not None:
id_value = action + "_" + child
sentence = initial_content[id_value]
render_output = (
"""<div style='font-size:16px;display:none' id='"""
+ id_value
+ """'> <b>"""
+ sentence
+ """</b>"""
)
if type(question) == list:
for i, q in enumerate(question):
render_output += render_questions_tool_2.render_q(
q, "root." + action, show=True
)
render_output += """</div><br><br>"""
print(render_output)
else:
render_output += render_questions_tool_2.render_q(
question, "root." + action, show=True
)
render_output += """</div><br><br>"""
print(render_output)
print(AFTER)
| craftassist-master | acl2020_submission/annotation_tools/tools/annotation_tool_2.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
LOCATION_RADIO = [
{"text": "Not specified", "key": None},
{
"text": "Represented using word(s) that indicate reference to a location (e.g. 'there', 'here', 'over there' etc)",
"key": "coref_resolve_check",
"tooltip": "e.g. 'there', 'here', 'over there' etc",
"next": [
{
"text": "What are the word(s) representing the location?",
"key": "yes.coref_resolve",
"span": True,
}
],
},
{"text": "Where the speaker is looking (e.g. 'where I am looking')", "key": "SPEAKER_LOOK"},
{"text": "Where the speaker is standing (e.g. 'by me', 'where I am')", "key": "SpeakerPos"},
{
"text": "Where the assistant is standing (e.g. 'by you', 'where you are', 'where you are standing')",
"key": "AGENT_POS",
},
{
"text": "Somewhere relative to another object(s) / area(s)",
"key": "REFERENCE_OBJECT",
"next": [
{
"text": "In terms of number of steps, how many ?",
"key": "steps",
"span": True,
"optional": True,
},
{
"text": "Where in relation to the other object(s)?",
"key": "relative_direction",
"radio": [
{"text": "Left", "key": "LEFT"},
{"text": "Right", "key": "RIGHT"},
{"text": "Above", "key": "UP"},
{"text": "Below", "key": "DOWN"},
{"text": "In front", "key": "FRONT"},
{"text": "Behind", "key": "BACK"},
{"text": "Away from", "key": "AWAY"},
{"text": "Inside", "key": "INSIDE"},
{"text": "Outside", "key": "OUTSIDE"},
{"text": "Nearby or close to", "key": "NEAR"},
{"text": "Around", "key": "AROUND"},
{"text": "Exactly at", "key": "EXACT"},
],
},
{
"text": "Are there words or pronouns that represent the relative object (e.g. 'this', 'that', 'these', 'those', 'it' etc)?",
"key": "coref_resolve_check",
"tooltip": "e.g. 'this', 'that', 'these', 'those', 'it' etc",
"radio": [
{
"text": "Yes",
"key": "yes",
"next": [
{
"text": "What is the word / pronoun representing the object?",
"key": "coref_resolve",
"span": True,
}
],
},
{
"text": "No",
"key": "no",
"next": [
{
"text": "What is the name of the relative object(s) or area?",
"key": "has_name",
"span": True,
}
],
},
],
},
],
},
]
"""
{
"text": "Can this object(s) be represented using a pronoun? If so, what is it",
"key": "reference_object.coref_resolve",
"span": True,
"optional": True,
},
"""
REF_OBJECT_OPTIONALS = [
{
"text": "What is the building material?",
"key": "reference_object.has_block_type",
"span": True,
"optional": True,
},
{
"text": "What is the color?",
"key": "reference_object.has_colour",
"span": True,
"optional": True,
},
{
"text": "What is the size?",
"key": "reference_object.has_size",
"span": True,
"optional": True,
},
{
"text": "What is the width?",
"key": "reference_object.has_width",
"span": True,
"optional": True,
},
{
"text": "What is the height?",
"key": "reference_object.has_height",
"span": True,
"optional": True,
},
{
"text": "What is the depth?",
"key": "reference_object.has_depth",
"span": True,
"optional": True,
},
]
Q_ACTION = {
"text": 'What action is being instructed? If multiple separate actions are being instructed (e.g. "do X and then do Y"), select "Multiple separate actions"',
"key": "action_type",
"add_radio_other": False,
"radio": [
# BUILD
{
"text": "Build, copy or complete something",
"key": "BUILD",
"next": [
{
"text": "Is this an exact copy or duplicate of an existing object?",
"key": "COPY",
"add_radio_other": False,
"radio": [
# COPY
{
"text": "Yes",
"key": "yes",
"next": [
{
"text": "Are there words or pronouns that indicate reference to the object to be copied (e.g. 'this', 'that', 'these', 'those', 'it' etc)",
"key": "reference_object.coref_resolve_check",
"tooltip": "e.g. 'this', 'that', 'these', 'those', 'it' etc",
"add_radio_other": False,
"radio": [
{
"text": "Yes",
"key": "yes",
"next": [
{
"text": "What is the word / pronoun representing the object?",
"key": "coref_resolve",
"span": True,
}
],
},
{
"text": "No",
"key": "no",
"next": [
{
"text": "What is the name of the object that should be copied?",
"key": "has_name",
"span": True,
}
],
},
],
},
*REF_OBJECT_OPTIONALS,
# {
# "text": "What is the location of the object to be copied?",
# "key": "location",
# "radio": LOCATION_RADIO,
# },
],
},
# BUILD
{
"text": "No",
"key": "no",
"next": [
{
"text": "Is the assistant being asked to...",
"key": "FREEBUILD",
"add_radio_other": False,
"radio": [
{
"text": "Build a fresh complete, specific object",
"key": "BUILD",
"next": [
{
"text": "What is the name of the thing to be built ?",
"key": "schematic.has_name",
"span": True,
},
{
"text": "What is the building material (what should it be built out of)?",
"key": "schematic.has_block_type",
"span": True,
"optional": True,
},
{
"text": "What is the size?",
"key": "schematic.has_size",
"span": True,
"optional": True,
},
{
"text": "What is the width?",
"key": "schematic.has_width",
"span": True,
"optional": True,
},
{
"text": "What is the colour ?",
"key": "schematic.has_colour",
"span": True,
"optional": True,
},
{
"text": "What is the height?",
"key": "schematic.has_height",
"span": True,
"optional": True,
},
{
"text": "What is the depth?",
"key": "schematic.has_depth",
"span": True,
"optional": True,
},
{
"text": "What is the thickness?",
"key": "schematic.has_thickness",
"span": True,
"optional": True,
},
],
},
{
"text": "Help complete or finish an already existing object",
"key": "FREEBUILD",
"next": [
{
"text": "Are there word(s) / pronouns that indicate reference to the object to be completed (e.g. 'this', 'that', 'these', 'those', 'it' etc)?",
"key": "reference_object.coref_resolve_check",
"add_radio_other": False,
"tooltip": "e.g. 'this', 'that', 'these', 'those', 'it' etc",
"radio": [
{
"text": "Yes",
"key": "yes",
"next": [
{
"text": "What is the word / pronoun representing the object?",
"key": "coref_resolve",
"span": True,
}
],
},
{
"text": "No",
"key": "no",
"next": [
{
"text": "What is the name of the object that should be completed?",
"key": "has_name",
"span": True,
}
],
},
],
},
*REF_OBJECT_OPTIONALS,
],
},
],
}
],
},
],
},
{
"text": "Where should the construction / copying / completion happen?",
"key": "location",
"radio": LOCATION_RADIO,
},
],
},
# MOVE
{
"text": "Move or walk somewhere",
"key": "MOVE",
"next": [
{
"text": "Where should the assistant move to?",
"key": "location",
"radio": LOCATION_RADIO,
}
],
},
# SPAWN
{
"text": "Spawn something",
"key": "SPAWN",
"next": [
{
"text": "What is the name of the object that should be spawned?",
"key": "reference_object.has_name",
"span": True,
}
],
},
# DESTROY
{
"text": "Destroy, remove, or kill something",
"key": "DESTROY",
"next": [
{
"text": "Are there word(s) / pronouns that indicate reference to the object to be destroyed (e.g. 'this', 'that', 'these', 'those', 'it' etc)?",
"key": "reference_object.coref_resolve_check",
"tooltip": "e.g. 'this', 'that', 'these', 'those', 'it' etc",
"radio": [
{
"text": "Yes",
"key": "yes",
"next": [
{
"text": "What is the word / pronoun representing the object?",
"key": "coref_resolve",
"span": True,
}
],
},
{
"text": "No",
"key": "no",
"next": [
{
"text": "What is the name of the object that should be destroyed?",
"key": "has_name",
"span": True,
}
],
},
],
},
*REF_OBJECT_OPTIONALS,
{
"text": "What is the location of the object to be removed?",
"key": "location",
"radio": LOCATION_RADIO,
},
],
},
# DIG
{
"text": "Dig",
"key": "DIG",
"next": [
{
"text": "Where should the digging happen ?",
"key": "location",
"radio": LOCATION_RADIO,
},
{
"text": "What is the size of the thing to be dug?",
"key": "has_size",
"span": True,
"optional": True,
},
{
"text": "What is the width of the thing to be dug?",
"key": "has_width",
"span": True,
"optional": True,
},
{
"text": "What is the height of the thing to be dug?",
"key": "has_length",
"span": True,
"optional": True,
},
{
"text": "What is the depth of the thing to be dug?",
"key": "has_depth",
"span": True,
"optional": True,
},
],
},
# FILL
{
"text": "Fill something",
"key": "FILL",
"next": [
{
"text": "Where is the thing that should be filled ?",
"key": "location",
"radio": LOCATION_RADIO,
},
{
"text": "What should the thing be filled with?",
"key": "has_block_type",
"span": True,
"optional": True,
},
*REF_OBJECT_OPTIONALS,
],
},
# TAG
{
"text": "Assign a description, name, or tag to an object",
"key": "TAG",
"tooltip": "e.g. 'That thing is fluffy' or 'The blue building is my house'",
"next": [
{
"text": "What is the description, name, or tag being assigned?",
"key": "tag",
"span": True,
},
{
"text": "What object is being assigned a description, name, or tag?",
"key": "reference_object",
},
*REF_OBJECT_OPTIONALS,
{
"text": "What is the location of the object to be described, named, or tagged?",
"key": "location",
"radio": LOCATION_RADIO,
},
],
},
# STOP
{
"text": "Stop an action",
"key": "STOP",
"next": [
{
"text": "Is this a command to stop a particular action?",
"key": "target_action_type",
"radio": [
{"text": "Building or copying", "key": "BUILD"},
{"text": "Moving", "key": "MOVE"},
{"text": "Destroying", "key": "DESTROY"},
{"text": "Digging", "key": "DIG"},
{"text": "Filling", "key": "FILL"},
],
}
],
},
# RESUME
{
"text": "Resume an action",
"key": "RESUME",
"next": [
{
"text": "Is this a command to resume a particular action?",
"key": "target_action_type",
"radio": [
{"text": "Building or copying", "key": "BUILD"},
{"text": "Moving", "key": "MOVE"},
{"text": "Destroying", "key": "DESTROY"},
{"text": "Digging", "key": "DIG"},
{"text": "Filling", "key": "FILL"},
],
}
],
},
# UNDO
{
"text": "Undo or revert an action",
"key": "UNDO",
"next": [
{
"text": "Is this a command to undo a particular action?",
"key": "target_action_type",
"radio": [
{"text": "Building", "key": "BUILD"},
{"text": "Destroying", "key": "DESTROY"},
{"text": "Digging", "key": "DIG"},
{"text": "Filling", "key": "FILL"},
],
}
],
},
# ANSWER QUESTION
{
"text": "Answer a question",
"key": "ANSWER",
"tooltip": "e.g. 'How many trees are there?' or 'Tell me how deep that tunnel goes'",
"next": [
{
"text": "What is being asked about ?",
"key": "filters",
"radio": [
{
"text": "Where the assistant is heading",
"key": "type.AGENT.move_target", # assign TAG, move_target
},
{
"text": "Where the assistant is currently located",
"key": "type.AGENT.location", # assign TAG, location
},
{
"text": "Name of the action the assistant is performing",
"key": "type.ACTION.action_name", # assign TAG, action_name
},
{
"text": "Name of the object that an action is being performed on",
"key": "type.ACTION.action_reference_object_name", # # assign TAG, action_reference_object_name
"next": [
{
"text": "Which action is being asked about?",
"key": "action_type",
"radio": [
{"text": "Building", "key": "BUILD"},
{"text": "Destroying", "key": "DETSROY"},
{"text": "Digging", "key": "DIG"},
{"text": "Filling", "key": "FILL"},
{"text": "Spawning", "key": "SPAWN"},
{"text": "Moving", "key": "MOVE"},
],
}
],
},
{
"text": "Questions related to a specific object(s) / area(s)",
"key": "type.REFERENCE_OBJECT",
"next": [
{
"text": "Is this a yes/no question ?",
"key": "answer_type",
"radio": [
{"text": "Yes this is a yes/no question", "key": "EXISTS"},
{
"text": "No some specific attribute is being asked about",
"key": "TAG",
"next": [
{
"text": "What exactly is being asked about",
"key": "tag_name",
"radio": [
{"text": "The name", "key": "has_name"},
{"text": "The size", "key": "has_size"},
{
"text": "The colour",
"key": "has_colour",
},
],
}
],
},
],
},
{
"text": "Are there words or pronouns that represent the object being talked about(e.g. 'this', 'that', 'these', 'those', 'it' etc)?",
"key": "coref_resolve_check",
"tooltip": "e.g. 'this', 'that', 'these', 'those', 'it' etc",
"radio": [
{
"text": "Yes",
"key": "yes",
"next": [
{
"text": "What is the word / pronoun representing the object?",
"key": "coref_resolve",
"span": True,
}
],
},
{
"text": "No",
"key": "no",
"next": [
{
"text": "What is the name of the object(s) being asked about?",
"key": "has_name",
"span": True,
}
],
},
],
},
{
"text": "Is the building material being asked about?",
"key": "has_block_type",
"span": True,
"optional": True,
},
{
"text": "Is the color of the object being asked about?",
"key": "has_colour",
"span": True,
"optional": True,
},
{
"text": "Is the size of the object being asked about?",
"key": "has_size",
"span": True,
"optional": True,
},
{
"text": "Is the width of the object being asked about?",
"key": "has_width",
"span": True,
"optional": True,
},
{
"text": "Is the height of the object being asked about?",
"key": "has_height",
"span": True,
"optional": True,
},
{
"text": "Is the depth of the object being asked about?",
"key": "has_depth",
"span": True,
"optional": True,
},
],
},
],
}
],
},
# OTHER ACTION NOT LISTED
{
"text": "Another action not listed here",
"key": "OtherAction",
"tooltip": "The sentence is a command, but not one of the actions listed here",
"next": [
{
"text": "What object (if any) is the target of this action? e.g. for the sentence 'Sharpen this axe', select the word 'axe'",
"key": "reference_object.has_name",
"span": True,
},
*REF_OBJECT_OPTIONALS,
{
"text": "Where should the action take place?",
"key": "location",
"radio": LOCATION_RADIO,
},
],
},
# NOT ACTION
{
"text": "This sentence is not a command or request to do something",
"key": "NOOP",
"tooltip": "e.g. 'Yes', 'Hello', or 'What a nice day it is today'",
},
# MULTIPLE ACTIONS
{
"text": "Multiple separate actions",
"key": "COMPOSITE_ACTION",
"tooltip": "e.g. 'Build a cube and then run around'. Do not select this for a single repeated action, e.g. 'Build 5 cubes'",
},
],
}
REPEAT_DIR = [
{"text": "Not specified", "key": None},
{"text": "Forward", "key": "FRONT"},
{"text": "Backward", "key": "BACK"},
{"text": "Left", "key": "LEFT"},
{"text": "Right", "key": "RIGHT"},
{"text": "Up", "key": "UP"},
{"text": "Down", "key": "DOWN"},
{"text": "Around", "key": "AROUND"},
]
Q_ACTION_LOOP = {
"text": "How many times should this action be performed?",
"key": "loop",
"radio": [
{"text": "Just once, or not specified", "key": None},
{
"text": "Repeatedly, a specific number of times",
"key": "ntimes",
"next": [
{"text": "How many times?", "span": True, "key": "repeat_for"},
{
"text": "In which direction should the action be repeated?",
"key": "repeat_dir",
"radio": REPEAT_DIR,
},
],
},
{
"text": "Repeatedly, once for every object or for all objects",
"key": "repeat_all",
"tooltip": "e.g. 'Destroy the red blocks', or 'Build a shed in front of each house'",
"next": [
{
"text": "In which direction should the action be repeated?",
"key": "repeat_dir",
"radio": REPEAT_DIR,
}
],
},
{
"text": "Repeated forever",
"key": "forever",
"tooltip": "e.g. 'Keep building railroad tracks in that direction' or 'Collect diamonds until I tell you to stop'",
},
{
"text": "Repeated until a certain condition is met",
"key": "repeat_until",
# "tooltip": "e.g. 'Dig until you hit bedrock', 'Keep walking until you reach water'",
"next": [
{
"text": "Until the assistant reaches some object(s) /area",
"key": "adjacent_to_block_type",
"span": True,
}
],
},
],
}
| craftassist-master | acl2020_submission/annotation_tools/tools/all_question_flows.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import csv
def any_two(a, b, c):
return a == b or a == c or b == c
with open("Batch_3449808_batch_results.csv", "r") as f:
r = csv.DictReader(f)
r = [d for d in r]
whittled = [
{k: v for k, v in d.items() if (k.startswith("Answer.") or k == "Input.command") and v != ""}
for d in r
]
with open("results.tmp", "r") as f:
processed = f.readlines()
assert len(processed) == len(whittled)
faulty_processed_idxs = []
for i in range(181):
if not any_two(processed[3 * i], processed[3 * i + 1], processed[3 * i + 2]):
print(i)
print(whittled[3 * i])
# print(processed[3*i], processed[3*i+1], processed[3*i+2], '', sep='\n')
faulty_processed_idxs.append(i)
# for i in faulty_processed_idxs:
# print(whittled[3*i], whittled[3*i], whittled[3*i], '', sep='\n')
| craftassist-master | acl2020_submission/annotation_tools/tools/analyze_outputs.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
import re
def render_q(q, parent_id, show=True, show_siblings=True):
"""Return a fieldset for the given question"""
assert "key" in q, "Missing key for q: {}".format(q)
r = ""
q_id = "{}.{}".format(parent_id, q["key"])
r += '<fieldset id="{}" style="display:{}">'.format(q_id, "block" if show else "none")
r += label_tag(tooltip=q.get("tooltip")) + q["text"] + "</label>"
if "radio" in q:
r += render_radios(
q["radio"],
q_id,
add_other_opt=q.get("add_radio_other", True),
show_siblings=show_siblings,
make_checkbox=q.get("checkbox", False),
)
if "span" in q:
r += render_span(q_id, q.get("optional"))
r += "</fieldset>"
return r
def render_span(parent_id, optional=False):
r = ""
group_id = "{}.span".format(parent_id)
if optional:
onclick = """var x = document.getElementById('{}');
x.style.display = x.style.display == 'block' ? 'none' : 'block';""".format(
group_id
)
r += """<label class="btn btn-primary btn-sm" onclick="{}"
style="margin-left:10px">Click and select all words if specified</label>""".format(
onclick
)
r += '<div id="{}" class="btn-group" data-toggle="buttons" style="display:{}">'.format(
group_id, "none" if optional else "block"
)
for i in range(40):
input_id = "{}#{}".format(group_id, i)
r += """<label class="btn btn-default word{i}"
name="{input_id}">""".format(
input_id=input_id, i=i
)
r += '<input type="checkbox" autocomplete="off" id="{input_id}" \
name="{input_id}">${{word{i}}}'.format(
input_id=input_id, i=i
)
r += "</label>"
r += "</div>"
return r
def render_radios(opts, parent_id, add_other_opt=True, show_siblings=True, make_checkbox=False):
if add_other_opt:
opts = opts + [{"text": "Other", "key": "Other"}]
r = ""
suffix = ""
for i, opt in enumerate(opts):
opt_id = "{}.{}".format(parent_id, opt["key"])
nexts = opt.get("next", [])
# render child questions
suffix += (
'<div id="{}.next" style="display:none">'.format(opt_id)
+ "\n".join([render_q(n, opt_id) for n in nexts])
+ "</div>"
)
# get onchange function
sibling_ids = ["{}.{}".format(parent_id, o["key"]) for o in opts]
# child_ids = ["{}.{}".format(opt_id, n["key"]) for n in nexts]
onchange = "\n".join(
[
"""
console.log('Toggling {sid}');
if (document.getElementById('{sid}.next')) {{
document.getElementById('{sid}.next').style.display = \
document.getElementById('{sid}').checked ? 'block' : 'none';
}}
""".format(
sid=sid
)
for sid in sibling_ids
]
)
if not show_siblings:
onchange += "\n".join(
[
"""
console.log('Hiding siblings {sid}');
if (document.getElementById('div_{sid}')) {{
document.getElementById('div_{sid}').style.display = \
document.getElementById('{sid}').checked ? 'block' : 'none';
}}
""".format(
sid=sid
)
for sid in sibling_ids
]
)
# produce div for single option
r += '<div class="radio" id="div_{}">'.format(opt_id) + label_tag(opt.get("tooltip"))
radio_name = parent_id + str(i) if make_checkbox else parent_id
r += """<input name="{}"
id="{}"
type="radio"
value="{}"
onchange="{}"
/>""".format(
radio_name, opt_id, opt["key"], onchange
)
r += opt["text"]
r += "</label></div>"
return r + suffix
def label_tag(tooltip=None):
if tooltip:
return '<label data-toggle="tooltip" data-placement="right" title="{}">'.format(tooltip)
else:
return "<label>"
def child_id(parent_id, text):
return parent_id + "." + re.sub(r"[^a-z]+", "-", text.lower().strip()).strip("-")
| craftassist-master | acl2020_submission/annotation_tools/tools/render_questions_tool_2.py |
"""
Copyright (c) Facebook, Inc. and its affiliates.
"""
Q_ACTION = {
"text": 'What action is being requested? If multiple separate actions are being requested (e.g. "do X and then do Y"), select "Multiple separate actions"',
"key": "action_type",
"tooltip": "e.g. in 'Make few copies of the cube' it is : 'Build, make a copy or complete something'",
"add_radio_other": False,
"radio": [
# BUILD
{
"text": "Build, make a copy or complete something",
"key": "BUILD",
"tooltip": "The sentence requests construction or making copies of some object",
"next": [
{
"text": "Is this exact copy or duplicate of something that already exists?",
"key": "COPY",
"add_radio_other": False,
"radio": [
# COPY
{
"text": "Yes",
"key": "yes",
"next": [
{
"text": "Select words specifying the thing that needs to be copied",
"key": "reference_object",
"tooltip": "e.g. in 'Make 5 copies of the white sheep and put them behind the house' select 'the white sheep'",
"optional": True,
"span": True,
},
{
"text": "Select words specifying where the copy should be made",
"key": "location",
"tooltip": "e.g. in 'Make 5 copies of the white sheep and put them behind the house' select 'behind the house'",
"span": True,
"optional": True,
},
],
},
# BUILD
{
"text": "No",
"key": "no",
"next": [
{
"text": "Is the assistant being asked to...",
"key": "FREEBUILD",
"add_radio_other": False,
"radio": [
# Build
{
"text": "Build a specific object or objects from scratch",
"key": "BUILD",
"next": [
{
"text": "Select words specifying what needs to be built",
"key": "schematic",
"tooltip": "e.g. in 'construct two big wooden houses in front of the tower' select 'big wooden houses'",
"span": True,
},
{
"text": "Select words specifying where the thing should be built",
"key": "location",
"tooltip": "e.g. in 'construct two big wooden houses in front of the tower' select 'in front of the tower'",
"span": True,
"optional": True,
},
],
},
# Freebuild
{
"text": "Help complete or finish already existing object(s)",
"key": "FREEBUILD",
"next": [
{
"text": "Select words specifying what needs to be completed",
"key": "reference_object",
"tooltip": "e.g. in 'complete that for me please' select 'that'",
"span": True,
}
],
},
],
}
],
},
],
}
],
}, # Build , copy, freebuild finishes
# MOVE
{
"text": "Move or walk somewhere",
"key": "MOVE",
"tooltip": "The assistant is being asked to move",
"next": [
{
"text": "Select words specifying the location to which the agent should move",
"key": "location",
"span": True,
"tooltip": "e.g. in 'go to the sheep' select 'to the sheep'",
}
],
}, # MOVE finishes
# SPAWN
{
"text": "Spawn something (place an animal or creature in the game world)",
"key": "SPAWN",
"tooltip": "for example 'spawn a pig'.",
"next": [
{
"text": "Select words specifying what needs to be spawned",
"key": "reference_object",
"span": True,
"tooltip": "e.g. in 'spawn a pig' select 'a pig' or 'pig'",
},
{
"text": "Select words specifying where to spawn",
"key": "location",
"optional": True,
"span": True,
"tooltip": "e.g. in 'spawn a pig behind the house' select 'behind the house'",
},
],
},
# DESTROY
{
"text": "Destroy, remove, or kill something",
"key": "DESTROY",
"tooltip": "Something needs to be destroyed.",
"next": [
{
"text": "Select words specifying what needs to be destroyed",
"key": "reference_object",
"span": True,
"tooltip": "e.g. in 'destroy the red cube over there' select 'red cube over there'",
}
],
},
# DIG
{
"text": "Dig",
"key": "DIG",
"tooltip": "Digging of some kind needs to be done",
"next": [
{
"text": "Select words specifying what needs to be dug",
"key": "schematic",
"optional": True,
"tooltip": "e.g. in 'dig a big circular hole over there' select 'big circular hole'",
"span": True,
},
{
"text": "Select words specifying where the thing will be dug",
"key": "location",
"optional": True,
"span": True,
"tooltip": "e.g. in 'dig a big hole over there' select 'over there'",
},
],
},
# FILL
{
"text": "Fill something",
"key": "FILL",
"tooltip": "Fill or cover an object/area with something",
"next": [
{
"text": "Select words specifying what needs to be filled",
"key": "reference_object",
"span": True,
"tooltip": "e.g. in 'fill the mine with diamonds' select 'mine'",
},
{
"text": "Select words specifying what material is used for filling",
"key": "has_block_type",
"optional": True,
"span": True,
"tooltip": "e.g. in 'fill the mine with diamonds' select 'diamonds'",
},
],
},
# Tag
{
"text": "Assign a description, name, or tag to an object",
"key": "TAG",
"tooltip": "e.g. 'That thing is fluffy' or 'The blue building is my house'",
"next": [
{
"text": "Select words specifying the object that is being tagged",
"key": "filters",
"span": True,
"tooltip": "e.g. in 'this is bright' select 'this'",
},
{
"text": "Select words specifying the description or tag being assigned",
"key": "tag_val",
"span": True,
"tooltip": "e.g. in 'this is bright' select 'bright'",
},
],
},
# Answer
{
"text": "Answer a question",
"key": "ANSWER",
"tooltip": "e.g. 'How many trees are there?' or 'Tell me how deep that tunnel goes'",
},
# Dance
{
"text": "A movement where the path or step-sequence is more important than the destination",
"key": "DANCE",
"tooltip": "Dance or movement where the path is more important than the destination, e.g. go around the cube 4 times",
"next": [
{
"text": "Select words specifying where the dance needs to happen",
"key": "location",
"optional": True,
"span": True,
"tooltip": "e.g. in 'dance in front of the cube' select 'in front of the cube'",
}
],
},
# STOP
{
"text": "Stop an action",
"key": "STOP",
"tooltip": "Stop or pause something",
"next": [
{
"text": "Select words specifying which action needs to be stopped",
"key": "target_action_type",
"optional": True,
"span": True,
"tooltip": "e.g. in 'stop digging' select 'digging'",
}
],
},
# RESUME
{
"text": "Resume an action",
"key": "RESUME",
"tooltip": "Resume or continue something",
"next": [
{
"text": "Select words specifying which action needs to be resumed",
"key": "target_action_type",
"optional": True,
"span": True,
"tooltip": "e.g. in 'continue walking' select 'walking'",
}
],
},
# UNDO
{
"text": "Undo or revert an action",
"key": "UNDO",
"tooltip": "Undo a previously completed action",
"next": [
{
"text": "Select words specifying which action needs to be reverted",
"key": "target_action_type",
"optional": True,
"span": True,
"tooltip": "e.g. in 'undo what you built' select 'what you built'",
}
],
},
# MULTIPLE ACTIONS
{
"text": "Multiple separate actions",
"key": "COMPOSITE_ACTION",
"tooltip": "e.g. 'Build a cube and then run around'. Do not select this for a single repeated action, e.g. 'Build 5 cubes'",
},
# OTHER ACTION NOT LISTED
{
"text": "Another action not listed here",
"key": "OtherAction",
"tooltip": "In case the given sentence is a command, but not one of the command types listed above, please click this",
"next": [
{
"text": "What object (if any) is the target of this action?",
"key": "reference_object",
"span": True,
"optional": True,
"tooltip": "e.g. in 'Sharpen the axe behind me', select 'axe'",
},
{
"text": "Where should the action take place?",
"key": "location",
"span": True,
"optional": True,
"tooltip": "e.g. in 'Sharpen the axe behind me', select 'behind me'",
},
],
},
# NOT ACTION
{
"text": "This sentence is not a command or request to do something",
"key": "NOOP",
"tooltip": "In case the given sentence is not a command or request to do something, please click this",
},
],
}
REPEAT_DIR = [
{"text": "Not specified", "key": None, "tooltip": "The direction isn't specified"},
{
"text": "Forward",
"key": "FRONT",
"tooltip": "Repetition towards the front / forward direction",
},
{"text": "Backward", "key": "BACK", "tooltip": "Repetition towards the back"},
{"text": "Left", "key": "LEFT", "tooltip": "Repetition to the left"},
{"text": "Right", "key": "RIGHT", "tooltip": "Repetition to the left"},
{"text": "Up", "key": "UP", "tooltip": "Repetition upwards"},
{"text": "Down", "key": "DOWN", "tooltip": "Repetition downward"},
{"text": "Around", "key": "AROUND", "tooltip": "Repetition around"},
]
Q_ACTION_LOOP = {
"text": "How many times should this action be performed?",
"key": "loop",
"tooltip": "Does the above action or any part of it need to be repeated ?",
"add_radio_other": False,
"radio": [
{
"text": "Just once, or not specified",
"key": None,
"tooltip": "No repeats needed, it needs to be done exactly once.",
},
{
"text": "Repeatedly, a specific number of times",
"key": "ntimes",
"tooltip": "The action needs to be repeated a fixed number of times",
"next": [
{
"text": "How many times? Select all words",
"span": True,
"key": "repeat_for",
"tooltip": "e.g. in 'go around the cube twice' select 'twice'",
},
{
"text": "In which direction should the action be repeated?",
"key": "repeat_dir",
"radio": REPEAT_DIR,
"tooltip": "e.g. in 'go around the cube twice' select 'Around'",
},
],
},
{
"text": "Repeatedly, once for every object or for all objects",
"key": "repeat_all",
"tooltip": "e.g. 'Destroy every red block', or 'Build a shed in front of each house'",
"next": [
{
"text": "In which direction should the action be repeated?",
"key": "repeat_dir",
"radio": REPEAT_DIR,
"tooltip": "e.g. in 'stack 5 blocks' select 'Up' since stacking is done upwards",
}
],
},
{
"text": "Repeated forever",
"key": "forever",
"tooltip": "e.g. 'Keep building railroad tracks in that direction' or 'Collect diamonds until I tell you to stop'",
},
{
"text": "Repeated until a certain condition is met",
"key": "repeat_until",
"tooltip": "e.g. 'Dig until you hit bedrock', 'Keep walking until you reach water'",
"next": [
{
"text": "Until the assistant reaches a specific object(s) / area",
"key": "adjacent_to_block_type",
"optional": True,
"tooltip": "e.g. in 'Dig until you hit bedrock' select 'bedrock'",
"span": True,
},
{
"text": "Until some other condition is met",
"key": "condition_span",
"optional": True,
"tooltip": "e.g. in 'Keep building until it is sundown' select 'it is sundown'",
"span": True,
},
],
},
],
}
| craftassist-master | acl2020_submission/annotation_tools/tools/question_flow_for_step_1.py |
import argparse
import functools
import json
import logging
import logging.handlers
import os
import pickle
from os.path import isfile
from os.path import join as pjoin
from glob import glob
from tqdm import tqdm
from time import time
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler
from transformers import AutoModel, AutoTokenizer, BertConfig
from utils_parsing import *
from utils_caip import *
# training loop (all epochs at once)
def train(model, dataset, tokenizer, args):
# make data sampler
train_sampler = RandomSampler(dataset)
model_collate_fn = functools.partial(caip_collate, tokenizer=tokenizer)
train_dataloader = DataLoader(
dataset, sampler=train_sampler, batch_size=args.batch_size, collate_fn=model_collate_fn
)
epoch_iterator = tqdm(train_dataloader, desc="Iteration", disable=True)
# make optimizer
optimizer = OptimWarmupEncoderDecoder(model, args)
# training loop
for e in range(args.num_epochs):
loc_steps = 0
loc_loss = 0.0
loc_int_acc = 0.0
loc_span_acc = 0.0
loc_full_acc = 0.0
tot_steps = 0
tot_loss = 0.0
tot_accuracy = 0.0
st_time = time()
for step, batch in enumerate(epoch_iterator):
batch_examples = batch[-1]
batch_tensors = [
t.to(model.decoder.lm_head.predictions.decoder.weight.device) for t in batch[:4]
]
x, x_mask, y, y_mask = batch_tensors
outputs = model(x, x_mask, y, y_mask)
loss = outputs["loss"]
# backprop
loss.backward()
if step % args.param_update_freq == 0:
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
model.zero_grad()
# compute accuracy and add hard examples
lm_acc, sp_acc, full_acc = compute_accuracy(outputs, y)
if "hard" in dataset.dtypes:
if e > 0 or tot_steps > 2 * args.decoder_warmup_steps:
for acc, exple in zip(lm_acc, batch_examples):
if not acc.item():
if step % 200 == 100:
print("ADDING HE:", step, exple[0])
dataset.add_hard_example(exple)
# book-keeping
loc_int_acc += lm_acc.sum().item() / lm_acc.shape[0]
loc_span_acc += sp_acc.sum().item() / sp_acc.shape[0]
loc_full_acc += full_acc.sum().item() / full_acc.shape[0]
tot_accuracy += full_acc.sum().item() / full_acc.shape[0]
loc_loss += loss.item()
loc_steps += 1
tot_loss += loss.item()
tot_steps += 1
if step % 400 == 0:
print(
"{:2d} - {:5d} \t L: {:.3f} A: {:.3f} \t {:.2f}".format(
e, step, loc_loss / loc_steps, loc_full_acc / loc_steps, time() - st_time
)
)
logging.info(
"{:2d} - {:5d} \t L: {:.3f} A: {:.3f} \t {:.2f}".format(
e, step, loc_loss / loc_steps, loc_full_acc / loc_steps, time() - st_time
)
)
loc_loss = 0
loc_steps = 0
loc_int_acc = 0.0
loc_span_acc = 0.0
loc_full_acc = 0.0
return (tot_loss / tot_steps, tot_accuracy / tot_steps)
# same as training loop without back-propagation
def validate(model, dataset, tokenizer, args):
# make data sampler
train_sampler = SequentialSampler(dataset)
model_collate_fn = functools.partial(caip_collate, tokenizer=tokenizer)
train_dataloader = DataLoader(
dataset, sampler=train_sampler, batch_size=args.batch_size, collate_fn=model_collate_fn
)
epoch_iterator = tqdm(train_dataloader, desc="Iteration", disable=True)
# training loop
tot_steps = 0
tot_loss = 0.0
tot_int_acc = 0.0
tot_span_acc = 0.0
tot_accu = 0.0
for step, batch in enumerate(epoch_iterator):
batch_tensors = [
t.to(model.decoder.lm_head.predictions.decoder.weight.device) for t in batch[:4]
]
x, x_mask, y, y_mask = batch_tensors
outputs = model(x, x_mask, y, y_mask)
loss = outputs["loss"]
# compute accuracy and add hard examples
lm_acc, sp_acc, full_acc = compute_accuracy(outputs, y)
# book-keeping
tot_int_acc += lm_acc.sum().item() / lm_acc.shape[0]
tot_span_acc += sp_acc.sum().item() / sp_acc.shape[0]
tot_accu += full_acc.sum().item() / full_acc.shape[0]
tot_loss += loss.item()
tot_steps += 1
return (
tot_loss / tot_steps,
tot_int_acc / tot_steps,
tot_span_acc / tot_steps,
tot_accu / tot_steps,
)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--data_dir", default="reformatted_ttad_data", type=str, help="train/valid/test data"
)
parser.add_argument(
"--output_dir", default="caip_model_dir", type=str, help="Where we save the model"
)
parser.add_argument("--model_name", default="caip_parser", type=str, help="Model name")
parser.add_argument(
"--tree_voc_file",
default="caip_tree_voc_final.json",
type=str,
help="Pre-computed grammar and output vocabulary",
)
# model arguments
parser.add_argument(
"--pretrained_encoder_name",
default="distilbert-base-uncased",
type=str,
help="Pretrained text encoder "
"See full list at https://huggingface.co/transformers/pretrained_models.html",
)
parser.add_argument(
"--num_decoder_layers",
default=6,
type=int,
help="Number of transformer layers in the decoder",
)
parser.add_argument(
"--num_highway", default=1, type=int, help="Number of highway layers in the mapping model"
)
# optimization arguments
parser.add_argument(
"--optimizer", default="adam", type=str, help="Optimizer in [adam|adagrad]"
)
parser.add_argument("--batch_size", default=64, type=int, help="Batch size")
parser.add_argument("--param_update_freq", default=1, type=int, help="Group N batch updates")
parser.add_argument("--num_epochs", default=2, type=int, help="Number of training epochs")
parser.add_argument(
"--examples_per_epoch", default=-1, type=int, help="Number of training examples per epoch"
)
parser.add_argument(
"--train_encoder", action="store_true", help="Whether to finetune the encoder"
)
parser.add_argument(
"--encoder_warmup_steps",
default=1,
type=int,
help="Learning rate warmup steps for the encoder",
)
parser.add_argument(
"--encoder_learning_rate", default=0.0, type=float, help="Learning rate for the encoder"
)
parser.add_argument(
"--decoder_warmup_steps",
default=1000,
type=int,
help="Learning rate warmup steps for the decoder",
)
parser.add_argument(
"--decoder_learning_rate", default=1e-4, type=float, help="Learning rate for the decoder"
)
parser.add_argument(
"--lambda_span_loss",
default=0.5,
type=float,
help="Weighting between node and span prediction losses",
)
parser.add_argument(
"--node_label_smoothing",
default=0.0,
type=float,
help="Label smoothing for node prediction",
)
parser.add_argument(
"--span_label_smoothing",
default=0.0,
type=float,
help="Label smoothing for span prediction",
)
parser.add_argument(
"--dtype_samples",
default='[["templated", 1.0]]',
type=str,
help="Sampling probabilities for handling different data types",
)
parser.add_argument(
"--rephrase_proba", default=-1.0, type=float, help="Only specify probablility of rephrases"
)
parser.add_argument(
"--word_dropout",
default=0.0,
type=float,
help="Probability of replacing input token with [UNK]",
)
parser.add_argument(
"--encoder_dropout", default=0.0, type=float, help="Apply dropout to encoder output"
)
args = parser.parse_args()
# HACK: allows us to give rephrase proba only instead of full dictionary
if args.rephrase_proba > 0:
args.dtype_samples = json.dumps(
[["templated", 1.0 - args.rephrase_proba], ["rephrases", args.rephrase_proba]]
)
# set up logging
l_handler = logging.handlers.WatchedFileHandler(
os.environ.get("LOGFILE", "logs/%s.log" % args.model_name.split("/")[-1])
)
l_format = logging.Formatter(fmt="%(asctime)s - %(message)s", datefmt="%d-%b-%y %H:%M:%S")
l_handler.setFormatter(l_format)
l_root = logging.getLogger()
l_root.setLevel(os.environ.get("LOGLEVEL", "INFO"))
l_root.addHandler(l_handler)
# make dataset
if isfile(args.tree_voc_file):
print("loading grammar")
logging.info("loading grammar")
full_tree, tree_i2w = json.load(open(args.tree_voc_file))
else:
print("making grammar")
logging.info("making grammar")
data = {"train": {}, "valid": {}, "test": {}}
for spl in data:
for fname in glob(pjoin(args.data_dir, "{}/*.json".format(spl))):
print(fname)
data[spl][fname.split("/")[-1][:-5]] = json.load(open(fname))
full_tree, tree_i2w = make_full_tree(
[
(d_list, 1.0)
for spl, dtype_dict in data.items()
for dtype, d_list in dtype_dict.items()
]
)
json.dump((full_tree, tree_i2w), open(args.tree_voc_file, "w"))
tokenizer = AutoTokenizer.from_pretrained(args.pretrained_encoder_name)
logging.info("loading data")
train_dataset = CAIPDataset(
tokenizer,
args,
prefix="train",
sampling=True,
word_noise=args.word_dropout,
full_tree_voc=(full_tree, tree_i2w),
)
# make model
logging.info("making model")
enc_model = AutoModel.from_pretrained(args.pretrained_encoder_name)
bert_config = BertConfig.from_pretrained("bert-base-uncased")
bert_config.is_decoder = True
bert_config.vocab_size = len(tree_i2w) + 8 # special tokens
bert_config.num_hidden_layers = args.num_decoder_layers
dec_with_loss = DecoderWithLoss(bert_config, args, tokenizer)
encoder_decoder = EncoderDecoderWithLoss(enc_model, dec_with_loss, args)
# train_model
logging.info("training model")
encoder_decoder = encoder_decoder.cuda()
encoder_decoder.train()
loss, accu = train(encoder_decoder, train_dataset, tokenizer, args)
# save model
json.dump(
(full_tree, tree_i2w), open(pjoin(args.output_dir, args.model_name + "_tree.json"), "w")
)
pickle.dump(args, open(pjoin(args.output_dir, args.model_name + "_args.pk"), "wb"))
torch.save(encoder_decoder.state_dict(), pjoin(args.output_dir, args.model_name + ".pth"))
# evaluate model
_ = encoder_decoder.eval()
logging.info("evaluating model")
valid_template = CAIPDataset(
tokenizer, args, prefix="valid", dtype="templated", full_tree_voc=(full_tree, tree_i2w)
)
l, _, _, a = validate(encoder_decoder, valid_template, tokenizer, args)
print("evaluating on templated valid: \t Loss: {:.4f} \t Accuracy: {:.4f}".format(l, a))
logging.info("evaluating on templated valid: \t Loss: {:.4f} \t Accuracy: {:.4f}".format(l, a))
valid_rephrase = CAIPDataset(
tokenizer, args, prefix="valid", dtype="rephrases", full_tree_voc=(full_tree, tree_i2w)
)
l, _, _, a = validate(encoder_decoder, valid_rephrase, tokenizer, args)
print("evaluating on rephrases valid: \t Loss: {:.4f} \t Accuracy: {:.4f}".format(l, a))
logging.info("evaluating on rephrases valid: \t Loss: {:.4f} \t Accuracy: {:.4f}".format(l, a))
valid_prompts = CAIPDataset(
tokenizer, args, prefix="valid", dtype="prompts", full_tree_voc=(full_tree, tree_i2w)
)
l, _, _, a = validate(encoder_decoder, valid_prompts, tokenizer, args)
print("evaluating on prompts valid: \t Loss: {:.4f} \t Accuracy: {:.4f}".format(l, a))
logging.info("evaluating on prompts valid: \t Loss: {:.4f} \t Accuracy: {:.4f}".format(l, a))
valid_humanbot = CAIPDataset(
tokenizer, args, prefix="valid", dtype="humanbot", full_tree_voc=(full_tree, tree_i2w)
)
l, _, _, a = validate(encoder_decoder, valid_humanbot, tokenizer, args)
print("evaluating on humanbot valid: \t Loss: {:.4f} \t Accuracy: {:.4f}".format(l, a))
logging.info("evaluating on humanbot valid: \t Loss: {:.4f} \t Accuracy: {:.4f}".format(l, a))
if __name__ == "__main__":
main()
| craftassist-master | acl2020_submission/model_training_code/train_model.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.