function=pnl.LinearMatrix(matrix=[[1.0]], default_variable=[0.5]), ), sender=B, receiver=D, ) comp.add_projection( projection=pnl.MappingProjection( name="MappingProjection from C[RESULT] to D[InputPort-0]", function=pnl.LinearMatrix(matrix=[[1.0]]), ), sender=C, receiver=D, ) comp.add_projection( projection=pnl.MappingProjection( name="MappingProjection from C[RESULT] to Inner Composition Input_CIM[INPUT_CIM_E_InputPort-0]", function=pnl.LinearMatrix(matrix=[[1.0]]), ), sender=C, receiver=Inner_Composition, ) comp.scheduler.add_condition(A, pnl.EveryNPasses(1, pnl.TimeScale.TRIAL)) comp.scheduler.add_condition(B, pnl.EveryNCalls(A, 2)) comp.scheduler.add_condition(C, pnl.EveryNCalls(B, 2)) comp.scheduler.termination_conds = { pnl.TimeScale.RUN: pnl.AfterNTrials(1, pnl.TimeScale.RUN), pnl.TimeScale.TRIAL: pnl.AfterNCalls(D, 4), }
import psyneulink as pnl comp = pnl.Composition(name='comp') A = pnl.TransferMechanism(name='A') B = pnl.TransferMechanism(name='B') C = pnl.TransferMechanism(name='C') comp.add_linear_processing_pathway([A, B, C]) comp.scheduler.add_condition_set({ A: pnl.AtNCalls(A, 0), B: pnl.Always(), C: pnl.EveryNCalls(B, 5), }) comp.run(inputs={A: 1}) # A, B, B, B, B, B, C print(comp.scheduler.execution_list[comp.default_execution_id]) with open(__file__.replace('.py', '.json'), 'w') as f: f.write(comp.json_summary + '\n')
comp.add_projection( projection=pnl.MappingProjection( name="MappingProjection_from_A_RESULT__to_B_InputPort_0_", function=pnl.LinearMatrix(matrix=[[1.0]]), ), sender=A, receiver=B, ) comp.add_projection( projection=pnl.MappingProjection( name="MappingProjection_from_B_RESULT__to_C_InputPort_0_", function=pnl.LinearMatrix(matrix=[[1.0]]), ), sender=B, receiver=C, ) comp.scheduler.add_condition( A, pnl.AtNCalls(dependency=A, n=0, time_scale=pnl.TimeScale.ENVIRONMENT_STATE_UPDATE), ) comp.scheduler.add_condition(B, pnl.Always()) comp.scheduler.add_condition(C, pnl.EveryNCalls(dependency=B, n=5)) comp.scheduler.termination_conds = { pnl.TimeScale.ENVIRONMENT_SEQUENCE: pnl.Never(), pnl.TimeScale.ENVIRONMENT_STATE_UPDATE: pnl.AllHaveRun(), }
sender=TASK, receiver=color_hidden, ) Stroop_model.add_projection( projection=pnl.MappingProjection( name="MappingProjection_from_TASK_RESULT__to_word_hidden_InputPort_0", function=pnl.LinearMatrix(default_variable=[0.5, 0.5], matrix=[[0.0, 0.0], [4.0, 4.0]]), ), sender=TASK, receiver=word_hidden, ) Stroop_model.add_controller(CONTROL) Stroop_model.scheduler.add_condition(word_hidden, pnl.EveryNCalls(dependency=TASK, n=10)) Stroop_model.scheduler.add_condition(color_hidden, pnl.EveryNCalls(dependency=TASK, n=10)) Stroop_model.scheduler.add_condition( OUTPUT, pnl.All( pnl.EveryNCalls(dependency=color_hidden, n=1), pnl.EveryNCalls(dependency=word_hidden, n=1), ), ) Stroop_model.scheduler.add_condition(DECISION, pnl.EveryNCalls(dependency=OUTPUT, n=1)) Stroop_model.scheduler.termination_conds = { pnl.TimeScale.ENVIRONMENT_SEQUENCE: pnl.Never(), pnl.TimeScale.ENVIRONMENT_STATE_UPDATE: pnl.AllHaveRun(),
control_signals=[(pnl.GAIN, task)], ) # Construct the Composition: Stroop_model = pnl.Composition(name="Stroop_model") Stroop_model.add_linear_processing_pathway(color_pathway) Stroop_model.add_linear_processing_pathway(word_pathway) Stroop_model.add_linear_processing_pathway(task_color_pathway) Stroop_model.add_linear_processing_pathway(task_word_pathway) Stroop_model.add_linear_processing_pathway(decision_pathway) Stroop_model.add_controller(control) # Assign conditions: settling_time = 10 Stroop_model.scheduler.add_condition( color_hidden, pnl.EveryNCalls(task, settling_time) ) Stroop_model.scheduler.add_condition( word_hidden, pnl.EveryNCalls(task, settling_time) ) Stroop_model.scheduler.add_condition( output, pnl.All(pnl.EveryNCalls(color_hidden, 1), pnl.EveryNCalls(word_hidden, 1)), ) Stroop_model.scheduler.add_condition(decision, pnl.EveryNCalls(output, 1)) #Stroop_model.show_graph(show_controller=True) #Stroop_model.run(animate={"show_controller":True}) red = [1,0]
import psyneulink as pnl comp = pnl.Composition(name='comp') A = pnl.TransferMechanism(function=pnl.Linear(slope=5.0, intercept=2.0), name='A') B = pnl.TransferMechanism(function=pnl.Logistic, name='B') for m in [A, B]: comp.add_node(m) comp.add_projection(pnl.MappingProjection(), A, B) comp.scheduler.add_condition_set({ A: pnl.EveryNPasses(1), B: pnl.EveryNCalls(A, 2), }) comp.termination_processing = { pnl.TimeScale.RUN: pnl.AfterNTrials(1), pnl.TimeScale.TRIAL: pnl.AfterNCalls(B, 4) } comp2 = pnl.Composition(name='comp2') for m in [A, B]: comp2.add_node(m) comp2.add_projection(pnl.MappingProjection(), A, B) comp2.scheduler.add_condition_set({ A: pnl.EveryNPasses(1),
comp.add_node(C) comp.add_node(Inner_Composition) comp.add_projection( projection=pnl.MappingProjection( name="MappingProjection_from_A_RESULT__to_B_InputPort_0_", function=pnl.LinearMatrix(default_variable=[2.0], matrix=[[1.0]]), ), sender=A, receiver=B, ) comp.add_projection( projection=pnl.MappingProjection( name="MappingProjection_from_A_RESULT__to_C_InputPort_0_", function=pnl.LinearMatrix(default_variable=[2.0], matrix=[[1.0]]), ), sender=A, receiver=C, ) comp.scheduler.add_condition(A, pnl.Always()) comp.scheduler.add_condition(B, pnl.EveryNCalls(dependency=A, n=1)) comp.scheduler.add_condition(C, pnl.EveryNCalls(dependency=A, n=1)) comp.scheduler.add_condition(Inner_Composition, pnl.EveryNCalls(dependency=C, n=1)) comp.scheduler.termination_conds = { pnl.TimeScale.ENVIRONMENT_SEQUENCE: pnl.Never(), pnl.TimeScale.ENVIRONMENT_STATE_UPDATE: pnl.AllHaveRun(), }
import psyneulink as pnl comp = pnl.Composition(name='comp') A = pnl.TransferMechanism(name='A') B = pnl.TransferMechanism(name='B') C = pnl.TransferMechanism(name='C') D = pnl.TransferMechanism(name='D') comp.add_linear_processing_pathway([A, B, C]) comp.add_linear_processing_pathway([A, B, D]) comp.scheduler.add_condition_set({ A: pnl.AtNCalls(A, 0), B: pnl.Always(), C: pnl.EveryNCalls(B, 5), D: pnl.EveryNCalls(B, 10), }) comp.run(inputs={A: 1}) # A, B, B, B, B, B, C, A, B, B, B, B, B, {C, D} print(comp.scheduler.execution_list[comp.default_execution_id]) with open(__file__.replace('.py', '.json'), 'w') as f: f.write(comp.json_summary) comp.show_graph()
matrix=[[3, -3], [-3, 3]], ), sender=word_hidden, receiver=OUTPUT, ) Stroop_model.add_projection( projection=pnl.MappingProjection( name="MappingProjection from word_input[OutputPort-0] to word_hidden[InputPort-0]", function=pnl.LinearMatrix( matrix=[[3.0, -3.0], [-3.0, 3.0]], default_variable=[0.0, 0.0] ), matrix=[[3, -3], [-3, 3]], ), sender=word_input, receiver=word_hidden, ) Stroop_model.add_controller(CONTROL) Stroop_model.scheduler.add_condition(DECISION, pnl.EveryNCalls(OUTPUT, 1)) Stroop_model.scheduler.add_condition( OUTPUT, pnl.All(pnl.EveryNCalls(color_hidden, 1), pnl.EveryNCalls(word_hidden, 1)), ) Stroop_model.scheduler.add_condition(color_hidden, pnl.EveryNCalls(TASK, 10)) Stroop_model.scheduler.add_condition(word_hidden, pnl.EveryNCalls(TASK, 10)) Stroop_model.scheduler.termination_conds = { pnl.TimeScale.RUN: pnl.Never(), pnl.TimeScale.TRIAL: pnl.AllHaveRun(), }
import psyneulink as pnl comp = pnl.Composition(name="comp") A = pnl.TransferMechanism(name="A") B = pnl.TransferMechanism(name="B") C = pnl.TransferMechanism(name="C") D = pnl.TransferMechanism(name="D") comp.add_linear_processing_pathway([A, B, C]) comp.add_linear_processing_pathway([A, B, D]) comp.scheduler.add_condition_set({ A: pnl.AtNCalls(A, 0), B: pnl.Always(), C: pnl.EveryNCalls(B, 5), D: pnl.EveryNCalls(C, 2), }) comp.run(inputs={A: 1}) # A, B, B, B, B, B, C, A, B, B, B, B, B, {C, D} print([{ node.name for node in time_step } for time_step in comp.scheduler.execution_list[comp.default_execution_id]]) # comp.show_graph()
C = pnl.RecurrentTransferMechanism(name="C") D = pnl.IntegratorMechanism(function=pnl.SimpleIntegrator, name="D") E = pnl.TransferMechanism(name="E") F = pnl.TransferMechanism(name="F") for m in [E, F]: inner_comp.add_node(m) for m in [A, B, C, D, inner_comp]: comp.add_node(m) comp.add_projection(pnl.MappingProjection(), A, B) comp.add_projection(pnl.MappingProjection(), A, C) comp.add_projection(pnl.MappingProjection(), B, D) comp.add_projection(pnl.MappingProjection(), C, D) comp.add_projection(pnl.MappingProjection(), C, inner_comp) inner_comp.add_projection(pnl.MappingProjection(), E, F) comp.scheduler.add_condition_set({ A: pnl.EveryNPasses(1), B: pnl.EveryNCalls(A, 2), C: pnl.EveryNCalls(B, 2) }) comp.termination_processing = { pnl.TimeScale.RUN: pnl.AfterNTrials(1), pnl.TimeScale.TRIAL: pnl.AfterNCalls(D, 4), }
) ABCD.add_projection( projection=pnl.MappingProjection( name="MappingProjection_from_A_RESULT__to_C_InputPort_0_", function=pnl.LinearMatrix(default_variable=[2.0], matrix=[[1.0]]), ), sender=A, receiver=C, ) ABCD.add_projection( projection=pnl.MappingProjection( name="MappingProjection_from_C_RESULT__to_D_InputPort_0_", function=pnl.LinearMatrix(default_variable=[1.0], matrix=[[1.0]]), ), sender=C, receiver=D, ) ABCD.scheduler.add_condition(A, pnl.Always()) ABCD.scheduler.add_condition(C, pnl.EveryNCalls(dependency=A, n=1)) ABCD.scheduler.add_condition(B, pnl.EveryNCalls(dependency=A, n=1)) ABCD.scheduler.add_condition( D, pnl.All(pnl.EveryNCalls(dependency=C, n=1), pnl.EveryNCalls(dependency=B, n=1))) ABCD.scheduler.termination_conds = { pnl.TimeScale.ENVIRONMENT_SEQUENCE: pnl.Never(), pnl.TimeScale.ENVIRONMENT_STATE_UPDATE: pnl.AllHaveRun(), }
name='MappingProjection from A[RESULT] to B[InputPort-0]', function=pnl.LinearMatrix(matrix=[[1.0]], default_variable=[2.0])), sender=A, receiver=B) ABCD.add_projection(projection=pnl.MappingProjection( name='MappingProjection from A[RESULT] to C[InputPort-0]', function=pnl.LinearMatrix(matrix=[[1.0]], default_variable=[2.0])), sender=A, receiver=C) ABCD.add_projection(projection=pnl.MappingProjection( name='MappingProjection from B[RESULT] to D[InputPort-0]', function=pnl.LinearMatrix(matrix=[[1.0]], default_variable=[0.5])), sender=B, receiver=D) ABCD.add_projection(projection=pnl.MappingProjection( name='MappingProjection from C[RESULT] to D[InputPort-0]', function=pnl.LinearMatrix(matrix=[[1.0]], default_variable=[1.0])), sender=C, receiver=D) ABCD.scheduler.add_condition(A, pnl.Always()) ABCD.scheduler.add_condition(B, pnl.EveryNCalls(A, 1)) ABCD.scheduler.add_condition(C, pnl.EveryNCalls(A, 1)) ABCD.scheduler.add_condition( D, pnl.All(pnl.EveryNCalls(C, 1), pnl.EveryNCalls(B, 1))) ABCD.scheduler.termination_conds = { pnl.TimeScale.RUN: pnl.Never(), pnl.TimeScale.TRIAL: pnl.AllHaveRun() } comp.show_graph()
print('Running simple model of FitzHugh Nagumo cell for %sms: %s' % (simtime, fhn)) fn = pnl.IntegratorMechanism(name='fn', function=fhn) comp = pnl.Composition(name='comp') im = pnl.IntegratorMechanism(name='im') # only used to demonstrate conditions comp.add_linear_processing_pathway([fn, im]) comp.scheduler.add_condition_set({ fn: pnl.Always(), # default im: pnl.All( # run when both conditions are met pnl.EveryNCalls(fn, 1 / dt), # every 1ms, based on fn frequency pnl.AfterNCalls(fn, .8 * simtime / dt) # after 80ms, based on fn frequency ) }) comp.termination_processing = { pnl.TimeScale.RUN: pnl.Never( ), # default, "Never" for early termination - ends when all trials finished pnl.TimeScale.TRIAL: pnl.AfterNCalls(fn, int(simtime / dt)) } print('Running the SimpleFN model...') comp.run(inputs={fn: 0}, log=True)
import psyneulink as pnl comp = pnl.Composition(name='comp') A = pnl.TransferMechanism(function=pnl.Linear(slope=5.0, intercept=2.0), name='A') B = pnl.TransferMechanism(function=pnl.Logistic, name='B') for m in [A, B]: comp.add_node(m) comp.add_projection(pnl.MappingProjection(), A, B) comp.scheduler.add_condition_set({ A: pnl.EveryNPasses(1), B: pnl.EveryNCalls(A, 2), }) comp.termination_processing = { pnl.TimeScale.RUN: pnl.AfterNTrials(1), pnl.TimeScale.TRIAL: pnl.AfterNCalls(B, 4) } comp2 = pnl.Composition(name='comp2') C = pnl.TransferMechanism(function=pnl.Linear(slope=5.0, intercept=2.0), name='C') D = pnl.TransferMechanism(function=pnl.Logistic, name='D') for m in [C, D]: comp2.add_node(m) comp2.add_projection(pnl.MappingProjection(), C, D)
function=pnl.FitzHughNagumoIntegrator( name='FitzHughNagumoIntegrator Function-0', d_v=1, initial_v=-1, initializer=[[0]], default_variable=[[0]])) im = pnl.IntegratorMechanism(name='im', function=pnl.AdaptiveIntegrator( initializer=[[0]], rate=0.5, default_variable=[[0]])) comp.add_node(fn) comp.add_node(im) comp.add_projection(projection=pnl.MappingProjection( name='MappingProjection from fn[OutputPort-0] to im[InputPort-0]', function=pnl.LinearMatrix(matrix=[[1.0]], default_variable=[-1.0])), sender=fn, receiver=im) comp.scheduler.add_condition(fn, pnl.Always()) comp.scheduler.add_condition( im, pnl.All(pnl.EveryNCalls(fn, 20.0), pnl.AfterNCalls(fn, 1600.0))) comp.scheduler.termination_conds = { pnl.TimeScale.RUN: pnl.Never(), pnl.TimeScale.TRIAL: pnl.AfterNCalls(fn, 2000) } comp.show_graph()
comp.add_node(im) comp.add_projection( projection=pnl.MappingProjection( name="MappingProjection_from_fn_OutputPort_0__to_im_InputPort_0_", function=pnl.LinearMatrix(default_variable=[-1.0], matrix=[[1.0]]), ), sender=fn, receiver=im, ) comp.scheduler.add_condition(fn, pnl.Always()) comp.scheduler.add_condition( im, pnl.All( pnl.EveryNCalls(dependency=fn, n=20.0), pnl.AfterNCalls(dependency=fn, n=1600.0, time_scale=pnl.TimeScale.ENVIRONMENT_STATE_UPDATE), ), ) comp.scheduler.termination_conds = { pnl.TimeScale.ENVIRONMENT_SEQUENCE: pnl.Never(), pnl.TimeScale.ENVIRONMENT_STATE_UPDATE: pnl.AfterNCalls(dependency=fn, n=2000, time_scale=pnl.TimeScale.ENVIRONMENT_STATE_UPDATE), }