Mercurial > code > home > repos > homeauto
annotate service/mqtt_to_rdf/inference.py @ 1613:03ed8c9abd5b
forget GRAPH_ID optimization in this case
| author | drewp@bigasterisk.com |
|---|---|
| date | Mon, 06 Sep 2021 23:03:51 -0700 |
| parents | 272f78d4671a |
| children | 97b2c3cfdb83 |
| rev | line source |
|---|---|
| 1587 | 1 """ |
| 2 copied from reasoning 2021-08-29. probably same api. should | |
| 3 be able to lib/ this out | |
| 4 """ | |
|
1588
0757fafbfdab
WIP inferencer - partial var and function support
drewp@bigasterisk.com
parents:
1587
diff
changeset
|
5 import itertools |
| 1587 | 6 import logging |
| 1601 | 7 import time |
| 1594 | 8 from collections import defaultdict |
| 9 from dataclasses import dataclass, field | |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
10 from typing import Dict, Iterator, List, Set, Tuple, Union, cast |
|
1588
0757fafbfdab
WIP inferencer - partial var and function support
drewp@bigasterisk.com
parents:
1587
diff
changeset
|
11 |
| 1587 | 12 from prometheus_client import Summary |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
13 from rdflib import BNode, Graph, Namespace, URIRef |
|
1589
5c1055be3c36
WIP more debugging, working towards bnode-matching support
drewp@bigasterisk.com
parents:
1588
diff
changeset
|
14 from rdflib.graph import ConjunctiveGraph, ReadOnlyGraphAggregate |
| 1587 | 15 from rdflib.term import Node, Variable |
| 16 | |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
17 from candidate_binding import CandidateBinding |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
18 from inference_types import (BindableTerm, EvaluationFailed, ReadOnlyWorkingSet, Triple) |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
19 from lhs_evaluation import Evaluation |
| 1605 | 20 |
| 1587 | 21 log = logging.getLogger('infer') |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
22 INDENT = ' ' |
| 1587 | 23 |
| 1601 | 24 INFER_CALLS = Summary('read_rules_calls', 'calls') |
| 1587 | 25 |
| 26 ROOM = Namespace("http://projects.bigasterisk.com/room/") | |
| 27 LOG = Namespace('http://www.w3.org/2000/10/swap/log#') | |
| 28 MATH = Namespace('http://www.w3.org/2000/10/swap/math#') | |
| 29 | |
| 30 | |
| 1594 | 31 @dataclass |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
32 class Lhs: |
| 1594 | 33 graph: Graph |
| 34 | |
| 35 def __post_init__(self): | |
| 1608 | 36 # do precomputation in here that's not specific to the workingSet |
| 37 self.staticRuleStmts = Graph() | |
|
1611
a794a150a89b
a little inner-loop performace. same number of iterations, but less time on logging and some stmt filtering
drewp@bigasterisk.com
parents:
1610
diff
changeset
|
38 self.nonStaticRuleStmts = Graph() |
|
a794a150a89b
a little inner-loop performace. same number of iterations, but less time on logging and some stmt filtering
drewp@bigasterisk.com
parents:
1610
diff
changeset
|
39 |
| 1608 | 40 self.lhsBindables: Set[BindableTerm] = set() |
| 41 self.lhsBnodes: Set[BNode] = set() | |
| 1594 | 42 for ruleStmt in self.graph: |
| 43 varsAndBnodesInStmt = [term for term in ruleStmt if isinstance(term, (Variable, BNode))] | |
| 44 self.lhsBindables.update(varsAndBnodesInStmt) | |
| 45 self.lhsBnodes.update(x for x in varsAndBnodesInStmt if isinstance(x, BNode)) | |
| 46 if not varsAndBnodesInStmt: | |
| 47 self.staticRuleStmts.add(ruleStmt) | |
|
1611
a794a150a89b
a little inner-loop performace. same number of iterations, but less time on logging and some stmt filtering
drewp@bigasterisk.com
parents:
1610
diff
changeset
|
48 else: |
|
a794a150a89b
a little inner-loop performace. same number of iterations, but less time on logging and some stmt filtering
drewp@bigasterisk.com
parents:
1610
diff
changeset
|
49 self.nonStaticRuleStmts.add(ruleStmt) |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
50 |
| 1602 | 51 self.evaluations = list(Evaluation.findEvals(self.graph)) |
| 52 | |
|
1609
34f2817320cc
new tests for a smaller part of the inner loop
drewp@bigasterisk.com
parents:
1608
diff
changeset
|
53 def __repr__(self): |
|
34f2817320cc
new tests for a smaller part of the inner loop
drewp@bigasterisk.com
parents:
1608
diff
changeset
|
54 return f"Lhs({graphDump(self.graph)})" |
|
34f2817320cc
new tests for a smaller part of the inner loop
drewp@bigasterisk.com
parents:
1608
diff
changeset
|
55 |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
56 def findCandidateBindings(self, workingSet: ReadOnlyWorkingSet, stats) -> Iterator['BoundLhs']: |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
57 """bindings that fit the LHS of a rule, using statements from workingSet and functions |
|
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
58 from LHS""" |
| 1597 | 59 log.debug(f'{INDENT*3} nodesToBind: {self.lhsBindables}') |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
60 stats['findCandidateBindingsCalls'] += 1 |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
61 |
| 1600 | 62 if not self._allStaticStatementsMatch(workingSet): |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
63 stats['findCandidateBindingEarlyExits'] += 1 |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
64 return |
|
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
65 |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
66 for binding in self._possibleBindings(workingSet, stats): |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
67 log.debug('') |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
68 log.debug(f'{INDENT*4}*trying {binding.binding}') |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
69 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
70 if not binding.verify(workingSet): |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
71 log.debug(f'{INDENT*4} this binding did not verify') |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
72 stats['permCountFailingVerify'] += 1 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
73 continue |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
74 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
75 stats['permCountSucceeding'] += 1 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
76 yield binding |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
77 |
| 1608 | 78 def _allStaticStatementsMatch(self, workingSet: ReadOnlyWorkingSet) -> bool: |
|
1613
03ed8c9abd5b
forget GRAPH_ID optimization in this case
drewp@bigasterisk.com
parents:
1612
diff
changeset
|
79 # bug: see TestSelfFulfillingRule.test3 for a case where this rule's |
|
03ed8c9abd5b
forget GRAPH_ID optimization in this case
drewp@bigasterisk.com
parents:
1612
diff
changeset
|
80 # static stmt is matched by a non-static stmt in the rule itself |
| 1608 | 81 for ruleStmt in self.staticRuleStmts: |
| 82 if ruleStmt not in workingSet: | |
| 83 log.debug(f'{INDENT*3} {ruleStmt} not in working set- skip rule') | |
| 84 return False | |
| 85 return True | |
| 86 | |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
87 def _possibleBindings(self, workingSet, stats) -> Iterator['BoundLhs']: |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
88 """this yields at least the working bindings, and possibly others""" |
| 1600 | 89 candidateTermMatches: Dict[BindableTerm, Set[Node]] = self._allCandidateTermMatches(workingSet) |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
90 |
| 1600 | 91 orderedVars, orderedValueSets = _organize(candidateTermMatches) |
| 92 self._logCandidates(orderedVars, orderedValueSets) | |
|
1592
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
93 |
| 1597 | 94 log.debug(f'{INDENT*3} trying all permutations:') |
|
1612
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
95 for valueSet in itertools.product(*orderedValueSets): |
| 1594 | 96 try: |
|
1612
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
97 yield BoundLhs(self, CandidateBinding(dict(zip(orderedVars, valueSet)))) |
| 1594 | 98 except EvaluationFailed: |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
99 stats['permCountFailingEval'] += 1 |
|
1592
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
100 |
| 1600 | 101 def _allCandidateTermMatches(self, workingSet: ReadOnlyWorkingSet) -> Dict[BindableTerm, Set[Node]]: |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
102 """the total set of terms each variable could possibly match""" |
|
1592
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
103 |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
104 candidateTermMatches: Dict[BindableTerm, Set[Node]] = defaultdict(set) |
| 1594 | 105 for lhsStmt in self.graph: |
| 1597 | 106 log.debug(f'{INDENT*4} possibles for this lhs stmt: {lhsStmt}') |
| 1608 | 107 for i, trueStmt in enumerate(workingSet): |
| 1597 | 108 # log.debug(f'{INDENT*5} consider this true stmt ({i}): {trueStmt}') |
|
1592
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
109 |
| 1594 | 110 for v, vals in self._bindingsFromStatement(lhsStmt, trueStmt): |
| 111 candidateTermMatches[v].update(vals) | |
| 112 | |
| 113 for trueStmt in itertools.chain(workingSet, self.graph): | |
| 114 for b in self.lhsBnodes: | |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
115 for t in [trueStmt[0], trueStmt[2]]: |
|
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
116 if isinstance(t, (URIRef, BNode)): |
|
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
117 candidateTermMatches[b].add(t) |
|
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
118 return candidateTermMatches |
|
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
119 |
| 1594 | 120 def _bindingsFromStatement(self, stmt1: Triple, stmt2: Triple) -> Iterator[Tuple[Variable, Set[Node]]]: |
| 121 """if these stmts match otherwise, what BNode or Variable mappings do we learn? | |
| 122 | |
| 123 e.g. stmt1=(?x B ?y) and stmt2=(A B C), then we yield (?x, {A}) and (?y, {C}) | |
| 124 or stmt1=(_:x B C) and stmt2=(A B C), then we yield (_:x, {A}) | |
| 125 or stmt1=(?x B C) and stmt2=(A B D), then we yield nothing | |
| 126 """ | |
| 127 bindingsFromStatement = {} | |
| 128 for term1, term2 in zip(stmt1, stmt2): | |
| 129 if isinstance(term1, (BNode, Variable)): | |
| 130 bindingsFromStatement.setdefault(term1, set()).add(term2) | |
| 131 elif term1 != term2: | |
| 132 break | |
| 133 else: | |
| 134 for v, vals in bindingsFromStatement.items(): | |
| 1597 | 135 log.debug(f'{INDENT*5} {v=} {vals=}') |
| 1594 | 136 yield v, vals |
| 137 | |
| 1600 | 138 def _logCandidates(self, orderedVars, orderedValueSets): |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
139 if not log.isEnabledFor(logging.DEBUG): |
|
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
140 return |
| 1597 | 141 log.debug(f'{INDENT*3} resulting candidate terms:') |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
142 for v, vals in zip(orderedVars, orderedValueSets): |
| 1597 | 143 log.debug(f'{INDENT*4} {v!r} could be:') |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
144 for val in vals: |
| 1597 | 145 log.debug(f'{INDENT*5}{val!r}') |
|
1592
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
146 |
|
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
147 |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
148 @dataclass |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
149 class BoundLhs: |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
150 lhs: Lhs |
| 1610 | 151 binding: CandidateBinding |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
152 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
153 def __post_init__(self): |
|
1613
03ed8c9abd5b
forget GRAPH_ID optimization in this case
drewp@bigasterisk.com
parents:
1612
diff
changeset
|
154 self.usedByFuncs = Graph() |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
155 self._applyFunctions() |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
156 |
| 1608 | 157 self.graphWithoutEvals = self.lhs.graph - self.usedByFuncs |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
158 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
159 def _applyFunctions(self): |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
160 """may grow the binding with some results""" |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
161 while True: |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
162 delta = self._applyFunctionsIteration() |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
163 if delta == 0: |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
164 break |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
165 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
166 def _applyFunctionsIteration(self): |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
167 before = len(self.binding.binding) |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
168 delta = 0 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
169 for ev in self.lhs.evaluations: |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
170 newBindings, usedGraph = ev.resultBindings(self.binding) |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
171 self.usedByFuncs += usedGraph |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
172 self.binding.addNewBindings(newBindings) |
| 1608 | 173 delta = len(self.binding.binding) - before |
| 174 log.debug(f'{INDENT*4} eval rules made {delta} new bindings') | |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
175 return delta |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
176 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
177 def verify(self, workingSet: ReadOnlyWorkingSet) -> bool: |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
178 """Can this bound lhs be true all at once in workingSet?""" |
|
1611
a794a150a89b
a little inner-loop performace. same number of iterations, but less time on logging and some stmt filtering
drewp@bigasterisk.com
parents:
1610
diff
changeset
|
179 boundLhs = self.binding.apply(self.lhs.nonStaticRuleStmts - self.usedByFuncs) |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
180 |
|
1611
a794a150a89b
a little inner-loop performace. same number of iterations, but less time on logging and some stmt filtering
drewp@bigasterisk.com
parents:
1610
diff
changeset
|
181 if log.isEnabledFor(logging.DEBUG): |
|
a794a150a89b
a little inner-loop performace. same number of iterations, but less time on logging and some stmt filtering
drewp@bigasterisk.com
parents:
1610
diff
changeset
|
182 boundLhs = list(boundLhs) |
|
a794a150a89b
a little inner-loop performace. same number of iterations, but less time on logging and some stmt filtering
drewp@bigasterisk.com
parents:
1610
diff
changeset
|
183 self._logVerifyBanner(boundLhs, workingSet) |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
184 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
185 for stmt in boundLhs: |
|
1611
a794a150a89b
a little inner-loop performace. same number of iterations, but less time on logging and some stmt filtering
drewp@bigasterisk.com
parents:
1610
diff
changeset
|
186 log.debug(f'{INDENT*4} check for %s', stmt) |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
187 |
|
1611
a794a150a89b
a little inner-loop performace. same number of iterations, but less time on logging and some stmt filtering
drewp@bigasterisk.com
parents:
1610
diff
changeset
|
188 if stmt not in workingSet: |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
189 log.debug(f'{INDENT*5} stmt not known to be true') |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
190 return False |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
191 return True |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
192 |
|
1611
a794a150a89b
a little inner-loop performace. same number of iterations, but less time on logging and some stmt filtering
drewp@bigasterisk.com
parents:
1610
diff
changeset
|
193 def _logVerifyBanner(self, boundLhs, workingSet: ReadOnlyWorkingSet): |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
194 log.debug(f'{INDENT*4}/ verify all bindings against this boundLhs:') |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
195 for stmt in sorted(boundLhs): |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
196 log.debug(f'{INDENT*4}|{INDENT} {stmt}') |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
197 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
198 # log.debug(f'{INDENT*4}| and against this workingSet:') |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
199 # for stmt in sorted(workingSet): |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
200 # log.debug(f'{INDENT*4}|{INDENT} {stmt}') |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
201 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
202 log.debug(f'{INDENT*4}\\') |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
203 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
204 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
205 @dataclass |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
206 class Rule: |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
207 lhsGraph: Graph |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
208 rhsGraph: Graph |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
209 |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
210 def __post_init__(self): |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
211 self.lhs = Lhs(self.lhsGraph) |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
212 |
|
1612
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
213 def applyRule(self, workingSet: Graph, implied: Graph, stats: Dict): |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
214 for bound in self.lhs.findCandidateBindings(ReadOnlyGraphAggregate([workingSet]), stats): |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
215 log.debug(f'{INDENT*3} rule has a working binding:') |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
216 |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
217 for lhsBoundStmt in bound.binding.apply(bound.graphWithoutEvals): |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
218 log.debug(f'{INDENT*5} adding {lhsBoundStmt=}') |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
219 workingSet.add(lhsBoundStmt) |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
220 for newStmt in bound.binding.apply(self.rhsGraph): |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
221 log.debug(f'{INDENT*5} adding {newStmt=}') |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
222 workingSet.add(newStmt) |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
223 implied.add(newStmt) |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
224 |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
225 |
| 1587 | 226 class Inference: |
| 227 | |
| 228 def __init__(self) -> None: | |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
229 self.rules = [] |
| 1587 | 230 |
| 231 def setRules(self, g: ConjunctiveGraph): | |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
232 self.rules: List[Rule] = [] |
|
1599
abbf0eb0e640
fix a bug with a slightly moer complicated set of rules
drewp@bigasterisk.com
parents:
1598
diff
changeset
|
233 for stmt in g: |
|
abbf0eb0e640
fix a bug with a slightly moer complicated set of rules
drewp@bigasterisk.com
parents:
1598
diff
changeset
|
234 if stmt[1] == LOG['implies']: |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
235 self.rules.append(Rule(stmt[0], stmt[2])) |
|
1612
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
236 # other stmts should go to a default working set? |
| 1587 | 237 |
| 1601 | 238 @INFER_CALLS.time() |
| 1587 | 239 def infer(self, graph: Graph): |
| 240 """ | |
| 241 returns new graph of inferred statements. | |
| 242 """ | |
| 1597 | 243 log.info(f'{INDENT*0} Begin inference of graph len={graph.__len__()} with rules len={len(self.rules)}:') |
| 1601 | 244 startTime = time.time() |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
245 stats: Dict[str, Union[int, float]] = defaultdict(lambda: 0) |
|
1589
5c1055be3c36
WIP more debugging, working towards bnode-matching support
drewp@bigasterisk.com
parents:
1588
diff
changeset
|
246 # everything that is true: the input graph, plus every rule conclusion we can make |
|
1593
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
247 workingSet = Graph() |
|
b0df43d5494c
big rewrite- more classes, smaller methods, more typesafe, all current tests passing
drewp@bigasterisk.com
parents:
1592
diff
changeset
|
248 workingSet += graph |
| 1587 | 249 |
| 1594 | 250 # just the statements that came from RHS's of rules that fired. |
| 1587 | 251 implied = ConjunctiveGraph() |
| 252 | |
| 253 bailout_iterations = 100 | |
| 254 delta = 1 | |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
255 stats['initWorkingSet'] = cast(int, workingSet.__len__()) |
| 1587 | 256 while delta > 0 and bailout_iterations > 0: |
| 1597 | 257 log.info(f'{INDENT*1}*iteration ({bailout_iterations} left)') |
| 1587 | 258 bailout_iterations -= 1 |
| 259 delta = -len(implied) | |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
260 self._iterateAllRules(workingSet, implied, stats) |
| 1587 | 261 delta += len(implied) |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
262 stats['iterations'] += 1 |
| 1597 | 263 log.info(f'{INDENT*2} this inference iteration added {delta} more implied stmts') |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
264 stats['timeSpent'] = round(time.time() - startTime, 3) |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
265 stats['impliedStmts'] = len(implied) |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
266 log.info(f'{INDENT*0} Inference done {dict(stats)}. Implied:') |
| 1587 | 267 for st in implied: |
| 1597 | 268 log.info(f'{INDENT*1} {st}') |
| 1587 | 269 return implied |
| 270 | |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
271 def _iterateAllRules(self, workingSet: Graph, implied: Graph, stats): |
|
1612
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
272 for i, rule in enumerate(self.rules): |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
273 self._logRuleApplicationHeader(workingSet, i, rule) |
|
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
274 rule.applyRule(workingSet, implied, stats) |
| 1587 | 275 |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
276 def _logRuleApplicationHeader(self, workingSet, i, r: Rule): |
| 1594 | 277 if not log.isEnabledFor(logging.DEBUG): |
| 278 return | |
| 279 | |
| 280 log.debug('') | |
| 281 log.debug(f'{INDENT*2} workingSet:') | |
| 1597 | 282 for j, stmt in enumerate(sorted(workingSet)): |
| 283 log.debug(f'{INDENT*3} ({j}) {stmt}') | |
| 1594 | 284 |
| 285 log.debug('') | |
| 286 log.debug(f'{INDENT*2}-applying rule {i}') | |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
287 log.debug(f'{INDENT*3} rule def lhs: {graphDump(r.lhsGraph)}') |
|
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
288 log.debug(f'{INDENT*3} rule def rhs: {graphDump(r.rhsGraph)}') |
| 1594 | 289 |
|
1588
0757fafbfdab
WIP inferencer - partial var and function support
drewp@bigasterisk.com
parents:
1587
diff
changeset
|
290 |
|
1590
327202020892
WIP inference- getting into more degenerate test cases
drewp@bigasterisk.com
parents:
1589
diff
changeset
|
291 def graphDump(g: Union[Graph, List[Triple]]): |
|
327202020892
WIP inference- getting into more degenerate test cases
drewp@bigasterisk.com
parents:
1589
diff
changeset
|
292 if not isinstance(g, Graph): |
|
1607
b21885181e35
more modules, types. Maybe less repeated computation on BoundLhs
drewp@bigasterisk.com
parents:
1605
diff
changeset
|
293 log.warning(f"it's a {type(g)}") |
|
1590
327202020892
WIP inference- getting into more degenerate test cases
drewp@bigasterisk.com
parents:
1589
diff
changeset
|
294 g2 = Graph() |
| 1594 | 295 g2 += g |
|
1590
327202020892
WIP inference- getting into more degenerate test cases
drewp@bigasterisk.com
parents:
1589
diff
changeset
|
296 g = g2 |
|
1589
5c1055be3c36
WIP more debugging, working towards bnode-matching support
drewp@bigasterisk.com
parents:
1588
diff
changeset
|
297 g.bind('', ROOM) |
|
5c1055be3c36
WIP more debugging, working towards bnode-matching support
drewp@bigasterisk.com
parents:
1588
diff
changeset
|
298 g.bind('ex', Namespace('http://example.com/')) |
|
5c1055be3c36
WIP more debugging, working towards bnode-matching support
drewp@bigasterisk.com
parents:
1588
diff
changeset
|
299 lines = cast(bytes, g.serialize(format='n3')).decode('utf8').splitlines() |
|
1612
272f78d4671a
mark skipped tests. move applyRule into Rule. minor cleanups.
drewp@bigasterisk.com
parents:
1611
diff
changeset
|
300 lines = [line.strip() for line in lines if not line.startswith('@prefix')] |
|
1589
5c1055be3c36
WIP more debugging, working towards bnode-matching support
drewp@bigasterisk.com
parents:
1588
diff
changeset
|
301 return ' '.join(lines) |
|
5c1055be3c36
WIP more debugging, working towards bnode-matching support
drewp@bigasterisk.com
parents:
1588
diff
changeset
|
302 |
|
5c1055be3c36
WIP more debugging, working towards bnode-matching support
drewp@bigasterisk.com
parents:
1588
diff
changeset
|
303 |
| 1600 | 304 def _organize(candidateTermMatches: Dict[BindableTerm, Set[Node]]) -> Tuple[List[BindableTerm], List[List[Node]]]: |
|
1592
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
305 items = list(candidateTermMatches.items()) |
|
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
306 items.sort() |
|
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
307 orderedVars: List[BindableTerm] = [] |
|
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
308 orderedValueSets: List[List[Node]] = [] |
|
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
309 for v, vals in items: |
|
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
310 orderedVars.append(v) |
|
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
311 orderedValues: List[Node] = list(vals) |
|
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
312 orderedValues.sort(key=str) |
|
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
313 orderedValueSets.append(orderedValues) |
|
1588
0757fafbfdab
WIP inferencer - partial var and function support
drewp@bigasterisk.com
parents:
1587
diff
changeset
|
314 |
|
1592
d7b66234064b
pure reordering of funcs to make the next diffs smaller
drewp@bigasterisk.com
parents:
1591
diff
changeset
|
315 return orderedVars, orderedValueSets |