Merge pull request #3211 from PrincetonUniversity/devel

Devel

Author: kmantel

.github/actions/install-pnl/action.yml

@@ -103,7 +103,7 @@ runs:
         pip install setuptools wheel
         python setup.py sdist bdist_wheel
         echo "wheel=$(ls dist/*.whl)" | tee -a "$GITHUB_OUTPUT"
-        echo "sdist=$(ls dist/*.sdist)" | tee -a "$GITHUB_OUTPUT"
+        echo "sdist=$(ls dist/*.tar.gz)" | tee -a "$GITHUB_OUTPUT"
 
     - name: Python dependencies
       shell: bash

conftest.py

@@ -71,8 +71,7 @@ def pytest_runtest_setup(item):
 def pytest_generate_tests(metafunc):
     mech_and_func_modes = ['Python',
                            pytest.param('LLVM', marks=pytest.mark.llvm),
-                           pytest.param('PTX', marks=[pytest.mark.llvm,
-                                                      pytest.mark.cuda])
+                           pytest.param('PTX', marks=[pytest.mark.llvm, pytest.mark.cuda])
                           ]
 
     if "func_mode" in metafunc.fixturenames:
@@ -81,9 +80,9 @@ def pytest_generate_tests(metafunc):
     if "mech_mode" in metafunc.fixturenames:
         metafunc.parametrize("mech_mode", mech_and_func_modes)
 
-    if "comp_mode_no_llvm" in metafunc.fixturenames:
+    if "comp_mode_no_per_node" in metafunc.fixturenames:
         modes = [m for m in get_comp_execution_modes()
-                 if m.values[0] is not pnlvm.ExecutionMode.LLVM]
+                 if m.values[0] is not pnlvm.ExecutionMode._LLVMPerNode]
         metafunc.parametrize("comp_mode", modes)
 
     elif "comp_mode" in metafunc.fixturenames:
@@ -151,7 +150,7 @@ def pytest_runtest_teardown(item):
     pnlvm.cleanup("llvm" in item.keywords and not skip_cleanup_check)
 
 @pytest.fixture
-def comp_mode_no_llvm():
+def comp_mode_no_per_node():
     # dummy fixture to allow 'comp_mode' filtering
     pass
 
@@ -187,8 +186,8 @@ def llvm_current_fp_precision():
 @pytest.helpers.register
 def get_comp_execution_modes():
     return [pytest.param(pnlvm.ExecutionMode.Python),
-            pytest.param(pnlvm.ExecutionMode.LLVM, marks=pytest.mark.llvm),
-            pytest.param(pnlvm.ExecutionMode.LLVMExec, marks=pytest.mark.llvm),
+            pytest.param(pnlvm.ExecutionMode._LLVMPerNode, marks=pytest.mark.llvm),
+            pytest.param(pnlvm.ExecutionMode._LLVMExec, marks=pytest.mark.llvm),
             pytest.param(pnlvm.ExecutionMode.LLVMRun, marks=pytest.mark.llvm),
             pytest.param(pnlvm.ExecutionMode.PTXRun, marks=[pytest.mark.llvm,  pytest.mark.cuda])
            ]
@@ -208,29 +207,29 @@ def cuda_param(val):
     return pytest.param(val, marks=[pytest.mark.llvm, pytest.mark.cuda])
 
 @pytest.helpers.register
-def get_func_execution(func, func_mode):
+def get_func_execution(func, func_mode, *, tags:frozenset=frozenset(), member='function'):
     if func_mode == 'LLVM':
-        return pnlvm.execution.FuncExecution(func).execute
+        return pnlvm.execution.FuncExecution(func, tags=tags).execute
 
     elif func_mode == 'PTX':
-        return pnlvm.execution.FuncExecution(func).cuda_execute
+        return pnlvm.execution.FuncExecution(func, tags=tags).cuda_execute
 
     elif func_mode == 'Python':
-        return func.function
+        return getattr(func, member)
     else:
         assert False, "Unknown function mode: {}".format(func_mode)
 
 @pytest.helpers.register
-def get_mech_execution(mech, mech_mode):
+def get_mech_execution(mech, mech_mode, *, tags:frozenset=frozenset(), member='execute'):
     if mech_mode == 'LLVM':
-        return pnlvm.execution.MechExecution(mech).execute
+        return pnlvm.execution.MechExecution(mech, tags=tags).execute
 
     elif mech_mode == 'PTX':
