Calculate the analytic expectation values using monte-carlo trajectories.

Simulate the final state of programs given symbol_values are placed inside of the symbols with the name in symbol_names in each circuit. Channels in this simulation will be "tossed" to a certain realization during simulation. This simulation is repeated num_samples times and analytic expectation calculations with the given pauli_sums are calculated after each run. Once all the runs are finished, these quantities are averaged together. This process can be thought of as analyical expectation calculation done using monte carlo state vector simulation to account for noisy operations in the given circuits.

# Prepare some inputs.
qubit = cirq.GridQubit(0, 0)
my_symbol = sympy.Symbol('alpha')
my_circuit_tensor = tfq.convert_to_tensor([
        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)
my_num_samples = np.array([[100]])
# This op can now be run with:
output = tfq.noise.expectation(
    my_circuit_tensor, ['alpha'], my_values, my_paulis, my_num_samples)
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 for more details. Below is a simple example of how to make the from the above code block differentiable:

diff = tfq.differentiators.ForwardDifference()
my_differentiable_op = diff.generate_differentiable_op(

programs tf.Tensor of strings with shape [batch_size] containing the string representations of the circuits to be executed.
symbol_names 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 of real numbers with shape [batch_size, n_params] specifying parameter values to resolve into the circuits specificed by programs, following the ordering dictated by symbol_names.
pauli_sums 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.
num_samples tf.Tensor with num_samples[i][j] is equal to the number of times programs[i] will be simulated to estimate pauli_sums[i][j]. Therefore, num_samples must have the same shape as pauli_sums. Note: internally this quantity can get rounded up to the nearest multiple of the number of available threads to TensorFlow. For best performance ensure that the quantities in num_samples are a multiple of the number of available threads.

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).