Distributed (asynchronous) averaging

Question

This code simulates a distributed averaging protocol. There is a network of nodes, and at the clicks of a Poisson process:

1. A random node wakes up

2. Transmits it's current average to all the nodes it is connected to

3. These nodes have a coroutine which waits to accept new values and compute the average.

from numpy.random import exponential, randint, uniform
import time
from itertools import product
class Node(object):
 def __init__(self, number):
 self.friends = []
 self.count = 0
 self.val = number
 self.average = number
 self.avg = self.averager()
 self.avg.next()
 def averager(self):
 while True:
 term = yield self.average
 self.val += term
 self.count += 1
 self.average = self.val/self.count
class Network(object):
 def __init__(self, num_nodes):
 self.nodes = [0]*num_nodes
 for i in range(num_nodes):
 self.nodes[i] = Node(randint(1, 10))
 self.set_connections()
 def set_connections(self):
 for f, g in product(self.nodes, self.nodes):
 p = uniform()
 if p < 0.8:
 f.friends.append(g)
 g.friends.append(f)
 def mainloop(self):
 num_nodes = len(self.nodes)
 while True:
 next_time = exponential(0.1)
 node = self.nodes[randint(num_nodes)]
 for friend in node.friends:
 friend.avg.send(node.average)
 print friend.average
 time.sleep(next_time)

So far I've only tested it as follows:

>>> n = Network(10)
>>> n.mainloop()

and then observed that the friend.average printed out all converge to the same value.

My main concern about this code is that a lot of the logic for waking up nodes is in the Network class, whilst I'd rather it was in the node class. Also, there's no exception/error handling, or proper testing.

The main purpose of this was to try and understand coroutines, which was a bit of a mind bender.

Answer 1

The way that the random graph is generated seems suspicious:

class Network(object):
 def __init__(self, num_nodes):
 self.nodes = [0]*num_nodes
 for i in range(num_nodes):
 self.nodes[i] = Node(randint(1, 10))
 self.set_connections()
 def set_connections(self):
 for f, g in product(self.nodes, self.nodes):
 p = uniform()
 if p < 0.8:
 f.friends.append(g)
 g.friends.append(f)

First of all, self.nodes should just be defined as

self.nodes = [Node(randint(1, 10)) for _ in range(num_nodes)]

The way that nodes changes type from a list of integers to a list of Node objects makes it feel slightly more dirty.

It looks like set_connections() is only meant to be called from the constructor, so it should be renamed _set_connections() to suggest that it is private. However, considering that __init__() would just consist of two lines (self.nodes = ... and self._set_connections()), I would just lump everything into __init__().

product(self.nodes, self.nodes) seems wrong. It's possible to cause a Node to befriend itself. It's also possible to have two nodes list each other as friends twice. I suspect that what you want is combinations(self.nodes, 2).

def __init__(self, num_nodes):
 self.nodes = [Node(randint(1, 10)) for _ in range(num_nodes)]
 for f, g in combinations(self.nodes, 2):
 if uniform() < 0.8:
 f.friends.append(g)
 g.friends.append(f)