kenkeiras/lang-model
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add more logging context.

Browse Source
This commit is contained in:
kenkeiras 2017-10-01 20:46:48 +02:00
parent 6278cc43f7
commit 2f76cdc260
3 changed files with 57 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
naive-nlu/tree_nlu/knowledge_base.py
View File

@ -22,63 +22,67 @@ class KnowledgeBase(object):
def train(self, examples): def train(self, examples):
knowledge_before = copy.deepcopy(self.knowledge) knowledge_before = copy.deepcopy(self.knowledge)
with session().log('Train'):
# Parse everything
for example in examples:
# If there's parsed data, leverage it ASAP
if 'parsed' in example:
with session().log('parsed information integration'):
result = knowledge_evaluation.integrate_information(self.knowledge, {
"parsed": example['parsed'],
})
self.act_upon(result)
# Parse everything with session().log("language integration"):
for example in examples: tokens, decomposition, inferred_tree = parsing.integrate_language(self, example)
# If there's parsed data, leverage it ASAP session().annotate(tokens)
if 'parsed' in example:
result = knowledge_evaluation.integrate_information(self.knowledge, {
"parsed": example['parsed'],
})
self.act_upon(result)
session().annotate("Example: {}".format(example)) with session().log("full information integration"):
tokens, decomposition, inferred_tree = parsing.integrate_language(self, example) result = knowledge_evaluation.integrate_information(self.knowledge, {
session().annotate(tokens) "elements": tokens,
result = knowledge_evaluation.integrate_information(self.knowledge, { "decomposition": decomposition,
"elements": tokens, "parsed": inferred_tree,
"decomposition": decomposition, })
"parsed": inferred_tree,
})
session().annotate("Result: {}".format(self.get_value(result))) session().annotate("Result: {}".format(self.get_value(result)))
self.act_upon(result) self.act_upon(result)
session().annotate("Set: {}".format(self.get_value(result))) session().annotate("Set: {}".format(self.get_value(result)))
self.examples.append((decomposition, inferred_tree)) self.examples.append((decomposition, inferred_tree))
self.originals.append(example['text']) self.originals.append(example['text'])
# Reduce values # Reduce values
self.trained = parsing.reprocess_language_knowledge(self, self.examples) with session().log("reprocessing"):
self.trained = parsing.reprocess_language_knowledge(self, self.examples)
knowledge_after = copy.deepcopy(self.knowledge) knowledge_after = copy.deepcopy(self.knowledge)
knowledge_diff_getter = lambda: diff_knowledge(knowledge_before, knowledge_diff_getter = lambda: diff_knowledge(knowledge_before,
knowledge_after) knowledge_after)
return knowledge_diff_getter return knowledge_diff_getter
def process(self, row): def process(self, row):
row = row.lower() row = row.lower()
knowledge_before = copy.deepcopy(self.knowledge) knowledge_before = copy.deepcopy(self.knowledge)
session().annotate("Process: {}".format(row)) with session().log("Process: {}".format(row)):
tokens = parsing.to_tokens(row) tokens = parsing.to_tokens(row)
fit = parsing.get_fit(self, tokens) fit = parsing.get_fit(self, tokens)
if fit is None: if fit is None:
return None return None
tokens, inferred_tree = fit tokens, inferred_tree = fit
result = knowledge_evaluation.integrate_information(self.knowledge, result = knowledge_evaluation.integrate_information(self.knowledge,
{ {
"elements": tokens, "elements": tokens,
"parsed": inferred_tree, "parsed": inferred_tree,
}) })
self.act_upon(result) self.act_upon(result)
session().annotate("Result: {}".format(result)) session().annotate("Result: {}".format(result))
knowledge_after = copy.deepcopy(self.knowledge) knowledge_after = copy.deepcopy(self.knowledge)
knowledge_diff_getter = lambda: diff_knowledge(knowledge_before, knowledge_diff_getter = lambda: diff_knowledge(knowledge_before,
knowledge_after) knowledge_after)
return result, inferred_tree, knowledge_diff_getter return result, inferred_tree, knowledge_diff_getter
def get_value(self, result): def get_value(self, result):
if is_modifiable_property(result): if is_modifiable_property(result):

9
naive-nlu/tree_nlu/session/org_mode.py
View File

@ -41,8 +41,15 @@ class OrgModeSession:
def __init__(self, fname): def __init__(self, fname):
self.f = open(fname, 'wt') self.f = open(fname, 'wt')
self.level = 0 self.level = 0
self.dirty = False
def annotate(self, annotation): def annotate(self, annotation):
if self.dirty:
self.f.write("{indentation} {data}\n".format(
indentation='*' * (self.level + 2),
data="---"))
self.dirty = False
self.f.write("{indentation} {data}\n".format( self.f.write("{indentation} {data}\n".format(
indentation=' ' * (self.level + 2 + 1), indentation=' ' * (self.level + 2 + 1),
data=annotation)) data=annotation))
@ -51,6 +58,7 @@ class OrgModeSession:
self.f.write("{indentation} {data}\n".format( self.f.write("{indentation} {data}\n".format(
indentation='*' * (self.level + 1), indentation='*' * (self.level + 1),
data=string)) data=string))
self.dirty = False
return LevelContext(self.inc_level, self.dec_level) return LevelContext(self.inc_level, self.dec_level)
@ -59,6 +67,7 @@ class OrgModeSession:
def dec_level(self): def dec_level(self):
self.level -= 1 self.level -= 1
self.dirty = True
def close(self): def close(self):
self.f.close() self.f.close()

2
naive-nlu/tree_nlu/tests/gac_100.py
View File

@ -711,7 +711,7 @@ def main():
differences = knowledge.train([question]) differences = knowledge.train([question])
session().annotate(differences()) session().annotate(differences())
result, _, _ = knowledge.process(data['text']) result, _, _ = knowledge.process(data['text'])
if "after_execution" in data: if "after_execution" in data:
for f in data["after_execution"]: for f in data["after_execution"]: