Bring back tf.constant close #38

custom log path
fix quantity shape

Author: GlaserN

c3/c3objs.py

@@ -4,6 +4,7 @@
 import numpy as np
 import tensorflow as tf
 from c3.utils.utils import num3str
+from tensorflow.python.framework import ops
 
 
 class C3obj:
@@ -71,6 +72,7 @@ class Quantity:
     def __init__(
         self, value, min_val=None, max_val=None, unit="undefined", symbol=r"\alpha"
     ):
+        value = np.array(value)
         if "pi" in unit:
             pref = np.pi
         if "2pi" in unit:
@@ -89,7 +91,6 @@ def __init__(
         if hasattr(value, "shape"):
             self.shape = value.shape
             self.length = int(np.prod(value.shape))
-            self.__float__ = None
         else:
             self.shape = (1,)
             self.length = 1
@@ -102,9 +103,9 @@ def asdict(self) -> dict:
         """
         pref = self.pref
         return {
-            "value": self.numpy(),
-            "min_val": self.offset / pref,
-            "max_val": (self.scale / pref + self.offset / pref),
+            "value": self.numpy().tolist(),
+            "min_val": (self.offset / pref).tolist(),
+            "max_val": (self.scale / pref + self.offset / pref).tolist(),
             "unit": self.unit,
             "symbol": self.symbol,
         }
@@ -202,7 +203,10 @@ def set_value(self, val) -> None:
             )
             # TODO if we want we can extend bounds when force flag is given
         else:
-            self.value = tf.Variable(tmp, dtype=tf.float64)
+            if isinstance(val, ops.EagerTensor):
+                self.value = tf.cast(2 * (val * self.pref - self.offset) / self.scale - 1, tf.float64)
+            else:
+                self.value = tf.constant(tmp, dtype=tf.float64)
 
     def get_opt_value(self) -> np.ndarray:
         """ Get an optimizer friendly representation of the value."""

c3/experiment.py

@@ -48,6 +48,7 @@ def __init__(self, pmap: ParameterMap = None):
         self.unitaries: dict = {}
         self.dUs: dict = {}
         self.created_by = None
+        self.logdir: str = None
 
     def set_created_by(self, config):
         """
@@ -278,7 +279,7 @@ def get_gates(self):
                         ctrls["carrier"].params["framechange"].get_value(),
                         tf.complex128,
                     )
-                t_final = tf.Variable(instr.t_end - instr.t_start, dtype=tf.complex128)
+                t_final = tf.constant(instr.t_end - instr.t_start, dtype=tf.complex128)
                 FR = model.get_Frame_Rotation(t_final, freqs, framechanges)
                 if model.lindbladian:
                     SFR = tf_utils.tf_super(FR)
@@ -295,7 +296,7 @@ def get_gates(self):
                     for line, ctrls in instr.comps.items():
                         amp, sum = generator.devices["awg"].get_average_amp()
                         amps[line] = tf.cast(amp, tf.complex128)
