def __init__(self,
default_gating_allocation=None,
size=None,
monitor_for_gating=None,
function=None,
default_allocation:tc.optional(tc.any(int, float, list, np.ndarray))=None,
gate:tc.optional(list) = None,
modulation:tc.optional(str)=MULTIPLICATIVE,
params=None,
name=None,
prefs:is_pref_set=None,
**kwargs):
gate = convert_to_list(gate) or []
if kwargs:
# For backward compatibility:
if GATING_SIGNALS in kwargs:
args = kwargs.pop(GATING_SIGNALS)
if args:
gate.extend(convert_to_list(args))
if MONITOR_FOR_CONTROL in kwargs:
args = kwargs.pop(MONITOR_FOR_CONTROL)
if args:
monitor_for_gating.extend(convert_to_list(args))
# Assign args to params and functionParams dicts
params = self._assign_args_to_param_dicts(function=function,
params=params)
super().__init__(default_variable=default_gating_allocation,
size=size,
monitor_for_control=monitor_for_gating,
function=function,
default_allocation=default_allocation,
control=gate,
modulation=modulation,
params=params,
name=name,
prefs=prefs,
**kwargs)
def _instantiate_output_ports(self, context=None):
"""Instantiate ControlSignals and assign ControlProjections to Mechanisms in self.modulated_mechanisms
If **modulated_mechanisms** argument of constructor was specified as *ALL*,
assign all ProcessingMechanisms in Compositions to which LCControlMechanism belongs to self.modulated_mechanisms
Instantiate ControlSignal with Projection to the ParameterPort for the multiplicative_param of every
Mechanism listed in self.modulated_mechanisms
"""
from psyneulink.core.components.mechanisms.processing.processingmechanism import ProcessingMechanism_Base
# *ALL* is specified for modulated_mechanisms:
# assign all Processing Mechanisms in LCControlMechanism's Composition(s) to its modulated_mechanisms attribute
# FIX: IMPLEMENT FOR COMPOSITION
if isinstance(self.modulated_mechanisms,
str) and self.modulated_mechanisms is ALL:
if self.systems:
for system in self.systems:
self.modulated_mechanisms = []
for mech in system.mechanisms:
if (mech not in self.modulated_mechanisms
and isinstance(mech, ProcessingMechanism_Base)
and not (isinstance(mech, ObjectiveMechanism)
and mech._role is CONTROL) and
hasattr(mech.function, MULTIPLICATIVE_PARAM)):
self.modulated_mechanisms.append(mech)
else:
# If LCControlMechanism is not in a Process or System, defer implementing OutputPorts until it is
return
# Get the name of the multiplicative_param of each Mechanism in self.modulated_mechanisms
if self.modulated_mechanisms:
# Create (param_name, Mechanism) specification for **control_signals** argument of ControlSignal constructor
self.modulated_mechanisms = convert_to_list(
self.modulated_mechanisms)
multiplicative_param_names = []
for mech in self.modulated_mechanisms:
if isinstance(mech.function.parameters.multiplicative_param,
ParameterAlias):
multiplicative_param_names.append(
mech.function.parameters.multiplicative_param.source.
name)
else:
multiplicative_param_names.append(
mech.function.parameters.multiplicative_param.name)
ctl_sig_projs = []
for mech, mult_param_name in zip(self.modulated_mechanisms,
multiplicative_param_names):
ctl_sig_projs.append((mult_param_name, mech))
self.control = [{PROJECTIONS: ctl_sig_projs}]
self.parameters.control_allocation.default_value = self.value[0]
super()._instantiate_output_ports(context=context)
def _instantiate_output_ports(self, context=None):
"""Instantiate ControlSignals and assign ControlProjections to Mechanisms in self.modulated_mechanisms
If **modulated_mechanisms** argument of constructor was specified as *ALL*, assign all ProcessingMechanisms
in Compositions to which LCControlMechanism belongs to self.modulated_mechanisms.
Instantiate ControlSignal with Projection to the ParameterPort for the multiplicative_param of every
Mechanism listed in self.modulated_mechanisms.
"""
from psyneulink.core.components.mechanisms.processing.processingmechanism import ProcessingMechanism_Base
# A Composition is specified for modulated_mechanisms, so assign all Processing Mechanisms in composition
# to its modulated_mechanisms attribute
from psyneulink.core.compositions.composition import Composition, NodeRole
if isinstance(self.modulated_mechanisms, Composition):
comp = self.modulated_mechanisms
self.modulated_mechanisms = []
for mech in [
m for m in comp.nodes
if (isinstance(m, ProcessingMechanism_Base) and not (
isinstance(m, ObjectiveMechanism)
and comp.get_roles_for_node(m) != NodeRole.CONTROL)
and hasattr(m.function, MULTIPLICATIVE_PARAM))
]:
self.modulated_mechanisms.append(mech)
# Get the name of the multiplicative_param of each Mechanism in self.modulated_mechanisms
if self.modulated_mechanisms:
# Create (param_name, Mechanism) specification for **control_signals** argument of ControlSignal constructor
self.modulated_mechanisms = convert_to_list(
self.modulated_mechanisms)
multiplicative_param_names = []
for mech in self.modulated_mechanisms:
if isinstance(mech.function.parameters.multiplicative_param,
ParameterAlias):
multiplicative_param_names.append(
mech.function.parameters.multiplicative_param.source.
name)
else:
multiplicative_param_names.append(
mech.function.parameters.multiplicative_param.name)
ctl_sig_projs = []
for mech, mult_param_name in zip(self.modulated_mechanisms,
multiplicative_param_names):
ctl_sig_projs.append((mult_param_name, mech))
self.parameters.control._set([{
PROJECTIONS: ctl_sig_projs
}], context)
self.parameters.control_allocation.default_value = self.value[0]
super()._instantiate_output_ports(context=context)
self.aux_components.extend(self.control_projections)
def write_json_file(compositions, filename: str, path: str = None):
"""
Write one or more `Compositions <Composition>` and associated objects to file in the `general JSON format
<JSON_Model_Specification>`
.. _JSON_Write_Multiple_Compositions_Note:
.. note::
At present, if more than one Composition is specified, all must be fully disjoint; that is, they must not
share any `Components <Component>` (e.g., `Mechanism`, `Projections` etc.). This limitation will be
addressed in a future update.
Arguments
---------
compositions : Composition or list˚
specifies `Composition` or list of ones to be written to **filename**
filename : str
specifies name of file in which to write JSON specification of `Composition(s) <Composition>`
and associated objects.
path : str : default None
specifies path of file for JSON specification; if it is not specified then the current directory is used.
"""
compositions = convert_to_list(compositions)
for c in compositions:
from psyneulink.core.compositions.composition import Composition
if not isinstance(c, Composition):
raise PNLJSONError(
f'Item in compositions arg of write_to_json_file() is not a Composition: {c}.'
)
if path:
if path[-1] != '/':
path += '/'
filename = path + filename
merged_dict_summary = {}
for c in compositions:
try:
merged_dict_summary[MODEL_SPEC_ID_COMPOSITION].extend(
c._dict_summary[MODEL_SPEC_ID_COMPOSITION])
except KeyError:
merged_dict_summary.update(c._dict_summary)
with open(filename, 'w') as json_file:
json_file.write(_dump_pnl_json_from_dict(merged_dict_summary))
def _instantiate_control_signal_type(self, gating_signal_spec, context):
"""Instantiate actual ControlSignal, or subclass if overridden"""
from psyneulink.core.components.ports.port import _instantiate_port
from psyneulink.core.components.projections.projection import ProjectionError
allocation_parameter_default = self.parameters.gating_allocation.default_value
gating_signal = _instantiate_port(port_type=GatingSignal,
owner=self,
variable=self.default_allocation # User specified value
or allocation_parameter_default, # Parameter default
reference_value=allocation_parameter_default,
modulation=self.modulation,
port_spec=gating_signal_spec,
context=context)
if not type(gating_signal) in convert_to_list(self.outputPortTypes):
raise ProjectionError(f'{type(gating_signal)} inappropriate for {self.name}')
return gating_signal