def test_AxonMapModel(engine):
set_params = {'xystep': 2, 'engine': engine, 'rho': 432, 'axlambda': 2,
'n_axons': 9, 'n_ax_segments': 50,
'xrange': (-30, 30), 'yrange': (-20, 20),
'loc_od_x': 5, 'loc_od_y': 6}
model = AxonMapModel()
for param in set_params:
npt.assert_equal(hasattr(model.spatial, param), True)
# User can override default values
for key, value in set_params.items():
setattr(model.spatial, key, value)
npt.assert_equal(getattr(model.spatial, key), value)
model = AxonMapModel(**set_params)
model.build(**set_params)
for key, value in set_params.items():
npt.assert_equal(getattr(model.spatial, key), value)
# Zeros in, zeros out:
implant = ArgusII(stim=np.zeros(60))
npt.assert_almost_equal(model.predict_percept(implant).data, 0)
implant.stim = np.zeros(60)
npt.assert_almost_equal(model.predict_percept(implant).data, 0)
# Implant and model must be built for same eye:
with pytest.raises(ValueError):
implant = ArgusII(eye='LE', stim=np.zeros(60))
model.predict_percept(implant)
with pytest.raises(ValueError):
AxonMapModel(eye='invalid').build()
with pytest.raises(ValueError):
AxonMapModel(xystep=5).build(eye='invalid')
def test_AxonMapModel(engine):
set_params = {
'xystep': 2,
'engine': engine,
'rho': 432,
'axlambda': 20,
'n_axons': 9,
'n_ax_segments': 50,
'xrange': (-30, 30),
'yrange': (-20, 20),
'loc_od': (5, 6)
}
model = AxonMapModel()
for param in set_params:
npt.assert_equal(hasattr(model.spatial, param), True)
# User can override default values
for key, value in set_params.items():
setattr(model.spatial, key, value)
npt.assert_equal(getattr(model.spatial, key), value)
model = AxonMapModel(**set_params)
model.build(**set_params)
for key, value in set_params.items():
npt.assert_equal(getattr(model.spatial, key), value)
# Converting ret <=> dva
npt.assert_equal(isinstance(model.retinotopy, Watson2014Map), True)
npt.assert_almost_equal(model.retinotopy.ret2dva(0, 0), (0, 0))
npt.assert_almost_equal(model.retinotopy.dva2ret(0, 0), (0, 0))
model2 = AxonMapModel(retinotopy=Watson2014DisplaceMap())
npt.assert_equal(isinstance(model2.retinotopy, Watson2014DisplaceMap),
True)
# Zeros in, zeros out:
implant = ArgusII(stim=np.zeros(60))
npt.assert_almost_equal(model.predict_percept(implant).data, 0)
implant.stim = np.zeros(60)
npt.assert_almost_equal(model.predict_percept(implant).data, 0)
# Implant and model must be built for same eye:
with pytest.raises(ValueError):
implant = ArgusII(eye='LE', stim=np.zeros(60))
model.predict_percept(implant)
with pytest.raises(ValueError):
AxonMapModel(eye='invalid').build()
with pytest.raises(ValueError):
AxonMapModel(xystep=5).build(eye='invalid')
# Lambda cannot be too small:
with pytest.raises(ValueError):
AxonMapModel(axlambda=9).build()
def test_AxonMapModel_predict_percept(engine):
model = AxonMapModel(xystep=0.55,
axlambda=100,
rho=100,
thresh_percept=0,
engine=engine,
xrange=(-20, 20),
yrange=(-15, 15),
n_axons=500)
model.build()
# Single-electrode stim:
img_stim = np.zeros(60)
img_stim[47] = 1
percept = model.predict_percept(ArgusII(stim=img_stim))
# Single bright pixel, rest of arc is less bright:
npt.assert_equal(np.sum(percept.data > 0.8), 1)
npt.assert_equal(np.sum(percept.data > 0.6), 2)
npt.assert_equal(np.sum(percept.data > 0.1), 7)
npt.assert_equal(np.sum(percept.data > 0.0001), 32)
# Overall only a few bright pixels:
npt.assert_almost_equal(np.sum(percept.data), 3.31321, decimal=3)
# Brightest pixel is in lower right:
npt.assert_almost_equal(percept.data[33, 46, 0], np.max(percept.data))
# Top half is empty:
npt.assert_almost_equal(np.sum(percept.data[:27, :, 0]), 0)
# Same for lower band:
npt.assert_almost_equal(np.sum(percept.data[39:, :, 0]), 0)
# Full Argus II with small lambda: 60 bright spots
model = AxonMapModel(engine='serial',
xystep=1,
rho=100,
axlambda=40,
xrange=(-20, 20),
yrange=(-15, 15),
n_axons=500)
model.build()
percept = model.predict_percept(ArgusII(stim=np.ones(60)))
# Most spots are pretty bright, but there are 2 dimmer ones (due to their
# location on the retina):
npt.assert_equal(np.sum(percept.data > 0.5), 28)
npt.assert_equal(np.sum(percept.data > 0.275), 56)
# Model gives same outcome as Spatial:
spatial = AxonMapSpatial(engine='serial', xystep=1, rho=100, axlambda=40)
spatial.build()
spatial_percept = model.predict_percept(ArgusII(stim=np.ones(60)))
npt.assert_almost_equal(percept.data, spatial_percept.data)
npt.assert_equal(percept.time, None)
# that specifies the current amplitude to be applied to every electrode in the
# implant.
#
# For example, the following sends 1 microamp to all 60 electrodes of the
# implant:
import numpy as np
implant.stim = np.ones(60)
##############################################################################
# Predicting the percept
# ----------------------
# The third step is to apply the model to predict the percept resulting from
# the specified stimulus. Note that this may take some time on your machine:
percept = model.predict_percept(implant)
##############################################################################
# The resulting percept is stored in a
# :py:class:`~pulse2percept.percepts.Percept` object, which is similar in
# organization to the :py:class:`~pulse2percept.stimuli.Stimulus` object:
# the ``data`` container is a 3D NumPy array (Y, X, T) with labeled axes
# ``xdva``, ``ydva``, and ``time``.
#
# The percept can be plotted as follows:
ax = percept.plot()
ax.set_title('Predicted percept')
##############################################################################
# A major prediction of the axon map model is that the percept changes
# identity matrix whose size is equal to the number of electrodes. In code:
# Find the names of all the electrodes in the dataset:
electrodes = data.electrode.unique()
# Activate one electrode at a time:
import numpy as np
from pulse2percept.stimuli import Stimulus
argus.stim = Stimulus(np.eye(len(electrodes)), electrodes=electrodes)
###############################################################################
# Using the model's
# :py:func:`~pulse2percept.models.AxonMapModel.predict_percept`, we then get
# a Percept object where each frame is the percept generated from activating
# a single electrode:
percepts = model.predict_percept(argus)
percepts.play()
###############################################################################
# Finally, we can visualize the ground-truth and simulated phosphenes
# side-by-side:
from pulse2percept.viz import plot_argus_simulated_phosphenes
fig, (ax_data, ax_sim) = plt.subplots(ncols=2, figsize=(15, 5))
plot_argus_phosphenes(data, argus, scale=0.75, ax=ax_data)
plot_argus_simulated_phosphenes(percepts, argus, scale=1.25, ax=ax_sim)
ax_data.set_title('Ground-truth phosphenes')
ax_sim.set_title('Simulated phosphenes')
###############################################################################
# Analyzing phosphene shape
def test_AxonMapModel_predict_percept(engine):
model = AxonMapModel(xystep=0.55,
axlambda=100,
rho=100,
thresh_percept=0,
engine=engine,
xrange=(-20, 20),
yrange=(-15, 15),
n_axons=500)
model.build()
# Single-electrode stim:
img_stim = np.zeros(60)
img_stim[47] = 1
# Axon map jax predict_percept not implemented yet
if engine == 'jax':
with pytest.raises(NotImplementedError):
percept = model.predict_percept(ArgusII(stim=img_stim))
return
percept = model.predict_percept(ArgusII(stim=img_stim))
# Single bright pixel, rest of arc is less bright:
npt.assert_equal(np.sum(percept.data > 0.8), 1)
npt.assert_equal(np.sum(percept.data > 0.6), 2)
npt.assert_equal(np.sum(percept.data > 0.1), 7)
npt.assert_equal(np.sum(percept.data > 0.0001), 31)
# Overall only a few bright pixels:
npt.assert_almost_equal(np.sum(percept.data), 3.3087, decimal=3)
# Brightest pixel is in lower right:
npt.assert_almost_equal(percept.data[33, 46, 0], np.max(percept.data))
# Top half is empty:
npt.assert_almost_equal(np.sum(percept.data[:27, :, 0]), 0)
# Same for lower band:
npt.assert_almost_equal(np.sum(percept.data[39:, :, 0]), 0)
# Full Argus II with small lambda: 60 bright spots
model = AxonMapModel(engine='serial',
xystep=1,
rho=100,
axlambda=40,
xrange=(-20, 20),
yrange=(-15, 15),
n_axons=500)
model.build()
percept = model.predict_percept(ArgusII(stim=np.ones(60)))
# Most spots are pretty bright, but there are 2 dimmer ones (due to their
# location on the retina):
npt.assert_equal(np.sum(percept.data > 0.5), 28)
npt.assert_equal(np.sum(percept.data > 0.275), 56)
# Model gives same outcome as Spatial:
spatial = AxonMapSpatial(engine='serial',
xystep=1,
rho=100,
axlambda=40,
xrange=(-20, 20),
yrange=(-15, 15),
n_axons=500)
spatial.build()
spatial_percept = spatial.predict_percept(ArgusII(stim=np.ones(60)))
npt.assert_almost_equal(percept.data, spatial_percept.data)
npt.assert_equal(percept.time, None)
# Warning for nonzero electrode-retina distances
implant = ArgusI(stim=np.ones(16), z=10)
msg = ("Nonzero electrode-retina distances do not have any effect on the "
"model output.")
assert_warns_msg(UserWarning, model.predict_percept, msg, implant)