def build_decoders(model, conn, rng):
# Copied from older version of Nengo
encoders = model.params[conn.pre_obj].encoders
gain = model.params[conn.pre_obj].gain
bias = model.params[conn.pre_obj].bias
eval_points = connection_b.get_eval_points(model, conn, rng)
try:
targets = connection_b.get_targets(conn, eval_points)
except:
# nengo <= 2.3.0
targets = connection_b.get_targets(model, conn, eval_points)
x = np.dot(eval_points, encoders.T / conn.pre_obj.radius)
E = None
if conn.solver.weights:
E = model.params[conn.post_obj].scaled_encoders.T[conn.post_slice]
# include transform in solved weights
targets = connection_b.multiply(targets, conn.transform.T)
try:
wrapped_solver = model.decoder_cache.wrap_solver(
connection_b.solve_for_decoders)
try:
decoders, solver_info = wrapped_solver(conn,
gain,
bias,
x,
targets,
rng=rng,
E=E)
except TypeError:
# fallback for older nengo versions
decoders, solver_info = wrapped_solver(conn.solver,
conn.pre_obj.neuron_type,
gain,
bias,
x,
targets,
rng=rng,
E=E)
except BuildError:
raise BuildError(
"Building %s: 'activities' matrix is all zero for %s. "
"This is because no evaluation points fall in the firing "
"ranges of any neurons." % (conn, conn.pre_obj))
return eval_points, decoders, solver_info
def build_decoders(model, conn, rng):
# Copied from older version of Nengo
encoders = model.params[conn.pre_obj].encoders
gain = model.params[conn.pre_obj].gain
bias = model.params[conn.pre_obj].bias
eval_points = connection_b.get_eval_points(model, conn, rng)
try:
targets = connection_b.get_targets(conn, eval_points)
except:
# nengo <= 2.3.0
targets = connection_b.get_targets(model, conn, eval_points)
x = np.dot(eval_points, encoders.T / conn.pre_obj.radius)
E = None
if conn.solver.weights:
E = model.params[conn.post_obj].scaled_encoders.T[conn.post_slice]
# include transform in solved weights
targets = connection_b.multiply(targets, conn.transform.T)
try:
wrapped_solver = model.decoder_cache.wrap_solver(
connection_b.solve_for_decoders
)
try:
decoders, solver_info = wrapped_solver(
conn, gain, bias, x, targets,
rng=rng, E=E)
except TypeError:
# fallback for older nengo versions
decoders, solver_info = wrapped_solver(
conn.solver, conn.pre_obj.neuron_type, gain, bias, x, targets,
rng=rng, E=E)
except BuildError:
raise BuildError(
"Building %s: 'activities' matrix is all zero for %s. "
"This is because no evaluation points fall in the firing "
"ranges of any neurons." % (conn, conn.pre_obj))
return eval_points, decoders, solver_info
def build_decoders(model, conn, rng, sampled_transform):
# Copied from Nengo, except where noted below
encoders = model.params[conn.pre_obj].encoders
gain = model.params[conn.pre_obj].gain
bias = model.params[conn.pre_obj].bias
eval_points = get_eval_points(model, conn, rng)
targets = get_targets(conn, eval_points)
if conn.solver.weights and not conn.solver.compositional:
# solver is solving for the whole weight matrix, so apply
# transform/encoders to targets
# CHANGE: backwards compatibility with nengo<=2.8.0
# if not isinstance(conn.transform, Dense):
# raise BuildError(
# "Non-compositional solvers only work with Dense transforms")
# transform = conn.transform.sample(rng=rng)
# targets = np.dot(targets, transform.T)
if nengo_transforms is not None and not isinstance(
conn.transform, nengo_transforms.Dense): # pragma: no cover
raise BuildError(
"Non-compositional solvers only work with Dense transforms")
targets = np.dot(targets, sampled_transform.T)
# weight solvers only allowed on ensemble->ensemble connections
assert isinstance(conn.post_obj, Ensemble)
post_enc = model.params[conn.post_obj].scaled_encoders
targets = np.dot(targets, post_enc.T[conn.post_slice])
x = np.dot(eval_points, encoders.T / conn.pre_obj.radius)
# CHANGE: we pass `dt` to `solve_for_decoders`,
# and do not support the decoder cache.
# wrapped_solver = (model.decoder_cache.wrap_solver(solve_for_decoders)
# if model.seeded[conn] else solve_for_decoders)
# decoders, solver_info = wrapped_solver(
# conn, gain, bias, x, targets, rng=rng)
decoders, solver_info = solve_for_decoders(conn,
gain,
bias,
x,
targets,
rng=rng,
dt=model.dt)
return eval_points, decoders.T, solver_info
def eval_point_decoding(conn, sim, eval_points=None):
"""Get the targets and actual decoded values for a set of eval points.
This function evaluates the static decoding (i.e. using the neuron type's
``rates`` function) of a connection for a given set of evaluation points.
Parameters
----------
conn : Connection
The Connection to evaluate the decoding of.
sim : Simulator
A Nengo simulator storing the built connection.
eval_points : array_like (N, E) (optional)
An N x E array of evaluation points to evaluate the decoding for, where
N is the number of points and E is the dimensionality of the input
ensemble (i.e. ``conn.size_in``). If None (default), use the connection's
training evaluation points.
Returns
-------
eval_points : ndarray (N, E)
A shallow copy of the evaluation points used. E is the dimensionality
of the connection input ensemble (i.e. ``conn.size_in``).
targets : ndarray (N, D)
The target function value at each evaluation point.
decoded : ndarray (N, D)
The decoded function value at each evaluation point.
"""
# pylint: disable=import-outside-toplevel
# note: these are imported here to avoid circular imports
from nengo import rc
from nengo.builder.ensemble import get_activities
from nengo.builder.connection import get_targets
dtype = rc.float_dtype
if eval_points is None:
eval_points = sim.data[conn].eval_points
else:
eval_points = np.asarray(eval_points, dtype=dtype)
ens = conn.pre_obj
weights = sim.data[conn].weights
activities = get_activities(sim.data[ens], ens, eval_points)
decoded = np.dot(activities, weights.T)
targets = get_targets(conn, eval_points, dtype=dtype)
return eval_points, targets, decoded
def eval_point_decoding(conn, sim, eval_points=None):
"""Get the targets and actual decoded values for a set of eval points.
This function evaluates the static decoding (i.e. using the neuron type's
`rates` function) of a connection for a given set of evaluation points.
Parameters
----------
conn : Connection
The Connection to evaluate the decoding of.
sim : Simulator
A Nengo simulator storing the built connection.
eval_points : array_like (N, E) (optional)
An N x E array of evaluation points to evaluate the decoding for, where
N is the number of points and E is the dimensionality of the input
ensemble (i.e. `conn.size_in`). If None (default), use the connection's
training evaluation points.
Returns
-------
eval_points : ndarray (N, E)
A shallow copy of the evaluation points used. E is the dimensionality
of the connection input ensemble (i.e. `conn.size_in`).
targets : ndarray (N, D)
The target function value at each evaluation point.
decoded : ndarray (N, D)
The decoded function value at each evaluation point.
"""
from nengo.builder.ensemble import get_activities
from nengo.builder.connection import get_targets
if eval_points is None:
eval_points = sim.data[conn].eval_points
else:
eval_points = np.asarray(eval_points)
decoders = sim.data[conn].decoders
if decoders is None:
raise ValueError("Connection must have decoders")
activities = get_activities(sim.model, conn.pre_obj, eval_points)
decoded = np.dot(activities, decoders.T)
targets = get_targets(sim.model, conn, eval_points)
return eval_points, targets, decoded
def eval_point_decoding(conn, sim, eval_points=None):
"""Get the targets and actual decoded values for a set of eval points.
This function evaluates the static decoding (i.e. using the neuron type's
`rates` function) of a connection for a given set of evaluation points.
Parameters
----------
conn : Connection
The Connection to evaluate the decoding of.
sim : Simulator
A Nengo simulator storing the built connection.
eval_points : array_like (N, E) (optional)
An N x E array of evaluation points to evaluate the decoding for, where
N is the number of points and E is the dimensionality of the input
ensemble (i.e. `conn.size_in`). If None (default), use the connection's
training evaluation points.
Returns
-------
eval_points : ndarray (N, E)
A shallow copy of the evaluation points used. E is the dimensionality
of the connection input ensemble (i.e. `conn.size_in`).
targets : ndarray (N, D)
The target function value at each evaluation point.
decoded : ndarray (N, D)
The decoded function value at each evaluation point.
"""
from nengo.builder.ensemble import get_activities
from nengo.builder.connection import get_targets
if eval_points is None:
eval_points = sim.data[conn].eval_points
else:
eval_points = np.asarray(eval_points)
decoders = sim.data[conn].decoders
if decoders is None:
raise ValueError("Connection must have decoders")
activities = get_activities(sim.model, conn.pre_obj, eval_points)
decoded = np.dot(activities, decoders.T)
targets = get_targets(sim.model, conn, eval_points)
return eval_points, targets, decoded