-        return pnlvm.execution.MechExecution(mech).cuda_execute
+        return pnlvm.execution.MechExecution(mech, tags=tags).cuda_execute
 
     elif mech_mode == 'Python':
         def mech_wrapper(x):
-            mech.execute(x)
+            getattr(mech, member)(x)
             return mech.output_values
 
         return mech_wrapper

cuda_requirements.txt

@@ -1 +1 @@
-pycuda >2018, <2025
+pycuda >2018, <2026

docs/source/Compilation.rst

@@ -33,8 +33,8 @@ Use
 Compiled form of a model can be invoked by passing one of the following values to the `bin_execute` parameter of `Composition.run`, or `Composition.exec`:
 
   * `ExecutionMode.Python`: Normal python execution
-  * `ExecutionMode.LLVM`: Compile and execute individual nodes. The scheduling loop still runs in Python. If any of the nodes fails to compile, an error is raised. *NOTE:* Schedules that require access to node data will not work correctly.
-  * `ExecutionMode.LLVMExec`: Execution of `Composition.exec` is replaced by a compiled equivalent. If the `Composition` fails to compile, an error is raised.
+  * `ExecutionMode._LLVMPerNode`: Compile and execute individual nodes. The scheduling loop still runs in Python. If any of the nodes fails to compile, an error is raised. *NOTE:* Schedules that require access to node data will not work correctly.
+  * `ExecutionMode._LLVMExec`: Execution of `Composition.exec` is replaced by a compiled equivalent. If the `Composition` fails to compile, an error is raised.
   * `ExecutionMode.LLVMRun`: Execution of `Composition.run` is replaced by a compiled equivalent. If the `Composition` fails to compile, an error is raised.
   * `ExecutionMode.Auto`: This option attempts all three above mentioned granularities, and gracefully falls back to lower granularity. Warnings are raised in place of errors. This is the recommended way to invoke compiled execution as the final fallback is the Python baseline.
 

psyneulink/core/components/component.py

@@ -1484,7 +1484,7 @@ def _get_compilation_params(self):
                      "control_signal", "competition",
                      "has_recurrent_input_port", "enable_learning",
                      "enable_output_type_conversion", "changes_shape",
-                     "output_type", "bounds", "internal_only",
+                     "output_type", "range", "internal_only",
                      "require_projection_in_composition", "default_input",
                      "shadow_inputs", "compute_reconfiguration_cost",
                      "reconfiguration_cost", "net_outcome", "outcome",

psyneulink/core/components/functions/function.py

@@ -171,9 +171,22 @@
 from psyneulink.core.globals.preferences.preferenceset import PreferenceEntry, PreferenceLevel
 from psyneulink.core.globals.registry import register_category
 from psyneulink.core.globals.utilities import (
-    convert_all_elements_to_np_array, convert_to_np_array, get_global_seed, is_instance_or_subclass, object_has_single_value, parameter_spec, parse_valid_identifier, safe_len,
-    SeededRandomState, try_extract_0d_array_item, contains_type, is_numeric, NumericCollections,
-    random_matrix, array_from_matrix_string
+    NumericCollections,
+    SeededRandomState,
+    _get_global_seed,
+    array_from_matrix_string,
+    contains_type,
+    convert_all_elements_to_np_array,
+    convert_to_np_array,
+    is_instance_or_subclass,
+    is_numeric,
+    is_numeric_scalar,
+    object_has_single_value,
+    parameter_spec,
+    parse_valid_identifier,
+    random_matrix,
+    safe_len,
+    try_extract_0d_array_item,
 )
 
 __all__ = [
@@ -357,7 +370,7 @@ def _seed_setter(value, owning_component, context, *, compilation_sync):
 
     value = try_extract_0d_array_item(value)
     if value is None or value == DEFAULT_SEED():
-        value = get_global_seed()
+        value = _get_global_seed()
 
     # Remove any old PRNG state
     owning_component.parameters.random_state.set(None, context=context)
@@ -438,7 +451,7 @@ class Function_Base(Function):
          prefs=None          \
     )
 
-    Implement abstract class for Function category of Component class
+    Abstract base class for Function category of Component class
 
     COMMENT:
         Description:
@@ -1000,8 +1013,8 @@ def _get_pytorch_fct_param_value(self, param_name, device, context):
 
 
 # *****************************************   EXAMPLE FUNCTION   *******************************************************
