Feat/learning nested

Scripts/Models (Under Development)/EGO/EGO Model - MDP.py

@@ -9,6 +9,9 @@
 
 # FIX: TERMINATION CONDITION IS GETTING TRIGGED AFTER 1st TRIAL
 
+# FOR INPUT NODES: scheduler.add_condition(A, BeforeNCalls(A,1)
+# Termination: AfterNCalls(Ctl,2)
+
 """
 QUESTIONS:
 
@@ -105,6 +108,7 @@
        Use of SweetPea for stimulus generation requires it be installed::
        >> pip install sweetpea
 
+
 .. _EGO_training:
 
 *Training*

psyneulink/core/components/functions/nonstateful/combinationfunctions.py

@@ -1256,12 +1256,16 @@ def _validate_variable(self, variable, context=None):
                     old_length = 1
                 else:
                     old_length = len(variable[i - 1])
-                if isinstance(variable[i], numbers.Number):
+                if variable[i] is None:
+                    owner_str = f"'{self.owner.name}' " if self.owner else ''
+                    raise FunctionError(f"One of the elements of variable for {self.__class__.__name__} function "
+                                        f"of {owner_str}is None; variable: {variable}.")
+                elif isinstance(variable[i], numbers.Number):
                     new_length = 1
                 else:
                     new_length = len(variable[i])
                 if old_length != new_length:
-                    owner_str = f"'{self.owner.name }'" if self.owner else ''
+                    owner_str = f"'{self.owner.name }' " if self.owner else ''
                     raise FunctionError(f"Length of all arrays in variable for {self.__class__.__name__} function "
                                         f"of {owner_str}must be the same; variable: {variable}.")
         return variable

psyneulink/core/components/functions/nonstateful/learningfunctions.py

@@ -2480,8 +2480,11 @@ def _function(self,
         self.parameters.error_matrix._set(error_matrix, context)
         # self._check_args(variable=variable, context=context, params=params, context=context)
 
-        # If learning_rate was not specified for instance or composition, use default value
-        learning_rate = self._get_current_parameter_value(LEARNING_RATE, context)
+        # If learning_rate was not specified for instance or composition or in params, use default value
+        if params and LEARNING_RATE in params and params[LEARNING_RATE] is not None:
+            learning_rate = params[LEARNING_RATE]
+        else:
+            learning_rate = self._get_current_parameter_value(LEARNING_RATE, context)
         if learning_rate is None:
             learning_rate = self.defaults.learning_rate
 

psyneulink/core/components/mechanisms/modulatory/learning/learningmechanism.py

@@ -1154,9 +1154,17 @@ def _check_type_and_timing(self):
                                                 repr(LEARNING_TIMING)))
 
     def _parse_function_variable(self, variable, context=None):
+        # # MODIFIED 9/11/23 OLD:
         # Return values of ACTIVATION_INPUT_INDEX, ACTIVATION_OUTPUT_INDEX, and first ERROR_SIGNAL_INDEX InputPorts
         #   in variable; remaining inputs (additional error signals and/or COVARITES) are passed in kwargs)
         return variable[range(min(len(self.input_ports),3))]
+        # MODIFIED 9/11/23 NEW:
+        # Return values of ACTIVATION_INPUT, ACTIVATION_OUTPUT, and ERROR_SIGNAL InputPorts in variable;
+        #   remaining inputs (additional error signals and/or COVARITES) are passed in kwargs)
+        # return np.array(self.input_values, dtype=object)
+        # FIX: SHOULD EXTRA ERROR_SIGNAL (AND ERROR_MATRIX) BE PUT IN params? CF WHAT HAPPENS WITH RUMELHART NETWORK
+        # return variable[range(2 + len(self.error_signal_input_ports))]
+        # MODIFIED 9/11/23 END
 
     def _validate_variable(self, variable, context=None):
         """Validate that variable has exactly three items: activation_input, activation_output and error_signal
@@ -1395,10 +1403,11 @@ def add_ports(self, error_sources, context=None):
             error_source = input_port.path_afferents[0].sender.owner
             self.error_matrices.append(error_source.primary_learned_projection.parameter_ports[MATRIX])
             if ERROR_SIGNAL in input_port.name:
-                # self._error_signal_input_ports.append(input_port)
                 self.error_signal_input_ports.append(input_port)
             instantiated_input_ports.append(input_port)
 
+        assert True
+
         # TODO: enable this. fails because LearningMechanism does not have a
         # consistent _parse_function_variable
         # self._update_default_variable(np.asarray(self.input_values, dtype=int), context)

psyneulink/core/components/mechanisms/processing/compositioninterfacemechanism.py

@@ -274,12 +274,13 @@ def _get_destination_info_from_input_CIM(self, port, comp=None):
         comp = comp or self.composition
         port_map = port.owner.port_map
         idx = 0 if isinstance(port, InputPort) else 1
