class Cog(object):
"""
The basic units of which blocks are composed
Cogs are named for their similarity to clockwork cogwheels.
They are simple and do the same task over and over, but by
virtue of how they are connected to their fellows, they
collectively bring about interesting behavior.
Input channels are similar to cables in that they carry activity
signals that vary over time.
Each cog contains two important parts, a daisychain and a ziptie.
The daisychain is an object that builds cables into short sequences,
and the ziptie is an object that takes the resulting chains
and performs clustering on them, creating bundles.
During upward processing, cable activities are used to train
the daisychain and ziptie, making new bundles, maturing existing
bundles, and calculating the activity in bundle.
During downward processing,
the daisychain and ziptie use the bundle activity goals from
the next level higher to create goals for the cables.
"""
def __init__(self, max_cables, max_bundles, max_chains_per_bundle=None,
name='anonymous', level=0):
""" Initialize the cogs with a pre-determined maximum size """
self.name = name
self.max_cables = max_cables
self.max_bundles = max_bundles
if max_chains_per_bundle is None:
max_chains_per_bundle = int(max_cables ** 2 / max_bundles)
self.daisychain = DaisyChain(max_cables, name=name)
if max_bundles > 0:
self.ziptie = ZipTie(max_cables **2, max_bundles,
max_cables_per_bundle=max_chains_per_bundle,
name=name)
def step_up(self, cable_activities, reward, enough_cables):
# TODO: fix this so that cogs can gracefully handle more cables
# or else never be assigned them in the first place
if cable_activities.size > self.max_cables:
cable_activities = cable_activities[:self.max_cables, :]
print '----- Number of max cables exceeded in', self.name, \
' -----'
""" cable_activities percolate upward through daisychain and ziptie """
chain_activities = self.daisychain.update(cable_activities, reward)
self.reaction= self.daisychain.get_cable_activity_reactions()
self.surprise = self.daisychain.get_surprise()
if enough_cables is True:
bundle_activities = self.ziptie.update(chain_activities)
else:
bundle_activities = np.zeros((0,1))
bundle_activities = tools.pad(bundle_activities, (self.max_bundles, 0))
return bundle_activities
def step_down(self, bundle_activity_goals):
""" bundle_activity_goals percolate downward """
chain_activity_goals = self.ziptie.get_cable_deliberation_vote(
bundle_activity_goals)
instant_cable_activity_goals = self.daisychain.deliberate(
chain_activity_goals)
self.cable_activity_goals =self.daisychain.get_cable_deliberation_vote()
return instant_cable_activity_goals
def get_projection(self, bundle_index):
""" Project a bundle down through the ziptie and daisychain """
chain_projection = self.ziptie.get_projection(bundle_index)
cable_projection = self.daisychain.get_projection(chain_projection)
return cable_projection
def fraction_filled(self):
""" How full is the set of cables for this cog? """
return float(self.daisychain.num_cables) / float(self.max_cables)
def num_bundles(self):
""" How many bundles have been created in this cog? """
return self.ziptie.num_bundles
def visualize(self):
""" Show the internal state of the daisychain and ziptie """
self.daisychain.visualize()
if self.max_bundles > 0:
self.ziptie.visualize()
return
