feat: Migrate to TensorFlow v2.0 (#541)

* Migrate the TensorFlow backend and optimizer to TensorFlow v2.0 / deprecate TensorFlow v1.0 behavior
   - Changes evaluation from lazy (v1.0) to eager (v2.0 default)
* Require TensorFlow and TensorFlow Probability releases compatible with TensorFlow v2.0
* Simplify test configuration with deprecation of TensorFlow v1.0 Sessions

Author: matthewfeickert

docs/governance/ROADMAP.md

@@ -65,7 +65,7 @@ The roadmap will be executed over mostly Quarter 3 of 2019 through Quarter 1 of
    - [ ] Add better Model creation [2019-Q4 → 2020-Q1]
    - [ ] Add background model support (Issue #514) [2019-Q4 → 2020-Q1]
    - [ ] Develop interface for the optimizers similar to tensor/backend [2019-Q4 → 2020-Q1]
-   - [ ] Migrate to TensorFlow v2.0 (PR #541) [2019-Q4]
+   - [x] Migrate to TensorFlow v2.0 (PR #541) [2019-Q4]
    - [ ] Drop Python 2.7 support at end of 2019 (Issue #469) [2019-Q4 (last week of December 2019)]
    - [ ] Finalize public API [2020-Q1]
    - [ ] Integrate pyfitcore/Statisfactory API [2020-Q1]

setup.py

@@ -9,7 +9,7 @@
     long_description = readme_md.read()
 
 extras_require = {
-    'tensorflow': ['tensorflow~=1.15', 'tensorflow-probability~=0.8', 'numpy~=1.16'],
+    'tensorflow': ['tensorflow~=2.0', 'tensorflow-probability~=0.8'],
     'torch': ['torch~=1.2'],
     'xmlio': ['uproot'],
     'minuit': ['iminuit'],

src/pyhf/__init__.py

@@ -28,15 +28,13 @@ def get_backend():
 
 
 @events.register('change_backend')
-def set_backend(backend, custom_optimizer=None, _session=None):
+def set_backend(backend, custom_optimizer=None):
     """
     Set the backend and the associated optimizer
 
     Example:
         >>> import pyhf
-        >>> import tensorflow as tf
-        >>> sess = tf.compat.v1.Session()
-        >>> pyhf.set_backend("tensorflow", _session=sess)
+        >>> pyhf.set_backend("tensorflow")
         >>> pyhf.tensorlib.name
         'tensorflow'
         >>> pyhf.set_backend(b"pytorch")
@@ -49,10 +47,6 @@ def set_backend(backend, custom_optimizer=None, _session=None):
     Args:
         backend (`str` or `pyhf.tensor` backend): One of the supported pyhf backends: NumPy, TensorFlow, and PyTorch
         custom_optimizer (`pyhf.optimize` optimizer): Optional custom optimizer defined by the user
-        _session (|tf.compat.v1.Session|_): TensorFlow v1 compatible Session to use when the :code:`"tensorflow"` backend API is used
-
-    .. |tf.compat.v1.Session| replace:: ``tf.compat.v1.Session``
-    .. _tf.compat.v1.Session: https://www.tensorflow.org/api_docs/python/tf/compat/v1/Session
 
     Returns:
         None
@@ -64,18 +58,14 @@ def set_backend(backend, custom_optimizer=None, _session=None):
         if isinstance(backend, bytes):
             backend = backend.decode("utf-8")
         backend = backend.lower()
-        # Needed while still using TF v1.0 API
-        if backend == "tensorflow":
-            backend = tensor.tensorflow_backend(session=_session)
-        else:
-            try:
-                backend = getattr(tensor, "{0:s}_backend".format(backend))()
-            except TypeError:
-                raise InvalidBackend(
-                    "The backend provided is not supported: {0:s}. Select from one of the supported backends: numpy, tensorflow, pytorch".format(
-                        backend
-                    )
+        try:
+            backend = getattr(tensor, "{0:s}_backend".format(backend))()
+        except TypeError:
+            raise InvalidBackend(
+                "The backend provided is not supported: {0:s}. Select from one of the supported backends: numpy, tensorflow, pytorch".format(
+                    backend
                 )
+            )
 
     _name_supported = getattr(tensor, "{0:s}_backend".format(backend.name))
     if _name_supported:
@@ -94,8 +84,6 @@ def set_backend(backend, custom_optimizer=None, _session=None):
         new_optimizer = (
             custom_optimizer if custom_optimizer else optimize.tflow_optimizer(backend)
         )
-        if tensorlib.name == 'tensorflow':
-            tensorlib_changed |= bool(backend.session != tensorlib.session)
     elif backend.name == 'pytorch':
         new_optimizer = (
             custom_optimizer

src/pyhf/cli/infer.py

@@ -68,9 +68,7 @@ def cls(
     if backend in ['pytorch', 'torch']:
         set_backend(tensor.pytorch_backend(float='float64'))
     elif backend in ['tensorflow', 'tf']:
-        from tensorflow.compat.v1 import Session
-
-        set_backend(tensor.tensorflow_backend(session=Session(), float='float64'))
+        set_backend(tensor.tensorflow_backend(float='float64'))
     tensorlib, _ = get_backend()
 
     optconf = {k: v for item in optconf for k, v in item.items()}

src/pyhf/optimize/opt_tflow.py

@@ -5,19 +5,6 @@
 import tensorflow as tf
 
 
-def _eval_func(op, argop, dataop, data):
-    def func(pars):
-        tensorlib, _ = get_backend()
-        pars_as_list = tensorlib.tolist(pars) if isinstance(pars, tf.Tensor) else pars
-        data_as_list = tensorlib.tolist(data) if isinstance(data, tf.Tensor) else data
-        value = tensorlib.session.run(
-            op, feed_dict={argop: pars_as_list, dataop: data_as_list}
-        )
-        return value
-
-    return func
-
-
 class tflow_optimizer(AutoDiffOptimizerMixin):
     """Tensorflow Optimizer Backend."""
 
@@ -49,24 +36,18 @@ def setup_minimize(
         variable_init = all_init[variable_idx]
         variable_bounds = [par_bounds[i] for i in variable_idx]
 
-        data_placeholder = tf.placeholder(
-            tensorlib.dtypemap['float'], (pdf.config.nmaindata + pdf.config.nauxdata,)
-        )
-        variable_pars_placeholder = tf.placeholder(
-            tensorlib.dtypemap['float'], (pdf.config.npars - len(fixed_vals),)
-        )
-
         tv = _TensorViewer([fixed_idx, variable_idx])
 
+        data = tensorlib.astensor(data)
         fixed_values_tensor = tensorlib.astensor(fixed_values, dtype='float')
 
-        full_pars = tv.stitch([fixed_values_tensor, variable_pars_placeholder])
-
-        nll = objective(full_pars, data_placeholder, pdf)
-        nllgrad = tf.identity(tf.gradients(nll, variable_pars_placeholder)[0])
-
-        func = _eval_func(
-            [nll, nllgrad], variable_pars_placeholder, data_placeholder, data,
-        )
+        def func(pars):
+            pars = tensorlib.astensor(pars)
+            with tf.GradientTape() as tape:
+                tape.watch(pars)
+                constrained_pars = tv.stitch([fixed_values_tensor, pars])
+                constr_nll = objective(constrained_pars, data, pdf)
+            grad = tape.gradient(constr_nll, pars).values
+            return constr_nll.numpy(), grad
 
         return tv, fixed_values_tensor, func, variable_init, variable_bounds