pyactup 2.2.1__tar.gz → 2.2.3__tar.gz

{pyactup-2.2.1 → pyactup-2.2.3}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: pyactup
-Version: 2.2.1
+Version: 2.2.3
 Summary: A lightweight Python implementation of a subset of the ACT-R cognitive architecture’s Declarative Memory
-Home-page: https://bitbucket.org/dfmorrison/pyactup/
+Home-page: https://dfmorrison.github.io/pyactup-documentation/
 Author: Don Morrison
 Author-email: dfm2@cmu.edu
 Platform: any

{pyactup-2.2.1 → pyactup-2.2.3}/pyactup.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: pyactup
-Version: 2.2.1
+Version: 2.2.3
 Summary: A lightweight Python implementation of a subset of the ACT-R cognitive architecture’s Declarative Memory
-Home-page: https://bitbucket.org/dfmorrison/pyactup/
+Home-page: https://dfmorrison.github.io/pyactup-documentation/
 Author: Don Morrison
 Author-email: dfm2@cmu.edu
 Platform: any

{pyactup-2.2.1 → pyactup-2.2.3}/pyactup.egg-info/requires.txt

@@ -1,3 +1,4 @@
 numpy
 pylru
 prettytable
+packaging

{pyactup-2.2.1 → pyactup-2.2.3}/pyactup.py

@@ -37,7 +37,7 @@ may be strictly algorithmic, may interact with human subjects, or may be embedde
 sites.
 """
 
-__version__ = "2.2.1"
+__version__ = "2.2.3"
 
 if "dev" in __version__:
     print("PyACTUp version", __version__)
@@ -135,6 +135,7 @@ class Memory(dict):
         self._fixed_noise_time = None
         self._temperature_param = 1 # will be reset below, but is needed for noise assignment
         self._noise = None
+        self._noise_distribution = None
         self._decay = None
         self._optimized_learning = None
         self._use_actr_similarity = False
@@ -295,18 +296,33 @@ class Memory(dict):
         assert not self._index and not self._slot_name_index
         self._indexed_attributes = indexed_attributes
 
+    @staticmethod
+    def is_real(x, name, non_negative=True, positive=False, none_allowed=True):
+        if none_allowed and x is None:
+            return
+        if (x is True or x is False
+            or (positive and x <= 0)
+            or (non_negative and x < 0)):
+            if positive:
+                mod = " positive"
+            elif non_negative:
+                mod = " non-negative"
+            else:
+                mod = ""
+            raise ValueError(f"The {name}, {x}, must be{' None or' if none_allowed else ''} a{mod} real number")
+
     @property
     def time(self):
         """This ``Memory``'s current time.
         Time in PyACTUp is a dimensionless quantity, the interpretation of which is at the
-        discretion of the modeler.
+        discretion of the modeler. Attempting to set the ``time`` to anything but a real
+        number raises a :exc:`ValueError`.
         """
         return self._time
 
     @time.setter
     def time(self, value):
-        if not isinstance(value, Real):
-            raise ValueError(f"Time {value} is not a real number")
+        Memory.is_real(value, "time", False, False, False)
         self._time = value
         if value != self._time:
             self._clear_fixed_noise()
@@ -322,6 +338,7 @@ class Memory(dict):
             chunks were created or reinforced will result in infinite or complex valued
             base-level activations and raise an :exc:`Exception`.
         """
+        Memory.is_real(amount, "time increment", False)
         if amount is not None:
             self.time += amount
         return self._time
@@ -381,8 +398,9 @@ class Memory(dict):
 
     @noise.setter
     def noise(self, value):
-        if value < 0:
-            raise ValueError(f"The noise, {value}, must not be negative")
+        Memory.is_real(value, "noise")
+        if value is None:
+            value = 0
         if self._temperature_param is None:
             t = Memory._validate_temperature(None, value)
             if not t:
@@ -391,9 +409,34 @@ class Memory(dict):
             else:
                 self._temperature = t
         if value != self._noise:
-            self._noise = value
+            self._noise = float(value)
             self._clear_fixed_noise()
 
