Feat/models/ego mdp (#2787)

• pytorchcomponents.py
  - collate_afferents: fix accomodation of mech with multiple input_ports and function that takes > 1 argument (e.g., LinearCombination)
  - pytorch_function_creator: refactor linearcombination implementation

• test_learning.py
  - test_backprop_fct_with_2_inputs_to_linear_combination_product and test_backprop_fct_with_3_inputs_to_linear_combination_product: include auto with ExecutionMode.PyTorch

• EGO Model - MDP
  - refactor to not use counter or response layers

• composition.py
  - _parse_receiver_spec(): modify error message for missing receiver to include name of offending Projection
  - _parse_receiver_spec(): modify error message for missing receiver to include name of offending Projection
  - test_composition.py
    - TestAddProjection:
      - restore test for parallel projections between two nodes
      - modify error msg for receiver not specified
      - add test for received node not in comp

* • memoryfunctions.py
  ContentAddressableMemory._validate(): modify error message for scalar fields

---------

Co-authored-by: jdcpni <pniintel55>

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

@@ -2279,10 +2279,11 @@ def __init__(self,
                  prefs:  Optional[ValidPrefSet] = None):
 
         default_variable = default_variable if default_variable is not None else [[0], [0], [0]]
-        error_matrix = np.zeros((len(default_variable[LEARNING_ACTIVATION_OUTPUT]),
-                                 len(default_variable[LEARNING_ERROR_OUTPUT])))
-
-        # self.return_val = ReturnVal(None, None)
+        try:
+            error_matrix = np.zeros((len(default_variable[LEARNING_ACTIVATION_OUTPUT]),
+                                     len(default_variable[LEARNING_ERROR_OUTPUT])))
+        except IndexError:
+            error_matrix = None
 
         super().__init__(
             default_variable=default_variable,

psyneulink/core/components/functions/stateful/memoryfunctions.py

@@ -1258,9 +1258,14 @@ def _validate(self, context=None):
         if (isinstance(distance_function, Distance)
                 and distance_function.metric == COSINE
                 and any([len(v)==1 for v in test_var])):
-            warnings.warn(f"{self.__class__.__name__} is using {distance_function} with metric=COSINE and has "
-                          f"at least one memory field that is a scalar (i.e., size=1), which will always produce "
-                          f"a distance of 0 (the angle of scalars is not defined).")
+            fields_nums_msg = [str(i) for i,v in enumerate(test_var) if len(v)==1]
+            if len(fields_nums_msg) == 1:
+                fields_nums_msg = f"and memory field {fields_nums_msg[0]} that is a scalar; this will"
+            else:
+                fields_nums_msg = f"with memory fields {' ,'.join(fields_nums_msg)} that are scalars, " \
+                                  f"each of which will "
+            warnings.warn(f"{self.componentName} is using {distance_function.componentName} with metric=COSINE "
+                          f"{fields_nums_msg} always produce a distance of 0 (since angle of scalars is not defined).")
 
         field_wts_homog = np.full(len(test_var),1).tolist()
         field_wts_heterog = np.full(len(test_var),range(0,len(test_var))).tolist()

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

@@ -1045,9 +1045,9 @@ class Parameters(ModulatoryMechanism_Base.Parameters):
                     :type: ``list``
                     :read only: True
         """
-        # variable = Parameter(np.array([[0],[0],[0]]),
-        #                      pnl_internal=True,
-        #                      constructor_argument='default_variable')
+        variable = Parameter(np.array([[0],[0]]),
+                             pnl_internal=True,
+                             constructor_argument='default_variable')
         function = Parameter(BackPropagation, stateful=False, loggable=False)
         covariates_sources = Parameter(None, stateful=False, structural=True, read_only=True)
         error_sources = Parameter(None, stateful=False, structural=True, read_only=True)
@@ -1154,32 +1154,25 @@ def _check_type_and_timing(self):
                                                 repr(LEARNING_TIMING)))
 
     def _parse_function_variable(self, variable, context=None):
-        function_variable = np.zeros_like(variable[np.array([ACTIVATION_INPUT_INDEX,
-                                                             ACTIVATION_OUTPUT_INDEX,
-                                                             ERROR_SIGNAL_INDEX])])
-        function_variable[ACTIVATION_INPUT_INDEX] = variable[ACTIVATION_INPUT_INDEX]
-        function_variable[ACTIVATION_OUTPUT_INDEX] = variable[ACTIVATION_OUTPUT_INDEX]
-        function_variable[ERROR_SIGNAL_INDEX] = variable[ERROR_SIGNAL_INDEX]
-        return function_variable
+        # 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))]
 
     def _validate_variable(self, variable, context=None):
         """Validate that variable has exactly three items: activation_input, activation_output and error_signal
         """
 
         variable = super()._validate_variable(variable, context)
 
-        if len(variable) < 3:
-            raise LearningMechanismError("Variable for {} ({}) must have at least three items ({}, {}, and {}{})".
-                                         format(self.name, variable,
-                                                ACTIVATION_INPUT,
-                                                ACTIVATION_OUTPUT,
-                                                ERROR_SIGNAL,"(s)"))
+        # if len(variable) < 3:
+        num_input_ports = len(self.input_ports)
+        error_signals_msg = f", and 'ERROR_SIGNAL(s)'" if num_input_ports > 2 else ""
+        if len(variable) < num_input_ports:
+            raise LearningMechanismError(f"Variable for {self.name} ({variable}) must have at least {num_input_ports} "
+                                         f"items: 'ACTIVATION_INPUT', 'ACTIVATION_INPUT'{error_signals_msg}")
 
-        # Validate that activation_input, activation_output are numeric and lists or 1d np.ndarrays and that
+        # Validate that activation_input, activation_output are numeric and lists or 1d arrays and that
         # there is the correct number of items beyond those for the number of error_sources and covariates_sources
-
-        assert ASSERT, "ADD TEST FOR LEN OF VARIABLE AGAINST NUMBER OF ERROR_SIGNALS AND COVARIATES"
-
         for i in range(len(variable)):
             item_num_string = "Item {i+1}"
 

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

@@ -197,7 +197,7 @@ class Parameters(ProcessingMechanism_Base.Parameters):
                     :type: 'list or np.ndarray'
         """
         function = Parameter(AdaptiveIntegrator(rate=0.5), stateful=False, loggable=False)
-        reset = Parameter([0], modulable=True, stateful=True, constructor_argument='reset_default')
+        reset = Parameter([0], modulable=True, constructor_argument='reset_default')
 
         #
     @check_user_specified

psyneulink/core/compositions/composition.py

@@ -6390,9 +6390,9 @@ def _parse_receiver_spec(self, projection, receiver, sender, learning_projection
             if hasattr(projection, "receiver"):
                 receiver = projection.receiver.owner
             else:
-                raise CompositionError("For a Projection to be added to a Composition, a receiver must be specified, "
-                                       "either on the Projection or in the call to Composition.add_projection(). {}"
-                                       " is missing a receiver specification. ".format(projection.name))
+                raise CompositionError(f"'{projection.name}' is missing a receiver specification.  For a Projection "
+                                       f"to be added to a Composition, a receiver must be specified either on the "
+                                       f"Projection or in the call to Composition.add_projection().")
 
         # initialize all receiver-related variables
         graph_receiver = receiver_mechanism = receiver_input_port = receiver
@@ -6448,13 +6448,12 @@ def _parse_receiver_spec(self, projection, receiver, sender, learning_projection
             if receiver is None:
                 # raise CompositionError(f"receiver arg ({repr(receiver_arg)}) in call to add_projection method of "
                 #                        f"{self.name} is not in it or any of its nested {Composition.__name__}s.")
-                if isinstance(receiver_arg, Port):
-                    receiver_str = f"{receiver_arg} of {receiver_arg.owner}"
-                else:
-                    receiver_str = f"{receiver_arg}"
-                raise CompositionError(f"{receiver_str}, specified as receiver of {Projection.__name__} from "
-                                       f"{sender.name}, is not in {self.name} or any {Composition.__name__}s nested "
-                                       f"within it.")
+                receiver_str = f"{receiver_arg} of {receiver_arg.owner}" \
+                    if isinstance(receiver_arg, Port) else f"{receiver_arg.name}"
+                proj_name = f"'{projection.name}'" if isinstance(projection.name, str) else Projection.__name__
+                raise CompositionError(
+                    f"'{receiver_str}', specified as receiver of '{proj_name}' from '{sender.name}', "
+                    f"is not in '{self.name}' or any {Composition.__name__}s nested within it.")
 
         return receiver, receiver_mechanism, graph_receiver, receiver_input_port, \
                nested_compositions, learning_projection
@@ -8564,6 +8563,20 @@ def _get_acts_in_out_cov(input_source, output_source, learned_projection)->List[
             covariates_sources = _get_covariate_info(output_source, learned_projection)
             # activation_output is always a single value since activation function is assumed to have only one output
             activation_output = [output_source.output_ports[0].value]
+            # insure that output_source.function.derivative can handle covariates
+            if covariates_sources:
+                try:
+                    output_source.function.derivative(input=None, output=activation_output,
+                                                      covariates=[source.variable for source in covariates_sources])
+                except TypeError as error:
+                    if "derivative() got an unexpected keyword argument 'covariates'" in error.args[0]:
+                        raise CompositionError(
+                            f"'{output_source.name}' in '{self.name}' has more than one input_port, "
+                            f"but the derivative of its function ({output_source.function.componentName}) "
+                            f"cannot handle covariates required to determine the partial derivatives of "
+                            f"each input in computing the gradients for Backpropagation; use a function "
+                            f"(such as LinearCombination) that handles more than one argument, "
+                            f"or remove the extra input_ports.")
             return [activation_input, activation_output, covariates_sources]
 
         # Get existing LearningMechanism if one exists (i.e., if this is a crossing point with another pathway)
@@ -8594,6 +8607,7 @@ def _get_acts_in_out_cov(input_source, output_source, learned_projection)->List[
             activation_input, activation_output, covariates_sources = _get_acts_in_out_cov(input_source,
                                                                                            output_source,
                                                                                            learned_projection)
+
             # Use only one error_signal_template for learning_function, since it gets only one source of error at a time
             learning_function = BackPropagation(default_variable=activation_input +
                                                                  activation_output +

psyneulink/library/compositions/emcomposition.py

@@ -111,6 +111,7 @@
 #        - CHECK FOR EXISTING LM ASSERT IN pytests
 #
 #      - AutodiffComposition:
+#         - Check that error occurs for adding a controller to an AutodiffComposition
 #         - Check that if "epochs" is not in input_dict for Autodiff, then:
 #           - set to num_trials as default,
 #           - leave it to override num_trials if specified (add this to DOCUMENTATION)
@@ -160,33 +161,20 @@
 #        - finish adding derivative (for if exponents are specified)
 #        - remove properties (use getter and setter for Parameters)
 #
+#      - ContentAddressableMemory Function:
+#           - rename "cue" -> "query"
+#           - add field_weights as parameter of EM, and make it a shared_parameter ?as well as a function_parameter?
+
 #     - DDM:
 #        - make reset_stateful_function_when a Parameter and arg in constructor
 #          and align with reset Parameter of IntegratorMechanism)
 #
 #    - FIX: BUGS:
-#      - Composition:
-#        - pathways arg:  the following should treat simple_mech as an INPUT node but it doesn't
-#              c = Composition(pathways=[[input,ctl],[simple_mech]])
-#        - parsing of input dict in constructor:
-#             improve error message, though the following attempt in XXX causes errors:
-#             try:
-#                 inputs, num_inputs_sets = self._parse_run_inputs(inputs, context)
-#             except:
-#                 raise CompositionError(f"PROGRAM ERROR: Unexpected problem parsing inputs in run() for {self.name}.")
-#
 #      -LearningMechanism / Backpropagation LearningFunction:
 #         - Construction of LearningMechanism on its own fails; e.g.:
 #             lm = LearningMechanism(learning_rate=.01, learning_function=BackPropagation())
-#             causes the folllowing error:
+#             causes the following error:
 #                TypeError("Logistic.derivative() missing 1 required positional argument: 'self'")
-#      - ContentAddressableMemory Function:
-#           - insure that selection function returns only one non-zero value or, if it weights them parametrically,
-#             then checks against the duplicate_entries setting and warns if that is set.
-#             (cf LINE 1509)
-#           - add tests for use of softmax (and worning if no duplicate_entries is set to True)
-#           - rename "cue" -> "query"
-#           - add field_weights as parameter of EM, and make it a shared_parameter ?as well as a function_parameter?
 #      - Adding GatingMechanism after Mechanisms they gate fails to implement gating projections
 #           (example:  reverse order of the following in _construct_pathways
 #                      self.add_nodes(self.softmax_nodes)

psyneulink/library/compositions/pytorchcomponents.py

@@ -9,15 +9,14 @@
 
 __all__ = ['PytorchMechanismWrapper', 'PytorchProjectionWrapper']
 
-# def lincomb_product(x):
-#     return x[0] * x[1]
 
 def pytorch_function_creator(function, device, context=None):
     """
     Converts a PsyNeuLink function into an equivalent PyTorch lambda function.
     NOTE: This is needed due to PyTorch limitations
     (see: https://github.com/PrincetonUniversity/PsyNeuLink/pull/1657#discussion_r437489990)
     """
+
     def get_fct_param_value(param_name):
         val = function._get_current_parameter_value(
             param_name, context=context)
@@ -34,10 +33,24 @@ def get_fct_param_value(param_name):
         return lambda x: x * slope + intercept
 
     elif isinstance(function, LinearCombination):
-        if get_fct_param_value('operation') == PRODUCT:
-            return lambda x: torch.tensor(x[0], device=device).double() * torch.tensor(x[1], device=device).double()
+        def linear_combination_sum(x):
+            result = torch.tensor([0] * len(x[0]), device=device).double()
+            for t in x:
+                result += t
+            return result
+        def linear_combination_product(x):
+            result = torch.tensor([1] * len(x[0]), device=device).double()
+            for t in x:
+                result *= t
+            return result
+        if function.operation == SUM:
+            return linear_combination_sum
+        elif function.operation == PRODUCT:
+            return linear_combination_product
         else:
-            return lambda x: torch.tensor(x[0], device=device).double() + torch.tensor(x[1], device=device).double()
+            from psyneulink.library.compositions.autodiffcomposition import AutodiffCompositionError
+            raise AutodiffCompositionError(f"The 'operation' parameter of {function.componentName} is not supported "
+                                           f"by AutodiffComposition; use 'SUM' or 'PRODUCT' if possible.")
 
     elif isinstance(function, Logistic):
         gain = get_fct_param_value('gain')
@@ -90,16 +103,16 @@ def add_afferent(self, afferent):
 
 
     def collate_afferents(self):
-        """
-        Returns weight-multiplied sum of all afferent projections
+        """Return weight-multiplied sum of all afferent projections for each input_port of the Mechanism
+        If there are multiple input_ports, return an array with the sum for each input_port
         """
         # FIX: AUGMENT THIS TO SUPPORT InputPort's function
-        # return sum((proj.execute(proj.sender.value) for proj in self.afferents))
         if len(self._mechanism.input_ports) == 1:
             return sum((proj.execute(proj.sender.value) for proj in self.afferents))
         else:
-            return [sum(proj.execute(proj.sender.value) for proj in input_port.path_afferents)
-                    for input_port in self._mechanism.input_ports]
+            # Sum projections to each input_port of the Mechanism and return array with the sums
+            return [sum(proj.execute(proj.sender.value) for proj in self.afferents if proj._projection in
+                        input_port.path_afferents) for input_port in self._mechanism.input_ports ]
 
     def execute(self, variable):
         self.value = self.function(variable)

psyneulink/library/compositions/pytorchmodelcreator.py

@@ -31,10 +31,43 @@ def __init__(self, composition, device, context=None):
 
         self.params = nn.ParameterList()
         self.device = device
+
         self._composition = composition
+        # # FIX: FOR USE IN SUPPORT OF NESTED AUTOCOMPOSITIONS:
+        # from psyneulink.core.compositions.composition import Composition
+        # # First, if the composition has any nested compositions, flatten it.
+        # if any(isinstance(node, Composition) for node in composition.nodes):
+        #     self._composition = composition.flatten()
+        # else:
+        #     self._composition = composition
+
+
+        # FIX: FLATTEN PNL COMPOSITION HERE:
+        #  - CREATE A NEW SCHEDULER FOR FLATTENED COMPOSITION:
+        #    flattened_comp_scheduler = graph_scheduler.Scheduler(flattened_composition)
+        #    flattened_comp_scheduler.add_condition_set(outer_composition.scheduler._user_specified_conds)
+        #    flattened_comp_scheduler.add_condition_set(nested_composition.scheduler._user_specified_conds) <- CAN'T
+        #    INCLUDE TIME-BASED
+        #    REMOVE NESTED COMP FROM OUTER COMPOSITION SCHEDULER
+        #  ON THE OUTER COMP SCHED THAT REFERENCES OR IS FOR THE NESTED COMP DEAL WIH THAT
+        #   USES: check for all dependencies of all outer_comp.scheduler.conditions for any on nest_comp,
+        #         recursing for All() and Any()
+        #   OWNS: if nested_comp in outer_comp.scheduler.conditions
+        #   FANCIER:  TRANSFER CONDITIONS THAT REFEFERENCE THE NESTED COMPOSITION TO ITS INPUT (?BEFORE) / OUTPUT (
+        #   AFTER) NODES
 
         # Instantiate pytorch mechanisms
         for node in set(composition.nodes) - set(composition.get_nodes_by_role(NodeRole.LEARNING)):
+            # FIX: ADD SUPPORT FOR NESTED AUTODIFFCOMPOSITION(S) HERE:
+            #      - WRITE FLATTEN METHOD, WHICH MUST:
+            #        - PRECLUDE CONTROLLERS AT ANY LEVEL OF NESTING
+            #        - CALL ITSELF RECURSIVELY FOR ALL LEVELS OF NESTING
+            #        - CREATE MAP OF PROJECTIONS IN FLATTENED VERSION TO input/output_CIM PROJECTIONS OF NESTED COMPS
+            #        - CREATE NEW SCHEDULER FOR FLATTENED COMP (FOR USE BY AUTODIFF) (see LINES 76-90 BELOW)
+            #      - MAKE SURE ALL NESTED COMPS ARE AUTODIFF-COMPLIANT
+            #      - CALL Composition.flatten()
+            #      - IN update_parameters, MAP PYTORCH PARAMETERS BACK TO input/output_CIM PROJECTIONS OF NESTED COMPS
+
             pytorch_node = PytorchMechanismWrapper(node,
                                                    self._composition._get_node_index(node),
                                                    device,