def make_vertices(self, model, n_steps):
"""Make vertices for the filter."""
# Get the complete matrix to be applied by the filter
out_signals = model.get_signals_from_object(self)
# Get the filter and filter routing regions
filter_region, filter_routing_region = make_filter_regions(
model.get_signals_to_object(self)[InputPort.standard],
model.dt,
True,
model.keyspaces.filter_routing_tag,
width=self.size_in)
self._routing_region = filter_routing_region
# Generate the vertices
vertices = flatinsertionlist()
for group in self.groups:
vertices.append(
group.make_vertices(out_signals, model.machine_timestep,
filter_region, filter_routing_region))
# Return the netlist specification
return netlistspec(vertices=vertices,
load_function=self.load_to_machine)
def make_vertices(self, model, n_steps):
"""Make vertices for the filter."""
# Get the complete matrix to be applied by the filter
out_signals = model.get_signals_from_object(self)
# Get the filter and filter routing regions
filter_region, filter_routing_region = make_filter_regions(
model.get_signals_to_object(self)[InputPort.standard],
model.dt, True,
model.keyspaces.filter_routing_tag,
width=self.size_in
)
self._routing_region = filter_routing_region
# Generate the vertices
vertices = flatinsertionlist()
for group in self.groups:
vertices.append(
group.make_vertices(out_signals,
model.machine_timestep,
filter_region,
filter_routing_region)
)
# Return the netlist specification
return netlistspec(vertices=vertices,
load_function=self.load_to_machine)
def test_flatinsertionlist():
"""Test a list which will always flatten the items it inserts."""
fil = nscollections.flatinsertionlist()
# We can append items normally
fil.append(123)
assert fil == [123]
# Unless they're lists
fil.append([1, 2, 3])
assert fil == [123, 1, 2, 3]
def test_flatinsertionlist():
"""Test a list which will always flatten the items it inserts."""
fil = nscollections.flatinsertionlist()
# We can append items normally
fil.append(123)
assert fil == [123]
# Unless they're lists
fil.append([1, 2, 3])
assert fil == [123, 1, 2, 3]
def make_netlist(self, *args, **kwargs):
"""Convert the model into a netlist for simulating on SpiNNaker.
Returns
-------
:py:class:`~nengo_spinnaker.netlist.Netlist`
A netlist which can be placed and routed to simulate this model on
a SpiNNaker machine.
"""
# Remove any passthrough Nodes which don't connect to anything
from nengo_spinnaker import operators
removed_operators = model.remove_sinkless_objects(
self.connection_map, operators.Filter)
# Call each operator to make vertices
operator_vertices = dict()
load_functions = collections_ext.noneignoringlist()
before_simulation_functions = collections_ext.noneignoringlist()
after_simulation_functions = collections_ext.noneignoringlist()
constraints = collections_ext.flatinsertionlist()
# Prepare to build a list of signal constraints
id_constraints = collections.defaultdict(set)
for op in itertools.chain(itervalues(self.object_operators),
self.extra_operators):
# Skip any operators that were previously removed
if op in removed_operators:
continue
# Otherwise call upon the operator to build vertices for the
# netlist. The vertices should always be returned as an iterable.
vxs, load_fn, pre_fn, post_fn, constraint = op.make_vertices(
self, *args, **kwargs)
operator_vertices[op] = tuple(vxs)
load_functions.append(load_fn)
before_simulation_functions.append(pre_fn)
after_simulation_functions.append(post_fn)
if constraint is not None:
constraints.append(constraint)
# Get the constraints on signal identifiers
if hasattr(op, "get_signal_constraints"):
# Ask the operator what constraints exist upon the keys it can
# accept.
for u, vs in iteritems(op.get_signal_constraints()):
id_constraints[u].update(vs)
else:
# Otherwise assume that all signals arriving at the operator
# must be uniquely identified.
incoming_all = itertools.chain(
*itervalues(self.connection_map.get_signals_to_object(op)))
for (u, _), (v, _) in itertools.combinations(incoming_all, 2):
if u != v:
id_constraints[u].add(v)
id_constraints[v].add(u)
# Construct nets from the signals
nets = dict()
id_to_signal = dict()
for signal, transmission_parameters in \
self.connection_map.get_signals():
# Get the source and sink vertices
original_sources = operator_vertices[signal.source]
if not isinstance(original_sources, collections.Iterable):
original_sources = (original_sources, )
# Filter out any sources which have an `accepts_signal` method and
# return False when this is called with the signal and transmission
# parameters.
sources = list()
for source in original_sources:
# For each source which either doesn't have a
# `transmits_signal` method or returns True when this is called
# with the signal and transmission parameters add a new net to
# the netlist.
if (hasattr(source, "transmits_signal")
and not source.transmits_signal(
signal, transmission_parameters)):
pass # This source is ignored
else:
# Add the source to the final list of sources
sources.append(source)
sinks = collections_ext.flatinsertionlist()
for sink in signal.sinks:
# Get all the sink vertices
sink_vertices = operator_vertices[sink]
if not isinstance(sink_vertices, collections.Iterable):
sink_vertices = (sink_vertices, )
# Include any sinks which either don't have an `accepts_signal`
# method or return true when this is called with the signal and
# transmission parameters.
sinks.append(
s for s in sink_vertices
if not hasattr(s, "accepts_signal")
or s.accepts_signal(signal, transmission_parameters))
# Create the net(s)
id_to_signal[id(signal._params)] = signal # Yuck
nets[signal] = NMNet(sources, list(sinks), signal.weight)
# Get the constraints on the signal identifiers
signal_id_constraints = dict()
for u, vs in iteritems(id_constraints):
signal_id_constraints[id_to_signal[u]] = {
id_to_signal[v]
for v in vs
}
# Return a netlist
return Netlist(nets=nets,
operator_vertices=operator_vertices,
keyspaces=self.keyspaces,
constraints=constraints,
load_functions=load_functions,
before_simulation_functions=before_simulation_functions,
after_simulation_functions=after_simulation_functions,
signal_id_constraints=signal_id_constraints)
def make_netlist(self, *args, **kwargs):
"""Convert the model into a netlist for simulating on SpiNNaker.
Returns
-------
:py:class:`~nengo_spinnaker.netlist.Netlist`
A netlist which can be placed and routed to simulate this model on
a SpiNNaker machine.
"""
# Call each operator to make vertices
operator_vertices = dict()
vertices = collections_ext.flatinsertionlist()
load_functions = collections_ext.noneignoringlist()
before_simulation_functions = collections_ext.noneignoringlist()
after_simulation_functions = collections_ext.noneignoringlist()
for op in itertools.chain(itervalues(self.object_operators),
self.extra_operators):
vxs, load_fn, pre_fn, post_fn = op.make_vertices(
self, *args, **kwargs
)
operator_vertices[op] = vxs
vertices.append(vxs)
load_functions.append(load_fn)
before_simulation_functions.append(pre_fn)
after_simulation_functions.append(post_fn)
# Construct the groups set
groups = list()
for vxs in itervalues(operator_vertices):
# If multiple vertices were provided by an operator then we add
# them as a new group.
if isinstance(vxs, collections.Iterable):
groups.append(set(vxs))
# Construct nets from the signals
nets = list()
for signal in itertools.chain(itervalues(self.connections_signals),
self.extra_signals):
# Get the source and sink vertices
sources = operator_vertices[signal.source.obj]
if not isinstance(sources, collections.Iterable):
sources = (sources, )
sinks = collections_ext.flatinsertionlist()
for sink in signal.sinks:
sinks.append(operator_vertices[sink.obj])
# Create the net(s)
for source in sources:
nets.append(Net(source, list(sinks),
signal.weight, signal.keyspace))
# Return a netlist
return Netlist(
nets=nets,
vertices=vertices,
keyspaces=self.keyspaces,
groups=groups,
load_functions=load_functions,
before_simulation_functions=before_simulation_functions,
after_simulation_functions=after_simulation_functions
)
def make_netlist(self, *args, **kwargs):
"""Convert the model into a netlist for simulating on SpiNNaker.
Returns
-------
:py:class:`~nengo_spinnaker.netlist.Netlist`
A netlist which can be placed and routed to simulate this model on
a SpiNNaker machine.
"""
# Remove any passthrough Nodes which don't connect to anything
from nengo_spinnaker import operators
removed_operators = model.remove_sinkless_objects(self.connection_map,
operators.Filter)
# Apply the default keyspace to any signals without keyspaces
self.connection_map.add_default_keyspace(self.keyspaces["nengo"])
# Call each operator to make vertices
operator_vertices = dict()
vertices = collections_ext.flatinsertionlist()
load_functions = collections_ext.noneignoringlist()
before_simulation_functions = collections_ext.noneignoringlist()
after_simulation_functions = collections_ext.noneignoringlist()
constraints = collections_ext.flatinsertionlist()
for op in itertools.chain(itervalues(self.object_operators),
self.extra_operators):
# Skip any operators that were previously removed
if op in removed_operators:
continue
# Otherwise call upon the operator to build vertices for the
# netlist.
vxs, load_fn, pre_fn, post_fn, constraint = op.make_vertices(
self, *args, **kwargs
)
operator_vertices[op] = vxs
vertices.append(vxs)
load_functions.append(load_fn)
before_simulation_functions.append(pre_fn)
after_simulation_functions.append(post_fn)
if constraint is not None:
constraints.append(constraint)
# Construct the groups set
groups = list()
for vxs in itervalues(operator_vertices):
# If multiple vertices were provided by an operator then we add
# them as a new group.
if isinstance(vxs, collections.Iterable):
groups.append(set(vxs))
# Construct nets from the signals
nets = list()
for signal, transmission_parameters in \
self.connection_map.get_signals():
# Get the source and sink vertices
original_sources = operator_vertices[signal.source]
if not isinstance(original_sources, collections.Iterable):
original_sources = (original_sources, )
# Filter out any sources which have an `accepts_signal` method and
# return False when this is called with the signal and transmission
# parameters.
sources = list()
for source in original_sources:
# For each source which either doesn't have a
# `transmits_signal` method or returns True when this is called
# with the signal and transmission parameters add a new net to
# the netlist.
if (hasattr(source, "transmits_signal") and not
source.transmits_signal(signal,
transmission_parameters)):
pass # This source is ignored
else:
# Add the source to the final list of sources
sources.append(source)
sinks = collections_ext.flatinsertionlist()
for sink in signal.sinks:
# Get all the sink vertices
sink_vertices = operator_vertices[sink]
if not isinstance(sink_vertices, collections.Iterable):
sink_vertices = (sink_vertices, )
# Include any sinks which either don't have an `accepts_signal`
# method or return true when this is called with the signal and
# transmission parameters.
sinks.append(s for s in sink_vertices if
not hasattr(s, "accepts_signal") or
s.accepts_signal(signal, transmission_parameters))
# Create the net(s)
nets.append(NMNet(sources, list(sinks),
signal.weight, signal.keyspace))
# Return a netlist
return Netlist(
nets=nets,
vertices=vertices,
keyspaces=self.keyspaces,
groups=groups,
constraints=constraints,
load_functions=load_functions,
before_simulation_functions=before_simulation_functions,
after_simulation_functions=after_simulation_functions
)
def make_netlist(self, *args, **kwargs):
"""Convert the model into a netlist for simulating on SpiNNaker.
Returns
-------
:py:class:`~nengo_spinnaker.netlist.Netlist`
A netlist which can be placed and routed to simulate this model on
a SpiNNaker machine.
"""
# Call each operator to make vertices
operator_vertices = dict()
load_functions = collections_ext.noneignoringlist()
before_simulation_functions = collections_ext.noneignoringlist()
after_simulation_functions = collections_ext.noneignoringlist()
constraints = collections_ext.flatinsertionlist()
# Prepare to build a list of signal constraints
id_constraints = collections.defaultdict(set)
for op in itertools.chain(itervalues(self.object_operators),
self.extra_operators):
# If the operator is a passthrough Node then skip it
if isinstance(op, model.PassthroughNode):
continue
# Otherwise call upon the operator to build vertices for the
# netlist. The vertices should always be returned as an iterable.
vxs, load_fn, pre_fn, post_fn, constraint = op.make_vertices(
self, *args, **kwargs
)
operator_vertices[op] = tuple(vxs)
load_functions.append(load_fn)
before_simulation_functions.append(pre_fn)
after_simulation_functions.append(post_fn)
if constraint is not None:
constraints.append(constraint)
# Get the constraints on signal identifiers
if hasattr(op, "get_signal_constraints"):
# Ask the operator what constraints exist upon the keys it can
# accept.
for u, vs in iteritems(op.get_signal_constraints()):
id_constraints[u].update(vs)
else:
# Otherwise assume that all signals arriving at the operator
# must be uniquely identified.
incoming_all = itertools.chain(*itervalues(
self.get_signals_to_object(op)))
for (u, _), (v, _) in itertools.combinations(incoming_all, 2):
if u != v:
id_constraints[u].add(v)
id_constraints[v].add(u)
# Construct nets from the signals
nets = dict()
id_to_signal = dict()
for signal, transmission_parameters in \
self.connection_map.get_signals():
# Get the source and sink vertices
original_sources = operator_vertices[signal.source]
if not isinstance(original_sources, collections.Iterable):
original_sources = (original_sources, )
# Filter out any sources which have an `accepts_signal` method and
# return False when this is called with the signal and transmission
# parameters.
sources = list()
for source in original_sources:
# For each source which either doesn't have a
# `transmits_signal` method or returns True when this is called
# with the signal and transmission parameters add a new net to
# the netlist.
if (hasattr(source, "transmits_signal") and not
source.transmits_signal(signal,
transmission_parameters)):
pass # This source is ignored
else:
# Add the source to the final list of sources
sources.append(source)
sinks = collections.deque()
for sink in signal.sinks:
# Get all the sink vertices
sink_vertices = operator_vertices[sink]
if not isinstance(sink_vertices, collections.Iterable):
sink_vertices = (sink_vertices, )
# Include any sinks which either don't have an `accepts_signal`
# method or return true when this is called with the signal and
# transmission parameters.
sinks.extend(s for s in sink_vertices if
not hasattr(s, "accepts_signal") or
s.accepts_signal(signal, transmission_parameters))
# Create the net(s)
id_to_signal[id(signal._params)] = signal # Yuck
nets[signal] = NMNet(sources, list(sinks), signal.weight)
# Get the constraints on the signal identifiers
signal_id_constraints = dict()
for u, vs in iteritems(id_constraints):
signal_id_constraints[id_to_signal[u]] = {
id_to_signal[v] for v in vs
}
# Return a netlist
return Netlist(
nets=nets,
operator_vertices=operator_vertices,
keyspaces=self.keyspaces,
constraints=constraints,
load_functions=load_functions,
before_simulation_functions=before_simulation_functions,
after_simulation_functions=after_simulation_functions,
signal_id_constraints=signal_id_constraints
)