+    @property
+    def noise_distribution(self):
+        """ Provide an alternative distribution from which noise is sampled.
+        If ``None`` the default logistic distribution is used. Otherwise the value of this
+        attribute should be a callable that takes no arguments and returns a real number.
+        It will be called once each time activation noise is required and the value,
+        scaled as usual by the :attr:`noise` parameter, will be used as the activation
+        noise. A :exc:`ValueError` is raised if an attempt is made to set this attribute
+        to anything other than a callable or ``None``.
+
+        .. warning::
+            It is rarely appropriate to use ``noise_distribution``. The default logistic
+            distribution is almost always a more appropriate choice. The ability to change
+            the distribution is provided only for esoteric purposes, and care should be
+            exercised lest biologically implausible models result.
+        """
+        return self._noise_distribution
+
+    @noise_distribution.setter
+    def noise_distribution(self, value):
+        if value is None or callable(value):
+            self._noise_distribution = value
+        else:
+            raise ValueError(f"The provided noise_distribution, {value}, is neither Callable nor None")
+
     @property
     def decay(self):
         """Controls the rate at which activation for chunks in memory decay with the passage of time.
@@ -411,12 +454,13 @@ class Memory(dict):
 
     @decay.setter
     def decay(self, value):
+        Memory.is_real(value, "decay")
         if value is not None:
-            if value < 0:
-                raise ValueError(f"The decay, {value}, must not be negative")
             if value >= 1 and self._optimized_learning is not None:
                 raise ValueError(f"The decay, {value}, must be less than one if optimized_learning is used")
-        self._decay = value
+            self._decay = float(value)
+        else:
+            self._decay = None
 
     @property
     def temperature(self):
@@ -435,6 +479,7 @@ class Memory(dict):
         if value is None or value is False:
             value = None
         else:
+            Memory.is_real(value, "temperature", True, True)
             value = float(value)
         t = Memory._validate_temperature(value, self._noise)
         if not t:
@@ -474,7 +519,8 @@ class Memory(dict):
 
     @threshold.setter
     def threshold(self, value):
-        if value is None or value is False:
+        Memory.is_real(value, "threshold", False)
+        if value is None:
             self._threshold = None
         else:
             self._threshold = float(value)
@@ -497,17 +543,18 @@ class Memory(dict):
         ratios of various times, the :attr:`mismatch` is sensitive to the actual
         magnitude. Suitable care should be exercised when adjusting it.
 
-        Attempting to set this parameter to a value other than ``None`` or a real number
-        raises a :exc:`ValueError`.
+        Attempting to set this parameter to a value other than ``None`` or a non-negative
+        real number raises a :exc:`ValueError`.
         """
         return self._mismatch
 
     @mismatch.setter
     def mismatch(self, value):
-        if value is None or value is False:
+        if value is False:
+            value = None
+        Memory.is_real(value, "mismatch")
+        if value is None:
             self._mismatch = None
-        elif value < 0:
-            raise ValueError(f"The mismatch penalty, {value}, must not be negative")
         else:
             self._mismatch = float(value)
 
@@ -989,7 +1036,12 @@ class Memory(dict):
                                                          "references": c.references,
                                                          "base_level_activation": r})
                 if self._noise:
-                    noise = self._rng.logistic(scale=self._noise, size=nchunks)
+                    if self._noise_distribution is not None:
+                        noise = self._noise * np.array([self._noise_distribution()
+                                                        for i in range(nchunks)],
+                                                       dtype=np.float64)
+                    else:
+                        noise = self._rng.logistic(scale=self._noise, size=nchunks)
                     if self._fixed_noise is not None:
                         if self._fixed_noise_time != self._time:
                             self._clear_fixed_noise()

{pyactup-2.2.1 → pyactup-2.2.3}/setup.py

@@ -10,7 +10,7 @@ setup(name="pyactup",
       description="A lightweight Python implementation of a subset of the ACT-R cognitive architecture’s Declarative Memory",
       author="Don Morrison",
       author_email="dfm2@cmu.edu",
-      url="https://bitbucket.org/dfmorrison/pyactup/",
+      url="https://dfmorrison.github.io/pyactup-documentation/",
       platforms=["any"],
       long_description=DESCRIPTION,
       long_description_content_type="text/markdown",
@@ -18,7 +18,8 @@ setup(name="pyactup",
       install_requires=[
           "numpy",
           "pylru",
-          "prettytable"],
+          "prettytable",
+          "packaging"],
       tests_require=["pytest"],
       python_requires=">=3.8",
       classifiers=["Intended Audience :: Science/Research",