feat: Configurable default backend

docs/api.rst

@@ -10,8 +10,6 @@ Top-Level
    :toctree: _generated/
    :nosignatures:
 
-   default_backend
-   default_optimizer
    tensorlib
    optimizer
    get_backend

src/pyhf/__init__.py

@@ -1,155 +1,8 @@
 from pyhf.tensor import BackendRetriever as tensor
-from pyhf.optimize import OptimizerRetriever as optimize
+from pyhf.optimize import OptimizerRetriever as optimize  # noqa
+from pyhf.tensor.manager import get_backend
+from pyhf.tensor.manager import set_backend
 from pyhf._version import version as __version__
-from pyhf.exceptions import InvalidBackend, InvalidOptimizer, Unsupported
-from pyhf import events
-
-tensorlib = None
-optimizer = None
-
-
-def get_backend():
-    """
-    Get the current backend and the associated optimizer
-
-    Example:
-        >>> import pyhf
-        >>> backend, optimizer = pyhf.get_backend()
-        >>> backend
-        <pyhf.tensor.numpy_backend.numpy_backend object at 0x...>
-        >>> optimizer
-        <pyhf.optimize.scipy_optimizer object at 0x...>
-
-    Returns:
-        backend, optimizer
-    """
-    global tensorlib
-    global optimizer
-    return tensorlib, optimizer
-
-
-tensorlib = tensor.numpy_backend()
-default_backend = tensorlib
-optimizer = optimize.scipy_optimizer()
-default_optimizer = optimizer
-
-
-@events.register('change_backend')
-def set_backend(backend, custom_optimizer=None, precision=None):
-    """
-    Set the backend and the associated optimizer
-
-    Example:
-        >>> import pyhf
-        >>> pyhf.set_backend("tensorflow")
-        >>> pyhf.tensorlib.name
-        'tensorflow'
-        >>> pyhf.tensorlib.precision
-        '64b'
-        >>> pyhf.set_backend(b"pytorch", precision="32b")
-        >>> pyhf.tensorlib.name
-        'pytorch'
-        >>> pyhf.tensorlib.precision
-        '32b'
-        >>> pyhf.set_backend(pyhf.tensor.numpy_backend())
-        >>> pyhf.tensorlib.name
-        'numpy'
-        >>> pyhf.tensorlib.precision
-        '64b'
-
-    Args:
-        backend (:obj:`str` or `pyhf.tensor` backend): One of the supported pyhf backends: NumPy, TensorFlow, PyTorch, and JAX
-        custom_optimizer (`pyhf.optimize` optimizer): Optional custom optimizer defined by the user
-        precision (:obj:`str`): Floating point precision to use in the backend: ``64b`` or ``32b``. Default is backend dependent.
-
-    Returns:
-        None
-    """
-    global tensorlib
-    global optimizer
-
-    _supported_precisions = ["32b", "64b"]
-    backend_kwargs = {}
-
-    if isinstance(precision, (str, bytes)):
-        if isinstance(precision, bytes):
-            precision = precision.decode("utf-8")
-        precision = precision.lower()
-
-    if isinstance(backend, (str, bytes)):
-        if isinstance(backend, bytes):
-            backend = backend.decode("utf-8")
-        backend = backend.lower()
-
-        if precision is not None:
-            backend_kwargs["precision"] = precision
-
-        try:
-            backend = getattr(tensor, f"{backend:s}_backend")(**backend_kwargs)
-        except TypeError:
-            raise InvalidBackend(
-                f"The backend provided is not supported: {backend:s}. Select from one of the supported backends: numpy, tensorflow, pytorch"
-            )
-
-    _name_supported = getattr(tensor, f"{backend.name:s}_backend")
-    if _name_supported:
-        if not isinstance(backend, _name_supported):
-            raise AttributeError(
-                f"'{backend.name:s}' is not a valid name attribute for backend type {type(backend)}\n                 Custom backends must have names unique from supported backends"
-            )
-        if backend.precision not in _supported_precisions:
-            raise Unsupported(
-                f"The backend precision provided is not supported: {backend.precision:s}. Select from one of the supported precisions: {', '.join([str(v) for v in _supported_precisions])}"
-            )
-    # If "precision" arg passed, it should always win
-    # If no "precision" arg, defer to tensor backend object API if set there
-    if precision is not None:
-        if backend.precision != precision:
-            backend_kwargs["precision"] = precision
-            backend = getattr(tensor, f"{backend.name:s}_backend")(**backend_kwargs)
-
-    # need to determine if the tensorlib changed or the optimizer changed for events
-    tensorlib_changed = bool(
-        (backend.name != tensorlib.name) | (backend.precision != tensorlib.precision)
-    )
-    optimizer_changed = False
-
-    if custom_optimizer:
-        if isinstance(custom_optimizer, (str, bytes)):
-            if isinstance(custom_optimizer, bytes):
-                custom_optimizer = custom_optimizer.decode("utf-8")
-            try:
-                new_optimizer = getattr(
-                    optimize, f"{custom_optimizer.lower()}_optimizer"
-                )()
-            except TypeError:
-                raise InvalidOptimizer(
-                    f"The optimizer provided is not supported: {custom_optimizer}. Select from one of the supported optimizers: scipy, minuit"
-                )
-        else:
-            _name_supported = getattr(optimize, f"{custom_optimizer.name:s}_optimizer")
-            if _name_supported:
-                if not isinstance(custom_optimizer, _name_supported):
-                    raise AttributeError(
-                        f"'{custom_optimizer.name}' is not a valid name attribute for optimizer type {type(custom_optimizer)}\n                 Custom optimizers must have names unique from supported optimizers"
-                    )
-            new_optimizer = custom_optimizer
-
-    else:
-        new_optimizer = optimize.scipy_optimizer()
-
-    optimizer_changed = bool(optimizer != new_optimizer)
-    # set new backend
-    tensorlib = backend
-    optimizer = new_optimizer
-    # trigger events
-    if tensorlib_changed:
-        events.trigger("tensorlib_changed")()
-    if optimizer_changed:
-        events.trigger("optimizer_changed")()
-    # set up any other globals for backend
-    tensorlib._setup()
-
 
 from pyhf.pdf import Model
 from pyhf.workspace import Workspace
