def mapping(self, node, operator, eps):
assert util.contains_superclass(operator.__class__, 'MapperOperator')
self._request(node, eps)
X = self._materialize_X(node)
return operator.mapping(X, self.prng)
def materialize(self, X, prng, node):
if self._dgraph.root.id == node.id:
return X, None
paths = [
path for path in nx.all_simple_paths(self._dgraph.graph,
self._dgraph.root.id, node.id)
]
assert len(paths) == 1
path = paths[0]
for i in range(len(path)):
node = self._dgraph.id_node_map[path[i]]
if util.contains_superclass(node.operator.__class__,
'SplitByPartition'):
id_node_map = self._dgraph.id_node_map
Xs = node.operator.transform(X)
X = Xs[node.idx]
else:
X = node.operator.transform(X)
return X, path
def select(self, node, operator, eps):
assert util.contains_superclass(operator.__class__,
'SelectionOperator')
self._request(node, eps)
X = self._materialize_X(node)
return operator.select(X, self.prng)
def measure(self, node, operator, eps):
assert util.contains_superclass(operator.__class__,
'MeasurementOperator')
self._request(node, eps)
X = self._materialize_X(node)
return operator.measure(X, self.prng)
def partition(self, operator, prng, node):
assert util.contains_superclass(operator.__class__, 'SplitByPartition')
mapping = operator.mapping
return [
self._dgraph.insert_subset(operator, idx, node)
for idx in sorted(set(mapping))
]
def measure(self, node, operator, eps):
assert util.contains_superclass(operator.__class__,
'MeasurementOperator')
assert operator.eps <= eps, "operator budget cannot exceed measurement budget"
self._request(node, eps)
X = self._materialize_X(node)
return operator.measure(X, self.prng)
def transform(self, operator, after=None):
assert util.contains_superclass(operator.__class__,
'TransformationOperator')
prev_data_node = after.data_node if after is not None else None
data_node = self._data_manager.transform(operator, prev_data_node)
node = self._tgraph.insert_transformation(data_node, operator, after)
return node
def partition(self, operator, after):
assert util.contains_superclass(operator.__class__, 'SplitByPartition')
data_nodes = self._data_manager.partition(operator, self.prng,
after.data_node)
meta_node = self._tgraph.insert_transformation(after.data_node,
operator, after)
child_nodes = []
for data_node in data_nodes:
child_node = self._tgraph.insert_transformation(
data_node, transformation.Null(), meta_node)
child_nodes.append(child_node)
return child_nodes
def _request(self, node, budget, child=None):
parent = self._tgraph.parent(node)
if node == self._tgraph.root:
assert parent is None
if node.budget_consumed + budget > self._budget:
raise BudgetExceededError()
else:
node.budget_consumed += budget
elif util.contains_superclass(node.operator.__class__,
'SplitByPartition'):
assert parent is not None
assert child is not None
budget_delta = max(
0, child.budget_consumed + budget - node.budget_consumed)
self._request(parent, budget_delta, node)
node.budget_consumed += budget_delta
else:
self._request(parent, node.operator.stability * budget, node)
node.budget_consumed += budget
def transform(self, operator, node):
assert util.contains_superclass(operator.__class__,
'TransformationOperator')
return self._dgraph.insert(operator, node)
