|---|
| [ View source on GitHub](https://github.com/tensorflow/quantum/blob/v0.7.6/tensorflow_quantum/core/ops/circuit_execution_ops.py#L41-L151) |
Get a TensorFlow op that will calculate batches of expectation values.
tfq.get_expectation_op(
backend=None,
*,
quantum_concurrent=quantum_context.get_quantum_concurrent_op_mode()
)
This function produces a non-differentiable TF op that will calculate
batches of expectation values given tensor batches of [`cirq.Circuit`](https://quantumai.google/reference/python/cirq/Circuit)s,
parameter values, and [`cirq.PauliSum`](https://quantumai.google/reference/python/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)
output
tf.Tensor([[0.71530885]], shape=(1, 1), dtype=float32)
In order to make the op differentiable, a `tfq.differentiator` object is
needed. see [`tfq.differentiators`](https://www.tensorflow.org/quantum/api_docs/python/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(
analytic_op=my_op
)
| ## Args ||
|---|---|
| `backend` | Optional Python `object` that specifies what backend this op should use when evaluating circuits. Can be [`cirq.DensityMatrixSimulator`](https://quantumai.google/reference/python/cirq/DensityMatrixSimulator) or any `cirq.sim.simulator.SimulatesExpectationValues`. If not provided the default C++ analytical expectation calculation op is returned. |
| `quantum_concurrent` | Optional Python `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`](https://www.tensorflow.org/quantum/api_docs/python/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 chip. |
| ## Returns ||
|---|---|
| A `callable` with the following signature:
`op(programs, symbol_names, symbol_values, pauli_sums)` ||
| `programs` | [`tf.Tensor`](https://www.tensorflow.org/api_docs/python/tf/Tensor) of strings with shape \[batch_size\] containing the string representations of the circuits to be executed. |
| `symbol_names` | [`tf.Tensor`](https://www.tensorflow.org/api_docs/python/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 `programs`. |
| `symbol_values` | [`tf.Tensor`](https://www.tensorflow.org/api_docs/python/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 dictated by `symbol_names`. |
| `pauli_sums` | [`tf.Tensor`](https://www.tensorflow.org/api_docs/python/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. |
| `Returns` | [`tf.Tensor`](https://www.tensorflow.org/api_docs/python/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). |