-                    t_final = tf.Variable(
+                    t_final = tf.constant(
                         instr.t_end - instr.t_start, dtype=tf.complex128
                     )
                     dephasing_channel = model.get_dephasing_channel(t_final, amps)
@@ -331,7 +332,7 @@ def propagation(self, signal: dict, gate):
             signals.append(signal[key]["values"])
             ts = signal[key]["ts"]
             hks.append(hctrls[key])
-        dt = tf.Variable(ts[1].numpy() - ts[0].numpy(), dtype=tf.complex128)
+        dt = tf.constant(ts[1].numpy() - ts[0].numpy(), dtype=tf.complex128)
 
         if model.lindbladian:
             col_ops = model.get_Lindbladians()

c3/generator/devices.py

@@ -100,8 +100,8 @@ def create_ts(self, t_start: np.float64, t_end: np.float64, centered: bool = Tru
         else:
             offset = 0
             num = self.slice_num + 1
-        t_start = tf.Variable(t_start + offset, dtype=tf.float64)
-        t_end = tf.Variable(t_end - offset, dtype=tf.float64)
+        t_start = tf.constant(t_start + offset, dtype=tf.float64)
+        t_end = tf.constant(t_end - offset, dtype=tf.float64)
         ts = tf.linspace(t_start, t_end, num)
         return ts
 
@@ -451,7 +451,7 @@ def process(self, instr, chan, iq_signal):
         """
         n_ts = tf.floor(self.params["rise_time"].get_value() * self.resolution)
         ts = tf.linspace(
-            tf.Variable(0.0, dtype=tf.float64),
+            tf.constant(0.0, dtype=tf.float64),
             self.params["rise_time"].get_value(),
             tf.cast(n_ts, tf.int32),
         )

c3/generator/generator.py

@@ -42,6 +42,7 @@ def __init__(
             self.chains = chains
             self.__check_signal_chains()
         self.resolution = resolution
+        self.gen_stacked_signals = None
 
     def __check_signal_chains(self) -> None:
         for channel, chain in self.chains.items():
@@ -111,9 +112,11 @@ def generate_signals(self, instr: Instruction) -> dict:
 
         """
         gen_signal = {}
+        if self.gen_stacked_signals:
+            del self.gen_stacked_signals
         gen_stacked_signals: dict = dict()
         for chan in instr.comps:
-            signal_stack: List[tf.Variable] = []
+            signal_stack: List[tf.constant] = []
             gen_stacked_signals[chan] = []
             for dev_id in self.chains[chan]:
                 dev = self.devices[dev_id]

c3/libraries/fidelities.py

@@ -99,7 +99,7 @@ def state_transfer_infid(U_dict: dict, gate: str, index, dims, psi_0, proj: bool
     projection = "fulluni"
     if proj:
         projection = "wzeros"
-    U_ideal = tf.Variable(
+    U_ideal = tf.constant(
         perfect_gate(gate, index, dims, projection), dtype=tf.complex128
     )
     psi_ideal = tf.matmul(U_ideal, psi_0)
@@ -138,7 +138,7 @@ def unitary_infid(U_dict: dict, gate: str, index, dims, proj: bool):
     if proj:
         projection = "wzeros"
         fid_lvls = 2 ** len(index)
-    U_ideal = tf.Variable(
+    U_ideal = tf.constant(
         perfect_gate(gate, index, dims, projection), dtype=tf.complex128
     )
     infid = 1 - tf_unitary_overlap(U, U_ideal, lvls=fid_lvls)
@@ -206,7 +206,7 @@ def lindbladian_unitary_infid(U_dict: dict, gate: str, index, dims, proj: bool):
         projection = "wzeros"
         fid_lvls = 2 ** len(index)
     U_ideal = tf_super(
-        tf.Variable(perfect_gate(gate, index, dims, projection), dtype=tf.complex128)
+        tf.constant(perfect_gate(gate, index, dims, projection), dtype=tf.complex128)
     )
     infid = 1 - tf_superoper_unitary_overlap(U, U_ideal, lvls=fid_lvls)
     return infid
@@ -258,7 +258,7 @@ def average_infid(U_dict: dict, gate: str, index, dims, proj=True):
         Project to computational subspace
     """
     U = U_dict[gate]
-    U_ideal = tf.Variable(
+    U_ideal = tf.constant(
         perfect_gate(gate, index, dims=[2] * len(dims)), dtype=tf.complex128
     )
     infid = 1 - tf_average_fidelity(U, U_ideal, lvls=dims)
@@ -338,7 +338,7 @@ def lindbladian_average_infid(U_dict: dict, gate: str, index, dims, proj=True):
         Project to computational subspace
     """
     U = U_dict[gate]
-    ideal = tf.Variable(
+    ideal = tf.constant(
         perfect_gate(gate, index, dims=[2] * len(dims)), dtype=tf.complex128
     )
     U_ideal = tf_super(ideal)
@@ -432,15 +432,15 @@ def populations(state, lindbladian):
 def population(U_dict: dict, lvl: int, gate: str):
     U = U_dict[gate]
     lvls = U.shape[0]
-    psi_0 = tf.Variable(basis(lvls, 0), dtype=tf.complex128)
+    psi_0 = tf.constant(basis(lvls, 0), dtype=tf.complex128)
     psi_actual = tf.matmul(U, psi_0)
     return populations(psi_actual, lindbladian=False)[lvl]
 
 
 def lindbladian_population(U_dict: dict, lvl: int, gate: str):
     U = U_dict[gate]
     lvls = int(np.sqrt(U.shape[0]))
-    psi_0 = tf.Variable(basis(lvls, 0), dtype=tf.complex128)
+    psi_0 = tf.constant(basis(lvls, 0), dtype=tf.complex128)
     dv_0 = tf_dm_to_vec(tf_state_to_dm(psi_0))
     dv_actual = tf.matmul(U, dv_0)
     return populations(dv_actual, lindbladian=True)[lvl]
@@ -460,7 +460,7 @@ def RB(
     gate = list(U_dict.keys())[0]
     U = U_dict[gate]
     dim = int(U.shape[0])
-    psi_init = tf.Variable(basis(dim, 0), dtype=tf.complex128)
+    psi_init = tf.constant(basis(dim, 0), dtype=tf.complex128)
     if logspace:
         lengths = np.rint(
             np.logspace(np.log10(min_length), np.log10(max_length), num=num_lengths)
@@ -554,7 +554,7 @@ def leakage_RB(
     gate = list(U_dict.keys())[0]
     U = U_dict[gate]
     dim = int(U.shape[0])
-    psi_init = tf.Variable(basis(dim, 0), dtype=tf.complex128)
+    psi_init = tf.constant(basis(dim, 0), dtype=tf.complex128)
     if logspace:
         lengths = np.rint(
             np.logspace(np.log10(min_length), np.log10(max_length), num=num_lengths)
@@ -701,7 +701,7 @@ def orbit_infid(
     infids = []
     for U in Us:
         dim = int(U.shape[0])
-        psi_init = tf.Variable(basis(dim, 0), dtype=tf.complex128)
+        psi_init = tf.constant(basis(dim, 0), dtype=tf.complex128)
         psi_actual = tf.matmul(U, psi_init)
         pop0 = tf_abs(psi_actual[0]) ** 2
         p1 = 1 - pop0

c3/optimizers/c1.py

@@ -36,17 +36,17 @@ class C1(Optimizer):
     """
 
     def __init__(
-        self,
-        dir_path,
-        fid_func,
-        fid_subspace,
-        pmap,
-        callback_fids=[],
-        algorithm=None,
-        store_unitaries=False,
-        options={},
-        run_name=None,
-        interactive=True,
+            self,
+            dir_path,
+            fid_func,
+            fid_subspace,
+            pmap,
+            callback_fids=[],
+            algorithm=None,
+            store_unitaries=False,
+            options={},
+            run_name=None,
+            interactive=True,
     ) -> None:
         super().__init__(
             pmap=pmap,
@@ -65,14 +65,6 @@ def __init__(
     def log_setup(self) -> None:
         """
         Create the folders to store data.
-
-        Parameters
-        ----------
-        dir_path : str
-            Filepath
-        run_name : str
-            User specified name for the run
-
         """
         dir_path = os.path.abspath(self.__dir_path)
         run_name = self.__run_name
@@ -90,11 +82,12 @@ def load_model_parameters(self, adjust_exp: str) -> None:
         self.pmap.model.update_model()
         shutil.copy(adjust_exp, os.path.join(self.logdir, "adjust_exp.log"))
 
-    def optimize_controls(self) -> None:
+    def optimize_controls(self, setup_log: bool = True) -> None:
         """
         Apply a search algorithm to your gateset given a fidelity function.
         """
-        self.log_setup()
+        if setup_log:
+            self.log_setup()
         self.start_log()
         self.exp.set_enable_store_unitaries(self.store_unitaries, self.logdir)
         print(f"C3:STATUS:Saving as: {os.path.abspath(self.logdir + self.logname)}")

c3/optimizers/optimizer.py

@@ -18,10 +18,6 @@ class Optimizer:
     ----------
     algorithm : callable
         From the algorithm library
-    plot_dynamics : boolean
-        Save plots of time-resolved dynamics in dir_path
-    plot_pulses : boolean
-        Save plots of control signals
     store_unitaries : boolean
         Store propagators as text and pickle
     """
@@ -42,7 +38,7 @@ def __init__(
         self.created_by = None
         self.logname = None
         self.options = None
-        self.dir_path = None
+        self.__dir_path = None
         self.logdir = None
         self.set_algorithm(algorithm)
 
@@ -62,24 +58,22 @@ def replace_logdir(self, new_logdir):
         new_logdir
 
         """
-        try:
-            old_logdir = self.logdir
-        except AttributeError:
-            old_logdir = None
-            pass
+        old_logdir = self.logdir
         self.logdir = new_logdir
+
+        if old_logdir is None:
+            return
+
         try:
-            os.remove(os.path.join(self.dir_path, "recent"))
+            os.remove(os.path.join(self.__dir_path, "recent"))
         except FileNotFoundError:
             pass
-        except AttributeError as e:
-            Warning(e)
-        # os.remove(self.dir_path + self.string)
-        if old_logdir:
-            try:
-                os.rmdir(old_logdir)
-            except OSError:
-                pass
+        # os.remove(self.__dir_path + self.string)
+
+        try:
+            os.rmdir(old_logdir)
+        except OSError:
+            pass
 
     def set_exp(self, exp: Experiment) -> None:
         self.exp = exp
@@ -235,7 +229,7 @@ def fct_to_min(
         """
 
         if isinstance(input_parameters, np.ndarray):
-            current_params = tf.Variable(input_parameters)
+            current_params = tf.constant(input_parameters)
             goal = self.goal_run(current_params)
             self.log_parameters()
             goal = float(goal)
@@ -261,7 +255,7 @@ def fct_to_min_autograd(self, x):
          float
              Value of the goal function.
         """
-        current_params = tf.Variable(x)
+        current_params = tf.constant(x)
         goal, grad = self.goal_run_with_grad(current_params)
         if isinstance(grad, tf.Tensor):
             grad = grad.numpy()

c3/optimizers/sensitivity.py

@@ -245,15 +245,15 @@ def goal_run(self, current_params):
                     goal = neg_loglkh_multinom_norm(
                         m_vals,
                         tf.stack(sim_vals),
-                        tf.Variable(m_stds, dtype=tf.float64),
-                        tf.Variable(m_shots, dtype=tf.float64),
+                        tf.constant(m_stds, dtype=tf.float64),
+                        tf.constant(m_shots, dtype=tf.float64),
                     )
                 else:
                     goal = g_LL_prime(
                         m_vals,
                         tf.stack(sim_vals),
-                        tf.Variable(m_stds, dtype=tf.float64),
-                        tf.Variable(m_shots, dtype=tf.float64),
+                        tf.constant(m_stds, dtype=tf.float64),
+                        tf.constant(m_shots, dtype=tf.float64),
                     )
                 goals.append(goal.numpy())
                 seq_weigths.append(num_seqs)

c3/parametermap.py

@@ -8,6 +8,7 @@
 from c3.c3objs import Quantity
 from c3.signal.gates import Instruction
 from c3.signal.pulse import components as comp_lib
+from typing import Union
 
 
 class ParameterMap:
@@ -250,7 +251,7 @@ def get_parameters_scaled(self) -> np.ndarray:
         # TODO is there a reason to not return a tensorflow array
         return np.concatenate(values, axis=0).flatten()
 
-    def set_parameters_scaled(self, values: tf.Variable) -> None:
+    def set_parameters_scaled(self, values: Union[tf.constant, tf.Variable]) -> None:
         """
         Set the values in the original instruction class. This fuction should only be
         called by an optimizer. Are you an optimizer?
@@ -259,8 +260,6 @@ def set_parameters_scaled(self, values: tf.Variable) -> None:
         ----------
         values: list
             List of parameter values. Matrix valued parameters need to be flattened.
-        opt_map: list
-            Corresponding identifiers for the parameter values.
 
         """
         model_updated = False

c3/system/chip.py

@@ -118,10 +118,10 @@ def init_Hs(self, ann_oper):
 
         """
         resonator = hamiltonians["resonator"]
-        self.Hs["freq"] = tf.Variable(resonator(ann_oper), dtype=tf.complex128)
+        self.Hs["freq"] = tf.constant(resonator(ann_oper), dtype=tf.complex128)
         if self.hilbert_dim > 2:
             duffing = hamiltonians["duffing"]
-            self.Hs["anhar"] = tf.Variable(duffing(ann_oper), dtype=tf.complex128)
+            self.Hs["anhar"] = tf.constant(duffing(ann_oper), dtype=tf.complex128)
 
     def get_Hamiltonian(self):
         """
@@ -216,7 +216,7 @@ def init_Hs(self, ann_oper):
             Annihilation operator in the full Hilbert space.
 
         """
-        self.Hs["freq"] = tf.Variable(
+        self.Hs["freq"] = tf.constant(
             hamiltonians["resonator"](ann_oper), dtype=tf.complex128
         )
 
@@ -317,10 +317,10 @@ def get_freq(self):
 
     def init_Hs(self, ann_oper):
         resonator = hamiltonians["resonator"]
-        self.Hs["freq"] = tf.Variable(resonator(ann_oper), dtype=tf.complex128)
+        self.Hs["freq"] = tf.constant(resonator(ann_oper), dtype=tf.complex128)
         if self.hilbert_dim > 2:
             duffing = hamiltonians["duffing"]
-            self.Hs["anhar"] = tf.Variable(duffing(ann_oper), dtype=tf.complex128)
+            self.Hs["anhar"] = tf.constant(duffing(ann_oper), dtype=tf.complex128)
 
     def init_Ls(self, ann_oper):
         """
@@ -446,12 +446,12 @@ def init_Hs(self, ann_oper):
             Annihilation operator in the full Hilbert space
         """
         resonator = hamiltonians["resonator"]
-        self.Hs["freq"] = tf.Variable(resonator(ann_oper), dtype=tf.complex128)
+        self.Hs["freq"] = tf.constant(resonator(ann_oper), dtype=tf.complex128)
         if self.hilbert_dim > 2:
             duffing = hamiltonians["duffing"]
-            self.Hs["anhar"] = tf.Variable(duffing(ann_oper), dtype=tf.complex128)
+            self.Hs["anhar"] = tf.constant(duffing(ann_oper), dtype=tf.complex128)
         third = hamiltonians["third_order"]
-        self.Hs["beta"] = tf.Variable(third(ann_oper), dtype=tf.complex128)
+        self.Hs["beta"] = tf.constant(third(ann_oper), dtype=tf.complex128)
 
     def get_Hamiltonian(self):
         """
@@ -546,7 +546,7 @@ def __init__(
             self.params["strength"] = strength
 
     def init_Hs(self, opers_list):
-        self.Hs["strength"] = tf.Variable(
+        self.Hs["strength"] = tf.constant(
             self.hamiltonian_func(opers_list), dtype=tf.complex128
         )
 
@@ -570,7 +570,7 @@ class Drive(LineComponent):
     def init_Hs(self, ann_opers: list):
         hs = []
         for a in ann_opers:
-            hs.append(tf.Variable(self.hamiltonian_func(a), dtype=tf.complex128))
+            hs.append(tf.constant(self.hamiltonian_func(a), dtype=tf.complex128))
         self.h = sum(hs)
 
     def get_Hamiltonian(self):

c3/system/model.py

@@ -331,14 +331,14 @@ def get_Frame_Rotation(self, t_final: np.float64, freqs: dict, framechanges: dic
         tf.Tensor
             A (diagonal) propagator that adjust phases
         """
-        exponent = tf.Variable(0.0, dtype=tf.complex128)
+        exponent = tf.constant(0.0, dtype=tf.complex128)
         for line in freqs.keys():
             freq = freqs[line]
             framechange = framechanges[line]
             qubit = self.couplings[line].connected[0]
             # TODO extend this to multiple qubits
             ann_oper = self.ann_opers[self.names.index(qubit)]
-            num_oper = tf.Variable(
+            num_oper = tf.constant(
                 np.matmul(ann_oper.T.conj(), ann_oper), dtype=tf.complex128
             )
             # TODO test dressing of FR
@@ -375,12 +375,12 @@ def get_dephasing_channel(self, t_final, amps):
             qubit = self.couplings[line].connected[0]
             # TODO extend this to multiple qubits
             ann_oper = self.ann_opers[self.names.index(qubit)]
-            num_oper = tf.Variable(
+            num_oper = tf.constant(
                 np.matmul(ann_oper.T.conj(), ann_oper), dtype=tf.complex128
             )
             Z = tf_utils.tf_super(
                 tf.linalg.expm(
-                    1.0j * num_oper * tf.Variable(np.pi, dtype=tf.complex128)
+                    1.0j * num_oper * tf.constant(np.pi, dtype=tf.complex128)
                 )
             )
             p = t_final * amp * self.dephasing_strength

c3/system/tasks.py

@@ -69,7 +69,7 @@ def initialise(self, drift_H, lindbladian=False, init_temp=None):
             else:
                 raise Warning("C3:WARNING: We still need to do Von Neumann right.")
         else:
-            state = tf.Variable(
+            state = tf.constant(
                 qt_utils.basis(dim, 0), shape=[dim, 1], dtype=tf.complex128
             )
             if lindbladian:
@@ -107,7 +107,7 @@ def confuse(self, pops):
             Populations after misclassification.
 
         """
-        conf_matrix = tf.Variable([[1]], dtype=tf.float64)
+        conf_matrix = tf.constant([[1]], dtype=tf.float64)
         for conf_row in self.params.values():
             row1 = conf_row.get_value()
             row2 = tf.ones_like(row1) - row1

c3/utils/tf_utils.py

@@ -417,7 +417,7 @@ def tf_matmul_n(tensor_list):
 def tf_log10(x):
     """Tensorflow had no logarithm with base 10. This is ours."""
     numerator = tf.log(x)
-    denominator = tf.log(tf.Variable(10, dtype=numerator.dtype))
+    denominator = tf.log(tf.constant(10, dtype=numerator.dtype))
     return numerator / denominator
 
 
@@ -443,8 +443,8 @@ def tf_diff(l):  # noqa
     returns the same shape by adding a 0 in the last entry.
     """
     dim = l.shape[0] - 1
-    diagonal = tf.Variable([-1] * dim + [0], dtype=l.dtype)
-    offdiagonal = tf.Variable([1] * dim, dtype=l.dtype)
+    diagonal = tf.constant([-1] * dim + [0], dtype=l.dtype)
+    offdiagonal = tf.constant([1] * dim, dtype=l.dtype)
     proj = tf.linalg.diag(diagonal) + tf.linalg.diag(offdiagonal, k=1)
     return tf.linalg.matvec(proj, l)
 
@@ -501,7 +501,7 @@ def tf_expm_dynamic(A, acc=1e-4):
     A_powers = A
     r += A
 
-    ii = tf.Variable(2, dtype=tf.complex128)
+    ii = tf.constant(2, dtype=tf.complex128)
     while tf.reduce_max(tf.abs(A_powers)) > acc:
         A_powers = tf.matmul(A_powers, A) / ii
         ii += 1
@@ -564,7 +564,7 @@ def tf_choi_to_chi(U, dims=None):
     """
     if dims is None:
         dims = [tf.sqrt(tf.cast(U.shape[0], U.dtype))]
-    B = tf.Variable(qt_utils.pauli_basis([2] * len(dims)), dtype=tf.complex128)
+    B = tf.constant(qt_utils.pauli_basis([2] * len(dims)), dtype=tf.complex128)
     return tf.linalg.adjoint(B) @ U @ B
 
 
@@ -708,5 +708,5 @@ def tf_project_to_comp(A, dims, to_super=False):
     proj = proj_list.pop()
     while not proj_list == []:
         proj = np.kron(proj_list.pop(), proj)
-    P = tf.Variable(proj, dtype=A.dtype)
+    P = tf.constant(proj, dtype=A.dtype)
     return tf.matmul(tf.matmul(P, A, transpose_a=True), P)

c3/utils/utils.py

@@ -123,6 +123,8 @@ def jsonify_list(data):
         return {k: jsonify_list(v) for k, v in data.items()}
     elif isinstance(data, list):
         return [jsonify_list(v) for v in data]
+    elif isinstance(data, tuple):
+        return tuple(jsonify_list(v) for v in data)
     elif isinstance(data, np.ndarray):
         return data.tolist()
     elif isinstance(data, ops.EagerTensor):

test/test_quantity.py

@@ -123,3 +123,8 @@ def test_qty_np_conversions() -> None:
 
     b = Quantity(np.array([0.0000001, 0.00001]))
     np.array([b])
+
+    c = Quantity([0, 0.1])
+    assert len(c) == 2
+    assert c.shape == [2]
+

test/test_tf_utils.py

@@ -24,8 +24,8 @@ def test_unitary_overlap(args: Tuple[List[int], List[int], List[int]]) -> None:
         Matrix A, Matrix B and Expected Overlap
     """
     x, x_noisy, over = args
-    pauli_x = tf.Variable(x)
-    pauli_x_noisy = tf.Variable(x_noisy)
+    pauli_x = tf.constant(x)
+    pauli_x_noisy = tf.constant(x_noisy)
 
     overlap = tf_unitary_overlap(pauli_x, pauli_x_noisy)
     assert overlap.numpy() > over