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