Attaching synapses from "upstream" neurons to my current neuron?

[IanQS]

Hey there!

Very cool library. I've got a neuron morphology that I'm loading in via the SWC and I've got synapse (x,y,z) locations. I'd like to "attach" them to the network. I have some code that would allow me to map these synapses to specific compartment indices. How might I: 1) "attach" these to the appropriate compartments and 2) set specific upstream neurons to fire according to some pattern(s)? I don't really care about the biophysical simulation of these upstream neurons - just that all synapses belonging to one of the upstream ones fire at the same time

Direction

• I see that there is assembling-cells-into-a-network but it's not quite what I'm looking for (I don't think)

• I also see jaxley.connect.connect, which I think might work? but the impression I get is that I need to define an actual network there

Would Jaxley work for my usecase?

[jnsbck]

Hi Ian,

what you are doing with the synapses already sounds about right. You just select the pre and post compartments based on their xyz locations, i.e. via something like .

# 1) connect to appropriate comps
net.compute_compartment_centers()
comp_centers = net.nodes[["x", "y", "z"]].values

pre_dists = scipy.spatial.distance.cdist(comp_centers, synapse_locs_pre)
pre_inds = np.argmin(pre_dists, axis=1)

post_dists = scipy.spatial.distance.cdist(comp_centers, synapse_locs_post)
post_inds = np.argmin(post_dists, axis=1)

jx.connect(net.select(pre_inds), net.select(post_inds), SomeSynapse())

and then stimulate or clamp the upstream neurons with

# 2) set upstream neuron to fire according to some pattern
net.select(pre).stimulate(some_stimulus) # this would stimulate all upstream comps, if you only want to stimulate the soma of the upstream neuron, then you'd have to filter for the cells, i.e. net.select(pre).soma.stimulate(some_stimulus)

if you want the upstream voltage to behave according to some function then instead of using stimulate you just clamp the voltage with clamp(state_name="v", some_array).

I did not run the code above, but schematically, this should work :)

Lemme know if that answers your question / if this does what you intended, otherwise don't hesitate to follow up.

Jonas

[IanQS]

Can I stimulate specific compartments?

this would stimulate all upstream comps, if you only want to stimulate the soma of the upstream neuron, then you'd have to filter for the cells, i.e. net.select(pre).soma.stimulate(some_stimulus)

I don't need to stimulate the upstream neuron per-se. All I care about are that spikes from an upstream neuron arrive around roughly the same time to the various compartments where they have synapse onto.

What I was thinking of doing was defining "spikes" for each of the upstream neurons (probably via some inhomogenous poisson process). I then repeat this for all the compartments that they synapse on to. One thing I'll have to reconcile is what happens if we have two or more synapses from different neurons interacting, but I suppose that's for me to figure out :) (Would love thoughts if you have any)

[jnsbck]

I might understand this wrong, but in general: Yes you can stimulate specific compartments. net.cell(0).branch(0).comp(0).do_something() only affects the specific compartment that was selected. Same with net.select(comp_index=1).do_something(). do_something() could be clamp, stimulate, insert etc. This means you can "inject" spikes into specific compartments by clamping its voltage to some user defined spike train for example.

Regarding your problem, the following works.

Option A: You connect the upstream neuron using synapses and clamp its voltage / stimulate it (which is what I thought you wanted to do initially).

Option B: You just inject spikes where there would be synapses (which I understand is what you meant, but correct me if I am wrong).

In that case, you would just figure out the post compartments based on your xyz locations and clamp their voltage to a spike train.

Lemme know if that works for your use case.

[michaeldeistler]

Is this what you are looking for? https://jaxley.readthedocs.io/en/beta/how_to_guide/predefined_spike_trains.html

[IanQS]

Yes! Option B is exactly it :) And yes! That link helps immensely

[IanQS]

Just a heads up - AlphaSynapse is not defined in the code. I ran into an issue when trying to import it. I tried trawling through the main branch history to find a previous definition but didn't find anything :/

from jaxley.synapses import AlphaSynapse

[michaeldeistler]

Hi Ian,

you are right, the AlphaSynapse is not available on the jaxley main branch. I had pointed you to a version 1.0.0 (not released yet) tutorial. I should have mentioned that, sorry.

To install v1.0.0, do:

pip install git+https://github.com/jaxleyverse/jaxley.git@1.0.0

With this, the AlphaSynapse should work---but please be aware that v1.0.0 requires changes to the Channels, see also the changelog here.

All the best
Michael

[IanQS]

If I have a lot of neurons upstream (about 800 with 15K synapses) using the connnect is gets really really slow. Would something like connectivity_matrix_connect work for my use case? I'd basically have 800 calls, one for each upstream neuron? I'll need to study the example more thoroughly but I think that's along the right path?

[michaeldeistler]

You can speed up connect by following the Troubleshooting guide here: https://jaxley.readthedocs.io/en/beta/reference/_autosummary/jaxley.connect.connect.html
Quote:

For large networks, using connect() might take a long time when selecting a large amount of cells at once. When encountering this problem, one can connect the network using functions not in the public Jaxley API.

Below, we connect the first half of all compartments in a network to the second half. Notice two things: First, we used the pandas function .loc on .nodes directly, which is faster than the Jaxley method select (because select builds a View of the net). We then use _append_multiple_synapses instead of connect to connect the synapses, since connect only accepts View as input.

cell = jx.Cell()
net = jx.Network([cell for _ in range(N)])

pre_nodes = net.nodes.loc[range(N // 2)]
post_nodes = net.nodes.loc[range(N//2, N)]

net._append_multiple_synapses(pre_nodes, post_nodes, IonotropicSynapse())