View source on GitHub 
Calculate the analytic expectation values using montecarlo trajectories.
tfq.noise.expectation(
programs, symbol_names, symbol_values, pauli_sums, num_samples
)
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.Circuit(
cirq.H(qubit) ** my_symbol,
cirq.depolarize(0.01)(qubit)
)
])
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)
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
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(
sampled_op=tfq.noise.expectation
)
Args  

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.

Returns  

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