-PROPENSITY = "PROPENSITY"
-PERTINACITY = "PERTINACITY"
+PROPENSITY = "propensity"
+PERTINACITY = "pertinacity"
 
 
 class ArgumentTherapy(Function_Base):
@@ -1083,6 +1096,10 @@ class ArgumentTherapy(Function_Base):
         REPORT_OUTPUT_PREF: PreferenceEntry(False, PreferenceLevel.INSTANCE),
     }
 
+    class Parameters(Function_Base.Parameters):
+        propensity = None
+        pertinacity = None
+
     # Mode indicators
     class Manner(Enum):
         OBSEQUIOUS = 0
@@ -1095,16 +1112,16 @@ class Manner(Enum):
     @check_user_specified
     def __init__(self,
                  default_variable=None,
-                 propensity=10.0,
-                 pertincacity=Manner.CONTRARIAN,
+                 propensity=Manner.CONTRARIAN,
+                 pertinacity=10.0,
                  params=None,
                  owner=None,
                  prefs:  Optional[ValidPrefSet] = None):
 
         super().__init__(
             default_variable=default_variable,
             propensity=propensity,
-            pertinacity=pertincacity,
+            pertinacity=pertinacity,
             params=params,
             owner=owner,
             prefs=prefs,
@@ -1155,7 +1172,7 @@ def _validate_params(self, request_set, target_set=None, context=None):
 
             # Validate param
             if param_name == PERTINACITY:
-                if isinstance(param_value, numbers.Number) and 0 <= param_value <= 10:
+                if is_numeric_scalar(param_value) and 0 <= param_value <= 10:
                     # target_set[PERTINACITY] = param_value
                     pass  # This leaves param in request_set, clear to be assigned to target_set in call to super below
                 else:

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

@@ -506,6 +506,15 @@ def func(entry_to_store,
                  decay_rate,
                  random_state)->torch.tensor:
             """Decay existing memories and replace weakest entry with entry_to_store (parallel EMStorage._function)"""
+
+            # If the batch_size is not equal to one then we need to raise an exception.
+            if len(entry_to_store.shape) > 2:
+                if entry_to_store.shape[0] != 1:
+                    raise NotImplementedError("EMSStorage has not been implemented for batch sizes greater than 1")
+                else:
+                    # Drop the singleton batch dimension
+                    entry_to_store = entry_to_store[0]
+
             if random_state.uniform(0, 1) < storage_prob:
                 if decay_rate:
                     memory_matrix *= torch.tensor(decay_rate)
@@ -515,9 +524,9 @@ def func(entry_to_store,
                     # Find weakest entry (i.e., with lowest norm) along specified axis of matrix
                     idx_of_min = torch.argmin(torch.linalg.norm(memory_matrix, axis=axis))
                 if axis == 0:
-                    memory_matrix[:,idx_of_min] = entry_to_store
+                    memory_matrix[:,idx_of_min] = entry_to_store[0]
                 elif axis == 1:
-                    memory_matrix[idx_of_min,:] = entry_to_store
+                    memory_matrix[idx_of_min,:] = entry_to_store[0]
             return memory_matrix
         return func
 

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

@@ -641,7 +641,7 @@ def _evaluate(self, variable=None, context=None, params=None, fit_evaluate=False
         # Run compiled mode if requested by parameter and everything is initialized
         if self.owner and self.owner.parameters.comp_execution_mode._get(context) != 'Python' and \
           ContextFlags.PROCESSING in context.flags:
-            all_samples = [s for s in itertools.product(*self.search_space)]
+            all_samples = list(itertools.product(*self.search_space))
             all_values, num_evals = self._grid_evaluate(self.owner, context, fit_evaluate)
             assert len(all_values) == num_evals
             assert len(all_samples) == num_evals
@@ -846,7 +846,7 @@ def reset_grid(self, context):
         """Reset iterators in `search_space <GridSearch.search_space>`"""
         for s in self.search_space:
             s.reset()
-        self.parameters.grid._set(itertools.product(*[s for s in self.search_space]), context)
+        self.parameters.grid._set((s for s in itertools.product(*[s for s in self.search_space])), context)
 
     def _traverse_grid(self, variable, sample_num, context=None):
         """Get next sample from grid.

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

@@ -218,8 +218,6 @@ class OneHot(SelectionFunction):
         function.  Values specified for parameters in the dictionary override any assigned to those parameters in
         arguments of the constructor.
 
-    bounds : None
-
     owner : Component
         `component <Component>` to which to assign the Function.