@@ -164,6 +17,7 @@ def set_backend(backend, custom_optimizer=None, precision=None):
     "Workspace",
     "__version__",
     "compat",
+    "default_backend",
     "exceptions",
     "get_backend",
     "infer",
@@ -185,3 +39,13 @@ def set_backend(backend, custom_optimizer=None, precision=None):
 
 def __dir__():
     return __all__
+
+
+def __getattr__(name):
+    if name == 'tensorlib':
+        return get_backend(default=False)[0]
+    if name == 'optimizer':
+        return get_backend(default=False)[1]
+    if name == 'default_backend':
+        return get_backend(default=True)[0]
+    raise AttributeError

src/pyhf/constraints.py

@@ -1,4 +1,5 @@
-from pyhf import get_backend, default_backend
+import pyhf
+from pyhf.tensor.manager import get_backend
 from pyhf import events
 from pyhf import probability as prob
 from pyhf.parameters import ParamViewer
@@ -12,6 +13,8 @@ def __dir__():
 
 class gaussian_constraint_combined:
     def __init__(self, pdfconfig, batch_size=None):
+        default_backend = pyhf.default_backend
+
         self.batch_size = batch_size
         # iterate over all constraints order doesn't matter....
 
@@ -144,6 +147,8 @@ def logpdf(self, auxdata, pars):
 
 class poisson_constraint_combined:
     def __init__(self, pdfconfig, batch_size=None):
+        default_backend = pyhf.default_backend
+
         self.batch_size = batch_size
         # iterate over all constraints order doesn't matter....
 

src/pyhf/interpolators/code0.py

@@ -1,6 +1,7 @@
 """Piecewise-linear Interpolation. (Code 0)."""
 import logging
-from pyhf import get_backend, default_backend
+import pyhf
+from pyhf.tensor.manager import get_backend
 from pyhf import events
 from pyhf.interpolators import _slow_interpolator_looper
 
@@ -25,7 +26,8 @@ class code0:
 
     def __init__(self, histogramssets, subscribe=True):
         """Piecewise-linear Interpolation."""
-        # nb: this should never be a tensor, store in default backend (e.g. numpy)
+        default_backend = pyhf.default_backend
+
         self._histogramssets = default_backend.astensor(histogramssets)
         # initial shape will be (nsysts, 1)
         self.alphasets_shape = (self._histogramssets.shape[0], 1)

src/pyhf/interpolators/code1.py

@@ -1,7 +1,8 @@
 """Piecewise-Exponential Interpolation (Code 1)."""
 import logging
 import math
-from pyhf import get_backend, default_backend
+import pyhf
+from pyhf.tensor.manager import get_backend
 from pyhf import events
 from pyhf.interpolators import _slow_interpolator_looper
 
