Python EveryNCalls 예제들

예제 #1

        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),
}

예제 #2

파일: SimpleLinear-conditional.py 프로젝트: kmantel/MDFTests

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')

예제 #3

파일: SimpleLinear-conditional.reconstructed.py 프로젝트: kmantel/MDF

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(),
}

예제 #4

파일: stroop_conflict_monitoring.reconstructed.py 프로젝트: kmantel/MDF

    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(),

예제 #5

파일: stroop_conflict_monitoring.py 프로젝트: OpenSourceBrain/PsyNeuLinkShowcase

    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]

예제 #6

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),

예제 #7

파일: model_with_nested_graph.reconstructed.py 프로젝트: kmantel/MDF

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(),
}

예제 #8

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()

예제 #9

        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(),
}

예제 #10

파일: SimpleBranching-conditional.py 프로젝트: kmantel/MDF

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()

예제 #11

파일: model_nested_comp_with_scheduler.py 프로젝트: kmantel/MDF

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),
}

예제 #12

파일: model_ABCD.reconstructed.py 프로젝트: kmantel/MDF

)
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(),
}

예제 #13

    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()

예제 #14

파일: SimpleFN-conditional.py 프로젝트: kmantel/MDFTests

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)

예제 #15

파일: model_with_two_disjoint_comps.py 프로젝트: uiuc-arc/PsyNeuLink

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)

예제 #16

파일: SimpleFN-conditional.converted.py 프로젝트: kmantel/MDFTests

                             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()

예제 #17

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),
}