def learn_lexical_semantics(domain, seed=None):
from parsing import Grammar
print("#" * 80)
print("Learn lexical semantics experiment for domain: %s\n" %
domain.__class__.__name__)
original_grammar = domain.grammar()
expanded_rules = cartesian_product_of_lexical_rules(domain.rules())
grammar = Grammar(
rules=expanded_rules,
annotators=original_grammar.annotators,
start_symbol=original_grammar.start_symbol,
)
model = Model(
grammar=grammar,
feature_fn=domain.features,
weights=domain.weights,
executor=domain.execute,
)
train_test(
model=model,
train_examples=domain.train_examples(),
test_examples=domain.test_examples(),
metrics=domain.metrics(),
training_metric=domain.training_metric(),
seed=seed,
print_examples=False,
)
def parse_input(self, input):
parses = Grammar.parse_input(self, input)
consecutive, even, count = find_number_variables(input)
for parse in parses:
if isinstance(parse.semantics, tuple):
parse.semantics = [parse.semantics]
parse.semantics.insert(0, ('numvars', count))
if consecutive:
parse.semantics.insert(0, ('consecutive', True))
if even == True or even == False:
parse.semantics.insert(0, ('even', even))
return parses
def parse_input(self, input):
parses = Grammar.parse_input(self, input)
consecutive, even, count = find_number_variables(input)
for parse in parses:
if isinstance(parse.semantics, tuple):
parse.semantics = [parse.semantics]
parse.semantics.insert(0, ('numvars', count))
if consecutive:
parse.semantics.insert(0, ('consecutive', True))
if even == True or even == False:
parse.semantics.insert(0, ('even', even))
return parses
def grammar(self):
return Grammar(rules=self.rules(), start_symbol='$E')
#Rule('$Person','$Loction $Person', lambda sems: (sems[1],"born("+sems[1]+") = " + sems[0])),
Rule('$Person', '$Loction $Person', lambda sems: (sems[0], sems[1])),
Rule('$Which', '哪个', '哪个'),
Rule('$Person', '$Which $Person', lambda sems: sems[1]),
Rule('$Relation', '$FwdRelation', lambda sems: (lambda arg:
(sems[0], arg))),
Rule('$FwdRelation', '父亲', '父亲'),
Rule('$FwdRelation', '儿子', '儿子'),
Rule('$FwdRelation', '老公', '老公'),
Rule('$FwdRelation', '歌曲', '歌曲'),
Rule('$FwdRelation', '唱 的', '歌曲'),
Rule('$De', '的', '的'),
Rule('$Person', '谁', 'who'),
Rule('$Equal', '是', 'Equal'),
Rule('$Type', '$Type $Equal $Type', lambda sems:
(sems[1], sems[0], sems[2])),
#Rule('$Person','$Person $Relation', lambda sems: sems[1](sems[0]) )
Rule('$Type', '$Type ?$De $Relation', lambda sems: sems[2](sems[0]))
]
grammar = Grammar(rules=rules)
query_list = [
'谢霆锋 父亲 儿子 是 谁', '谁 是 谢霆锋 父亲 儿子', '歌唱祖国 是 谁 唱 的', '谢霆锋 父亲 儿子 是 谁',
'谢霆锋 是 谁 的 儿子', '谁 是 谢霆锋 的 儿子', '哪个 香港 人 的 老公 是 谢贤 的 儿子', '歌唱祖国 谁 唱 的'
]
#parses = grammar.parse_input('谢霆锋 父亲 儿子 的 歌曲')
for query in query_list:
parses = grammar.parse_input(query)
print("###################################################")
for parse in parses[:1]:
print(query + " ==" + str(parse.semantics))
def grammar(self):
return Grammar(rules=self.rules(), annotators=self.annotators())
Rule('$Elem', 'element', {}, 0.25),
Rule('$Elem', 'value', {}, 0.25),
Rule('$NameMention', '?$Elem $Of $VariableName',
lambda sems: {'name': ('name', sems[2]['name'])}, 0.25),
Rule('$NameMention', '$VariableName',
lambda sems: {'name': ('name', sems[0]['name'])}),
]
rules_1 = decl_rules + dec_constructs + var_name_rules\
+ ptr_rules
rules_2 = func_name_rules + func_param_rules + func_call_rules\
+ add_fn_call_rules
rules_3 = loop_define_rules + loop_init_rules + loop_cond_rules\
+ loop_update_rules
rules_4 = pack_rules + init_rules + data_type_rules + arr_size_rules + \
cond_rules + exp_rules + return_stmt_rules + if_rules
# + struct_name_rules
rules_5 = nav_rules + edit_rules + system_rules + optionals + array_index_rules
rules = rules_1 + rules_2 + rules_3 + rules_4 + rules_5
grammar = Grammar(rules=rules,
annotators=[
TokenAnnotator(),
VariableNameAnnotator(),
NumberAnnotator(),
PackageTypeAnnotator(),
PositionalNumberAnnotator(),
StringTextAnnotator(),
ScopeVariablesAnnotator(),
])