Get a TensorFlow op that will calculate batches of expectation values.
This function produces a non-differentiable TF op that will calculate
batches of expectation values given tensor batches of
parameter values, and
cirq.PauliSum operators to measure.
# Simulate circuits with C++.
my_op = tfq.get_expectation_op()
# Prepare some inputs.
qubit = cirq.GridQubit(0, 0)
my_symbol = sympy.Symbol('alpha')
my_circuit_tensor = tfq.convert_to_tensor([
cirq.Circuit(cirq.H(qubit) ** my_symbol)
my_values = np.array([[0.123]])
my_paulis = tfq.convert_to_tensor([[
3.5 * cirq.X(qubit) - 2.2 * cirq.Y(qubit)
# This op can now be run with:
output = my_op(
my_circuit_tensor, ['alpha'], my_values, my_paulis)
tf.Tensor([[0.71530885]], shape=(1, 1), dtype=float32)
In order to make the op differentiable, a
tfq.differentiator object is
tfq.differentiators for more details. Below is a simple
example of how to make my_op from the above code block differentiable:
diff = tfq.differentiators.ForwardDifference()
my_differentiable_op = diff.generate_differentiable_op(
object that specifies what backend this op
should use when evaluating circuits. Can be any
cirq.SimulatesFinalState. If not provided the default C++
analytical expectation calculation op is returned.
bool. True indicates that the
returned op should not block graph level parallelism on itself when
executing. False indicates that graph level parallelism on itself
should be blocked. Defaults to value specified in
tfq.get_quantum_concurrent_op_mode which defaults to True
(no blocking). This flag is only needed for advanced users when
using TFQ for very large simulations, or when running on a real
callable with the following signature:
op(programs, symbol_names, symbol_values, pauli_sums)
tf.Tensor of strings with shape [batch_size] containing
the string representations of the circuits to be executed.
tf.Tensor of strings with shape [n_params], which
is used to specify the order in which the values in
symbol_values should be placed inside of the circuits in
tf.Tensor of real numbers with shape
[batch_size, n_params] specifying parameter values to resolve
into the circuits specified by programs, following the ordering
tf.Tensor of strings with shape [batch_size, n_ops]
containing the string representation of the operators that will
be used on all of the circuits in the expectation calculations.
tf.Tensor with shape [batch_size, n_ops] that holds the
expectation value for each circuit with each op applied to it
(after resolving the corresponding parameters in).