def deltas_from(self, g, old_d, node):
node_a = old_d.get(node, 0.0)
if abs(node_a) >= epsilon:
#print('DFF', node, type(node), node_a, list(g.hops_from_node(node)))
for hop in g.hops_from_node(node):
if abs(hop.weight) >= epsilon:
yield Delta(hop.to_node, hop.weight * node_a, node)
def sentas_to_deltas(self, sentas: Iterable[SentA]) \
-> Iterable[Delta]:
# Find max incoming activation and sum of incoming activations for
# each node.
maxin_d: Dict[Node, float] = defaultdict(float) # positive influences
possumin_d: Dict[Node, float] = defaultdict(float)
minin_d: Dict[Node, float] = defaultdict(float) # negative influences
negsumin_d: Dict[Node, float] = defaultdict(float)
for senta in sentas:
if senta.a >= 0:
maxin_d[senta.to_node] = max(maxin_d[senta.to_node], senta.a)
possumin_d[senta.to_node] += senta.a
elif senta.a < 0:
minin_d[senta.to_node] = min(minin_d[senta.to_node], senta.a)
negsumin_d[senta.to_node] += senta.a
# Make Deltas from the Tyrrell averages of the SentA's
multiplier = 1.0 - self.alpha
for node in union(maxin_d.keys(), minin_d.keys()):
amt = multiplier * (
((maxin_d.get(node, 0.0) +
self.tyrrell_alpha * possumin_d.get(node, 0.0)) /
(1 + self.tyrrell_alpha)) +
((minin_d.get(node, 0.0) +
self.tyrrell_beta * negsumin_d.get(node, 0.0)) /
(1 + self.tyrrell_beta)))
if abs(amt) >= epsilon:
yield Delta(node, amt)
def INFLATIONARY_deltas_from(self, g, old_d, nodeid) \
-> List[Delta]:
'''Deltas from nodeid to its neighbors.'''
result: List[Delta] = []
nodeid_a = old_d.get(nodeid, 0.0)
for neighborid, edge_d in g.adj[nodeid].items():
weight = edge_d.get('weight', 1.0)
delta = Delta(neighborid, weight * nodeid_a, nodeid)
result.append(delta)
return result
def deltas_to(self, g, old_d: Dict[NodeId, float], nodeid: NodeId) \
-> List[Delta]:
incoming_deltas = []
for neighborid in g.incoming_activation_neighbors(nodeid):
support_for_neighbor = old_d.get(neighborid, 0.0)
incoming_deltas.append(
Delta(
nodeid,
self.hop_weight(g, neighborid, nodeid) *
support_for_neighbor, neighborid))
return incoming_deltas
def rescale_deltas(self, deltas, node_a) -> List[Delta]:
if not deltas:
return deltas
ssum = sum(delta.amt for delta in deltas)
if ssum <= node_a:
return deltas
else:
multiplier = node_a / ssum
return [
Delta(d.nodeid, d.amt * multiplier, d.neighborid)
for d in deltas
]
def rescale_deltas(
self, outgoing_deltas: List[Delta], support_for_node: float
) -> List[Delta]:
if not outgoing_deltas:
return outgoing_deltas
ssum = sum(delta.amt for delta in outgoing_deltas)
if ssum <= support_for_node:
return outgoing_deltas
else:
multiplier = support_for_node / ssum
return [
Delta(d.nodeid, d.amt * multiplier, d.neighborid)
for d in outgoing_deltas
]
def deltas_from(self, g, old_d, node) -> Iterable[Delta]:
'''Deltas specify changes to node's neighbors, not to node.'''
node_a = old_d.get(node, 0.0) # node's current activation
outgoing_deltas = []
for neighbor, edge_d in g.adj[node].items():
weight = edge_d.get('weight', 1.0)
neighbor_a = old_d.get(node, 0.0) # neighbor's current activation
outgoing_deltas.append(
Delta(
neighbor,
weight, # + self.positive_feedback_rate * neighbor_a,
node
)
)
return self.rescale_deltas(outgoing_deltas, node_a)
def deltas_from(self, g, old_d: Dict[NodeId, float], nodeid: NodeId) \
-> Iterable[Delta]:
support_for_node = old_d.get(nodeid, 0.0)
outgoing_deltas = []
for hop in g.support_hops_from(nodeid):
neighborid = hop.to_node
support_for_neighbor = old_d.get(neighborid, 0.0)
hop_weight = g._hop_weight(hop)
outgoing_deltas.append(Delta(
neighborid,
hop_weight +
self.positive_feedback_rate * support_for_neighbor,
nodeid
))
result = self.rescale_deltas(outgoing_deltas, support_for_node)
#print('DFROM', nodeid, result)
return result
def deltas_from(self, g, old_d, nodeid) \
-> List[Delta]:
'''Deltas from nodeid to its neighbors.
Outgoing weights are quasi-averaged in a way similar to that used by
Toby Tyrell, but the quasi-averaging is done on the outgoing edges
rather than the incoming edges. This might not work as well.'''
result: List[Delta] = []
nodeid_a = old_d.get(nodeid, 0.0)
nws: List[NeighborW] = g.incident_nws(nodeid)
num_edges = len(nws)
# wtotal = sum(nws, key=attrgetter('weight'))
# wmax = max(nws, key=attrgetter('weight'))
# alpha = 1.0 / num_edges**2
multiplier = self.inflation_constant / (num_edges +
self.inflation_constant - 1)
for nw in nws:
delta = Delta(nw.neighbor, nodeid_a * nw.weight * multiplier,
nodeid)
result.append(delta)
return result
def deltas_to(self, g, old_d, node):
for hop in g.hops_to_node(node):
if abs(hop.weight) >= epsilon:
neighbor_a = old_d.get(hop.from_node, 0.0)
if abs(neighbor_a) >= epsilon:
yield Delta(node, hop.weight * neighbor_a, hop.from_node)
