[Zero]

Hi guys 

When you play with giant networks, for instance huge neural nets, how do you define their topology? I keep googling for tools in this area, but I can't find anything satisfying.

With a language like DOT, you can describe a directed graph by specifying relations one by one. It's like styling hair with tweezers. I'm looking for a hair brush! I would like to describe massively redundant directed graphs, with assertions like "31% of nodeGroup A listens to nodes of nodeGroup B".

Assertions should be fuzzy, and it should be possible to identify nodes by expressions, like "nodes which were active during the last 3 seconds", or "nodes which are part of nodeGroup C and nodeGroup D", or "nodes which are listening to <some_other_nodes>"...

Is there anything like that somewhere?

Thank you

[Korrelan]

Assertions should be fuzzy, and it should be possible to identify nodes by expressions, like "nodes which were active during the last 3 seconds", or "nodes which are part of nodeGroup C and nodeGroup D", or "nodes which are listening to <some_other_nodes>"...

So something similar to SQL, but for parallel processing?

I have never come across anything that uses this kind of language.

I write all my own parallel architectures.

Though it seems to me that if you require this kind of flexibility, then storing the nodes, properties and results, etc, within a MySQL database would allow this kind of flexibility/ selection.

If you just used the database to set the initial parameters/ starting point and to record the end results; MySQL would do the job.

Update synapse set [too node]=4536 where [from node]>1234 and [from node]<1345

 

[Zero]

So something similar to SQL, but for parallel processing?

Kind of.
SQL (or a JSON store) are good candidates for backend. But if you think about it, with SQL you're still doing things one by one. How about defining architectural patterns. It's a bit like a function / procedure in imperative language : it has an interface (arguments), and it works like a testable black box. Then you use it, coding like:

Code

myNicePattern(thisGroup, thatGroup, 50%);

The syntax could be different, but you get the point.

I have never come across anything that uses this kind of language.

Well, if you have never come across anything like that, I'm pretty sure it doesn't exist

[Korrelan]

I was thinking more along the lines of using database records to set the initial properties of a simulation.  If each node/ neuron had a parameter record in the database you could use SQL group update commands to set the initial links, parameters, etc.  You would have a field in the table that specified an individual neurons links etc.  The simulation would read each neurons parameters from the database into memory and run the simulation.

Neuron!Name=’N1’
Neuron!group=’Hippocampus’
Neuron!link1=N234
Neuron!link2=N678
Neuron!strength=23
Etc.

You could use the ‘Insert’ batch commands to create neuron records and ‘update’ batch commands to affect parameters en masse.

Result variables could be moved from memory back into the database at the end of the simulation run for easy viewing and SQL manipulation.

Well, if you have never come across anything like that, I'm pretty sure it doesn't exist

Not necessarily, I don’t look for third party solutions because I’ve always just wrote my own custom solutions.

I will keep an eye out now though.

 

[Zero]

Fields and tables should vary according to what's needed. Agnostic tools are cool

It is indeed about setting the initial properties, and state, of a simulation. When I said "backend", I was thinking about SQL as a target : this "thing" would compile to SQL commands & queries, that (when executed) would in turn construct the wanted architecture inside the db. Then you're supposed to extract this architecture from the db, in order to run it with... whatever you use for this kind of job. An engine.

Edit:
I'll use a visual metaphor. Start with a little torus, made of, say, 100 nodes. With 30 torus, you draw a line. With 6 of these lines, you can make 6 edges of a triangular pyramid. Now with adjacent triagular pyramids, you create the curved side of a cylinder... and so on. Well, I'm talking about creating a function for a torus (that calls INSERTs and UPDATEs), another one for a line (that calls the torus function), another one for the pyramid (that calls the line function), ...etc.

[Korrelan]

I obviously had the same dilemma.

My software allows me to draw/ edit huge 3D connectomes using fairly normal 2D/ 3D mouse edit commands and a custom script interface.  It also allows me to ‘fly/ move’ through the connectome to view/ edit it from inside.

The script interface handles several commands mostly for linking and setting parameters/ loading / saving and merging connectomes/ scripts, etc.

I have a lightweight version that just runs the connectome without the editor I load onto the slave computers/ cores.  They load the latest version before they import their sections of the connectome on boot up.

I also wrote a custom system for load balancing the slaves as well as keeping the whole system synchronised during parallel processes, etc using a mixture of tcp and udp schemas for various tasks.

Writing a 3D interface is fairly straight forward once you get your head around trigonometry.

Edit: I've just noticed I've 500 posts and become Roy Batty... cool.

 

[Art]

@ Korrelan - Congrats!
That's far better than becoming Very Batty. 

Say hi to Rachael and Rick!