Changeset 29929 in project


Ignore:
Timestamp:
10/15/13 01:58:17 (8 years ago)
Author:
Ivan Raikov
Message:

9ML-toolkit: updated to pyloric network model and initial support for electrical synapses

Location:
release/4/9ML-toolkit/trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • release/4/9ML-toolkit/trunk/examples/Brunel00/Brunel00_network_alpha.xml

    r29861 r29929  
    5555  <Property>
    5656    <label>g</label> <!-- Relative strength of inhibitory synapses -->
    57     <value>4.5</value>
     57    <value>5.0</value>
    5858  </Property>
    5959
    6060  <Property> <!-- nu_ext / nu_thr -->
    6161    <label>eta</label>
    62     <value>0.9</value>
     62    <value>2.0</value>
    6363  </Property>
    6464
     
    282282
    283283
    284   <Group name="BrunelCaseDalpha">
     284  <Group name="BrunelCaseCalpha">
    285285
    286286    <Population name="Exc"> <!-- Excitatory population definition --> 
  • release/4/9ML-toolkit/trunk/examples/Pyloric/Izhikevich.xml

    r29899 r29929  
    1313
    1414    <AnalogPort name="Isyn" mode='reduce' dimension='current'/>
    15     <AnalogPort name="Igap" mode='reduce' dimension='current'/>
    1615    <AnalogPort name="Iext" mode='receive' dimension='current'/>
    1716
     
    2928
    3029          <TimeDerivative variable="V">
    31             <MathInline> (0.04 * V * V) + (5 * V) + 140 - U + Isyn + Iext + Igap </MathInline>
     30            <MathInline> (0.04 * V * V) + (5 * V) + 140 - U + Isyn + Iext </MathInline>
    3231          </TimeDerivative>
    3332
  • release/4/9ML-toolkit/trunk/examples/Pyloric/Pyloric_network.xml

    r29898 r29929  
    455455
    456456    <!-- Projection from external sources to all neurons --> 
    457     <Projection name="External" >
     457    <Projection name="External" type="event" >
    458458      <source><reference>Ext</reference></source>
    459459      <target><reference>All neurons</reference></target>
     
    463463
    464464    <!-- Pyloric network projection --> 
    465     <Projection name="Pyloric" >
     465    <Projection name="Pyloric" type="event" >
    466466      <source><reference>All neurons</reference></source>
    467467      <target><reference>All neurons</reference></target>
     
    470470    </Projection>
    471471
     472    <!-- Electrical synapses projection --> 
     473    <Projection name="Electrical" type="cvar" >
     474      <source><reference>All neurons</reference></source>
     475      <target><reference>All neurons</reference></target>
     476      <rule><reference>from file</reference>
     477      <Property name="filename"><value>Electrical.dat</value></Property></rule>
     478    </Projection>
     479
    472480    <!-- Record spikes from the given set -->
    473481    <SpikeRecording set="All neurons"/>
  • release/4/9ML-toolkit/trunk/network.scm

    r29901 r29929  
    936936      (
    937937
     938       (fromlist-template
     939        (sxml:match 'nml:fromList
     940                    (lambda (node bindings root env)
     941                      (let ((kids (sxml:kids node)))
     942                        (fold (lambda (x ax)
     943                                (lset-union population=
     944                                    (make-population-set x populations) ax))
     945                              '() kids)
     946                        ))
     947                    ))
     948
    938949       (union-template
    939950        (sxml:match 'nml:union
     
    10051016  (alist->tenv
    10061017   `((name       . ,name)
     1018     (type       . ,type)
    10071019     (source     . ,source)
    10081020     (target     . ,target)
     
    11401152                   (let* (
    11411153                          (name          (sxml:attr node 'name))
     1154                          (type          ($ (or (sxml:attr node 'type) "event")))
    11421155                          (source-name   ($ (sxml:text (sxml:kidn* 'nml:reference (sxml:kidn* 'nml:source node)))))
    11431156                          (target-name   ($ (sxml:text (sxml:kidn* 'nml:reference (sxml:kidn* 'nml:target node)))))
     
    11651178                           (error 'eval-ul-group "invalid projection target" target))
    11661179                       
    1167                        (list `(,($ name) . ,(make-projection-tenv ($ name) source target rule-name response-name properties))
     1180                       (list `(,($ name) . ,(make-projection-tenv ($ name) type source target rule-name response-name properties))
    11681181                             `(,(and response-name ($ response-name)) (response . ,response) (projection . ,name)))
    11691182                       ))
  • release/4/9ML-toolkit/trunk/templates/Network.sml.tmpl

    r29901 r29929  
    2525                     end
    2626
     27  fun fromDiag (m, n, a, dflt) =
     28      if Index.validShape [m,n]
     29      then
     30          (let
     31               val na  = RTensor.Array.length a
     32               val na' = na-1
     33               val te  = RTensor.new ([m,n], dflt)
     34               fun diag (i, j, ia) =
     35                   let
     36                       val ia' =
     37                           (RTensor.update (te, [i,j], RTensor.Array.sub (a, ia));
     38                            if ia = na' then 0 else ia+1)
     39                   in
     40                       if (i=0) orelse (j=0)
     41                       then te
     42                       else diag (i-1, j-1, ia)
     43                   end
     44           in
     45               diag (m-1, n-1, 0)
     46           end)
     47      else
     48          raise RTensor.Shape
     49
    2750  val RandomInit = RandomMTZig.fromEntropy
    2851
     
    174197        end
    175198                         
     199
     200    fun felec E I
     201              ({% for pop in dict (group.populations) %}
     202              {{pop.name}}_state_vector{% if not loop.last %},{% endif %}
     203              {% endfor %} ) =
     204        case E of NONE => I
     205                | SOME E =>
     206                  let
     207                    val update = Unsafe.Real64Array.update
     208                    val I' = case I of SOME I => I
     209                                     | NONE => RTensor.new ([N,1],0.0)
     210                  {% for pr in dict (group.projections) %}
     211                  {% if pr.value.type == "cvar" %}
     212                  {% for spop in pr.value.source %}
     213                  {% for tpop in pr.value.target %}
     214                    fun {{spop.name}}_sub i = #({{first (spop.value.prototype.states)}})(Vector.sub ({{spop.name}}_state_vector, i))
     215                    fun {{tpop.name}}_sub i = #({{first (tpop.value.prototype.states)}})(Vector.sub ({{tpop.name}}_state_vector, i))
     216                    val _ = Loop.app
     217                                (0, N_{{spop.name}},
     218                                 fn (i) =>
     219                                    let
     220                                        val Vi = {{spop.name}}_sub i
     221                                        val sl = SparseMatrix.slice (#{{spop.name}}(E),1,i)
     222                                    in
     223                                        SparseMatrix.sliceAppi
     224                                            (fn (j,g) => let val Vj = {{tpop.name}}_sub j
     225                                                         in update (I,i,Real.- (sub(I,i), Real.* (g,Real.- (Vi,Vj)))) end)
     226                                            sl
     227                                    end)
     228                               
     229                  {% endfor %}
     230                  {% endfor %}
     231                  {% endif %}
     232                  {% endfor %}
     233                  in
     234                  end
    176235                         
    177236    fun ftime (
     
    243302                                                  (RTensor.new ([{{t.size}},{{s.size}}],1.0))),
    244303                                     sparse=false}{% if not loop.last %},{% endif %}
     304                                    {% endfor %}{% if not loop.last %},{% endif %}
     305                                    {% endfor %}
     306                                 ]
     307{% endmacro %}
     308
     309{% macro one_to_one(name, sp, tp, weight) %}
     310             val Pr_{{name}} = SparseMatrix.fromTensorList [N,N]
     311                                  [
     312                                    {% for s in sp %}
     313                                    {% for t in tp %}
     314                                    {offset=[{{t.start}},{{s.start}}],
     315                                     tensor=(fromDiag ({{t.size}},{{s.size}},Real64Array.fromList [{{weight}}],0.0)),
     316                                     sparse=true}{% if not loop.last %},{% endif %}
    245317                                    {% endfor %}{% if not loop.last %},{% endif %}
    246318                                    {% endfor %}
     
    274346
    275347           
     348           
    276349    fun fprojection () =
    277350       
     
    286359                                      pr.value.properties.epsilon.exprML,
    287360                                      pr.value.properties.weight.exprML) %}
     361             {% endcall %}
     362             {% else %}
     363             {% if pr.value.rule == "one-to-one" %}
     364             {% call one_to_one(pr.name,
     365                                pr.value.source.populations,
     366                                pr.value.target.populations,
     367                                pr.value.properties.weight.exprML) %}
    288368             {% endcall %}
    289369             {% else %}
     
    304384             {% endif %}
    305385             {% endif %}
     386             {% endif %}
    306387             {% endfor %}
    307388               
     
    311392                                  ([
    312393                                    {% for pr in psr.value.projections %}
     394                                    {% if pr.value.type == "event" %}
    313395                                    Pr_{{pr}}{% if not loop.last %},{% endif %}
     396                                    {% endif %}
    314397                                    {% endfor %}
    315398                                   ])
     
    318401                     ([
    319402                           {% for pr in dict (group.projections) %}
     403                               {% if pr.value.type == "event" %}
    320404                               Pr_{{pr.name}}{% if not loop.last %},{% endif %}
     405                               {% endif %}
    321406                           {% endfor %}
    322407                     ])
    323408{% endif %}
     409
     410             val Elst =
     411                      [
     412                           {% for pr in dict (group.projections) %}
     413                               {% if pr.value.type == "cvar" %}
     414                               Pr_{{pr.name}}{% if not loop.last %},{% endif %}
     415                               {% endif %}
     416                           {% endfor %}
     417                     ]
     418
     419             val E = if List.null Elst then NONE else SOME Elst
     420
    324421             in
    325               [
     422              ([
    326423{% if group.psrtypes %}{% for psr in dict (group.psrtypes) %}
    327424               S_{{ psr.name }}{% if not loop.last %},{% endif %}
     
    329426               S
    330427{% endif %}
    331               ]
     428              ], E)
    332429             end)
    333430
  • release/4/9ML-toolkit/trunk/templates/Sim.sml.tmpl

    r29901 r29929  
    5353exception Index
    5454
    55 fun start (tmax, N, S, D, Pn, initial_vector, psr_initial_vector, frun, fresponse, ftime, fspikes, finfo, out) =
     55fun start (tmax, N, S, D, E, Pn, initial_vector, psr_initial_vector, frun, fresponse, ftime, fspikes, finfo, out) =
    5656
    5757let
     
    6666        let
    6767           
    68             val (I',psr_state_vector_i) = fresponse I psr_state_vector
     68            val (I',psr_state_vector_i)  = fresponse I psr_state_vector
    6969           
    70             val state_vector_i = frun I' state_vector
     70            val I'' = felec E I' state_vector
     71           
     72            val state_vector_i = frun I'' state_vector
    7173
    7274            val t_i = ftime state_vector_i
     
    7678            val _   = finfo (state_vector_i, out)
    7779                             
    78             val I''  = if (List.null spike_i)
    79                       then NONE
    80                       else SOME
    81                                (let
    82                                     val T = Real64Array.array (N, 0.0)
    83                                 in
    84                                     List.app
    85                                         (fn (W) =>
    86                                             List.app
    87                                                 (fn (i,nv) =>
    88                                                     let
    89                                                         val sl = SparseMatrix.slice (W,1,i)
    90                                                     in
    91                                                         SparseMatrix.sliceAppi
    92                                                             (fn (i,x) => update (T,i,Real.+ (Real.* (nv,x), sub(T,i))))
    93                                                             sl
    94                                                     end)
    95                                                 spike_i)
    96                                         S;
    97                                     RTensor.fromArray ([N,1], T)
    98                                end)
     80            val I'''  = if (List.null spike_i)
     81                        then NONE
     82                        else SOME
     83                                 (let
     84                                      val T = Real64Array.array (N, 0.0)
     85                                  in
     86                                      List.app
     87                                          (fn (W) =>
     88                                              List.app
     89                                                  (fn (i,nv) =>
     90                                                      let
     91                                                          val sl = SparseMatrix.slice (W,1,i)
     92                                                      in
     93                                                          SparseMatrix.sliceAppi
     94                                                              (fn (i,x) => update (T,i,Real.+ (Real.* (nv,x), sub(T,i))))
     95                                                              sl
     96                                                      end)
     97                                                  spike_i)
     98                                          S;
     99                                      RTensor.fromArray ([N,1], T)
     100                                  end)
    99101
    100102            val _ = if not (List.null log_spike_i)
     
    106108            if t_i  > tmax
    107109            then (putStrLn out "# All done!"; state_vector_i)
    108             else netrun (D@[I''],state_vector_i,psr_state_vector_i)
     110            else netrun (D@[I'''],state_vector_i,psr_state_vector_i)
    109111        end
    110112      | netrun ([],state_vector,psr_state_vector) = raise Index
     
    129131        (let
    130132            val     _ = putStrLn TextIO.stdOut ("starting fprojection...")
    131             val (S,t) = timing fprojection
     133            val ((S,E),t) = timing fevent_projection
    132134            val     _ = putStrLn TextIO.stdOut ("fprojection took " ^ (Time.toString t) ^ " s")
    133135            val out   = TextIO.openOut (label ^ ".dat")
     
    142144            let
    143145                val _     = putStrLn TextIO.stdOut ("starting simulation...")
    144                 val (_,t) = timing (fn () => start (1200.0, N, S, D, Pn, initial, psr_initial, frun, fresponse, ftime, fspikes, finfo, out))
     146                val (_,t) = timing (fn () => start (1200.0, N, S, E, D, Pn, initial, psr_initial, frun, fresponse, ftime, fspikes, finfo, out))
    145147            in
    146148                putStrLn TextIO.stdOut ("simulation took " ^ (Time.toString t) ^ " s")
Note: See TracChangeset for help on using the changeset viewer.