@@ -26,7 +27,8 @@ class code1:
 
     def __init__(self, histogramssets, subscribe=True):
         """Piecewise-Exponential Interpolation."""
-        # nb: this should never be a tensor, store in default backend (e.g. numpy)
+        default_backend = pyhf.default_backend
+
         self._histogramssets = default_backend.astensor(histogramssets)
         # initial shape will be (nsysts, 1)
         self.alphasets_shape = (self._histogramssets.shape[0], 1)

src/pyhf/interpolators/code2.py

@@ -1,6 +1,7 @@
 """Quadratic Interpolation (Code 2)."""
 import logging
-from pyhf import get_backend, default_backend
+import pyhf
+from pyhf.tensor.manager import get_backend
 from pyhf import events
 from pyhf.interpolators import _slow_interpolator_looper
 
@@ -29,7 +30,8 @@ class code2:
 
     def __init__(self, histogramssets, subscribe=True):
         """Quadratic Interpolation."""
-        # nb: this should never be a tensor, store in default backend (e.g. numpy)
+        default_backend = pyhf.default_backend
+
         self._histogramssets = default_backend.astensor(histogramssets)
         # initial shape will be (nsysts, 1)
         self.alphasets_shape = (self._histogramssets.shape[0], 1)

src/pyhf/interpolators/code4.py

@@ -1,7 +1,8 @@
 """Polynomial Interpolation (Code 4)."""
 import logging
 import math
-from pyhf import get_backend, default_backend
+import pyhf
+from pyhf.tensor.manager import get_backend
 from pyhf import events
 from pyhf.interpolators import _slow_interpolator_looper
 
@@ -32,11 +33,13 @@ class code4:
 
     def __init__(self, histogramssets, subscribe=True, alpha0=1):
         """Polynomial Interpolation."""
+        default_backend = pyhf.default_backend
+
         # alpha0 is assumed to be positive and non-zero. If alpha0 == 0, then
         # we cannot calculate the coefficients (e.g. determinant == 0)
         assert alpha0 > 0
         self.__alpha0 = alpha0
-        # nb: this should never be a tensor, store in default backend (e.g. numpy)
+
         self._histogramssets = default_backend.astensor(histogramssets)
         # initial shape will be (nsysts, 1)
         self.alphasets_shape = (self._histogramssets.shape[0], 1)

src/pyhf/interpolators/code4p.py

@@ -1,6 +1,7 @@
 """Piecewise-Linear + Polynomial Interpolation (Code 4p)."""
 import logging
-from pyhf import get_backend, default_backend
+import pyhf
+from pyhf.tensor.manager import get_backend
 from pyhf import events
 from pyhf.interpolators import _slow_interpolator_looper
 
@@ -18,7 +19,8 @@ class code4p:
 
     def __init__(self, histogramssets, subscribe=True):
         """Piecewise-Linear  + Polynomial Interpolation."""
-        # nb: this should never be a tensor, store in default backend (e.g. numpy)
+        default_backend = pyhf.default_backend
+
         self._histogramssets = default_backend.astensor(histogramssets)
         # initial shape will be (nsysts, 1)
         self.alphasets_shape = (self._histogramssets.shape[0], 1)

src/pyhf/modifiers/histosys.py

@@ -1,6 +1,8 @@
 import logging
 
-from pyhf import get_backend, default_backend, events
+import pyhf
+from pyhf import events
+from pyhf.tensor.manager import get_backend
 from pyhf import interpolators
 from pyhf.parameters import ParamViewer
 
@@ -57,6 +59,8 @@ def append(self, key, channel, sample, thismod, defined_samp):
             )
 
     def finalize(self):
+        default_backend = pyhf.default_backend
+
         for modifier in self.builder_data.values():
             for sample in modifier.values():
                 sample["data"]["mask"] = default_backend.concatenate(

src/pyhf/modifiers/shapefactor.py

@@ -1,6 +1,8 @@
 import logging
 
-from pyhf import get_backend, default_backend, events
+import pyhf
+from pyhf import events
+from pyhf.tensor.manager import get_backend
 from pyhf.parameters import ParamViewer
 
 log = logging.getLogger(__name__)
@@ -124,6 +126,7 @@ def __init__(self, modifiers, pdfconfig, builder_data, batch_size=None):
         and at that point can be used to compute the effect of
         :class:`~pyhf.modifiers.shapefactor`.
         """
+        default_backend = pyhf.default_backend
 
         self.batch_size = batch_size
         keys = [f'{mtype}/{m}' for m, mtype in modifiers]