-        output_port = [port_map[k][1] for k in port_map if port_map[k][idx] is port]
-        assert len(output_port)==1, f"PROGRAM ERROR: Expected exactly 1 output_port for {port.name} " \
-                                   f"in port_map for {port.owner}; found {len(output_port)}."
-        assert len(output_port[0].efferents)==1, f"PROGRAM ERROR: Port ({output_port.name}) expected to have " \
-                                                 f"just one efferent; has {len(output_port.efferents)}."
-        receiver = output_port[0].efferents[0].receiver
+        output_ports = [port_map[k][1] for k in port_map if port_map[k][idx] is port]
+        assert len(output_ports)==1, f"PROGRAM ERROR: Expected exactly 1 output_port for {port.name} " \
+                                   f"in port_map for {port.owner}; found {len(output_ports)}."
+        output_port = output_ports[0]
+        assert len(output_port.efferents)==1, f"PROGRAM ERROR: Port ({output_port.name}) expected to have " \
+                                              f"just one efferent; has {len(output_port.efferents)}."
+        receiver = output_port.efferents[0].receiver
         if not isinstance(receiver.owner, CompositionInterfaceMechanism):
             return receiver, receiver.owner, comp
         return self._get_destination_info_from_input_CIM(receiver, receiver.owner.composition)
@@ -347,16 +348,53 @@ def _get_source_info_from_output_CIM(self, port, comp=None):
         comp = comp or self.composition
         port_map = port.owner.port_map
         idx = 0 if isinstance(port, InputPort) else 1
-        input_port = [port_map[k][0] for k in port_map if port_map[k][idx] is port]
-        assert len(input_port)==1, f"PROGRAM ERROR: Expected exactly 1 input_port for {port.name} " \
-                                   f"in port_map for {port.owner}; found {len(input_port)}."
-        assert len(input_port[0].path_afferents)==1, f"PROGRAM ERROR: Port ({input_port.name}) expected to have " \
-                                                     f"just one path_afferent; has {len(input_port.path_afferents)}."
-        sender = input_port[0].path_afferents[0].sender
+        input_ports = [port_map[k][0] for k in port_map if port_map[k][idx] is port]
+        assert len(input_ports)==1, f"PROGRAM ERROR: Expected exactly 1 input_port for {port.name} " \
+                                   f"in port_map for {port.owner}; found {len(input_ports)}."
+        assert len(input_ports[0].path_afferents)==1, f"PROGRAM ERROR: Port ({input_ports[0].name}) expected to have " \
+                                                     f"just one path_afferent; has {len(input_ports.path_afferents)}."
+        sender = input_ports[0].path_afferents[0].sender
         if not isinstance(sender.owner, CompositionInterfaceMechanism):
             return sender, sender.owner, comp
         return self._get_source_info_from_output_CIM(sender, sender.owner.composition)
 
+    def _get_destination_info_for_output_CIM(self, port, comp=None)-> list:
+        """Return Port, Node and Composition for "ultimate" destination(s) of projection to **port**.
+        **port**: InputPort or OutputPort of the output_CIM to which the projection of interest projects;
+                  used to find source (key=SENDER PORT) of the projection to the output_CIM.
+        **comp**: Composition at which to begin the search (or continue it when called recursively);
+                 assumes the Composition for the output_CIM to which **port** belongs by default
+        If there is more than one destination, return list of tuples, one for each destination;
+        this occurs if the source of the projection to the output_CIM (SENDER PORT) is a Node in a nested Composition
+        that is specified to project to more than one Node in the outer Composition
+        """
+        from psyneulink.core.compositions.composition import get_composition_for_node
+
+        # Ensure method is being called on an output_CIM
+        assert self == self.composition.output_CIM
+        #  CIM MAP ENTRIES:  [SENDER PORT,  [output_CIM InputPort,  output_CIM OutputPort]]
+        # Get receiver of output_port of output_CIM
+        comp = comp or self.composition
+        port_map = port.owner.port_map
+        idx = 0 if isinstance(port, InputPort) else 1
+        output_ports = [port_map[k][1] for k in port_map if port_map[k][idx] is port]
+        assert len(output_ports)==1, f"PROGRAM ERROR: Expected exactly 1 output_port for {port.name} " \
+                                   f"in port_map for {port.owner}; found {len(output_ports)}."
+        output_port = output_ports[0]
+        receivers_info = []
+        if not output_port.efferents:
+            return None
+        for efferent in output_port.efferents:
+            receiver = efferent.receiver
+            if not isinstance(efferent.receiver.owner, CompositionInterfaceMechanism):
+                assert comp.is_nested
+                receiver_comp = get_composition_for_node(receiver.owner)
+                receivers_info.append((efferent.receiver, efferent.receiver.owner, receiver_comp))
+            else:
+                receivers_info.append(self._get_destination_info_for_output_CIM(efferent.receiver,
+                                                                                efferent.receiver.owner.composition))
+        return receivers_info
+
     def _sender_is_probe(self, output_port):
         """Return True if source of output_port is a PROBE Node of the Composition to which it belongs"""
         from psyneulink.core.compositions.composition import NodeRole