def cross_entropy(predictions: np.ndarray,
targets: np.ndarray,
epsilon: float = 1e-15) -> float:
"""
Cross entropy calculation between :py:attr:`targets` (encoded as one-hot vectors)
and :py:attr:`predictions`. Predictions are normalized to sum up to `1.0`.
.. note::
The implementation of this function is based on the discussion on
`StackOverflow <https://stackoverflow.com/a/47398312/10138546>`_.
Due to ArrayBoxes that are required for automatic differentiation, we currently
use this implementation instead of implementations provided by sklearn for
example.
:param predictions: Predictions in same order as targets. In case predictions for
several samples are given, the weighted cross entropy is returned.
:param targets: Ground truth labels for supplied samples.
:param epsilon: Amount to clip predictions as log is not defined for `0` and `1`.
"""
assert (
predictions.shape == targets.shape
), f"Shape of predictions {predictions.shape} must match targets {targets.shape}"
current_sum = np.sum(predictions, axis=predictions.ndim - 1)
if predictions.ndim == 1:
sample_count = 1
predictions = predictions / current_sum
else:
sample_count = predictions.shape[0]
predictions = predictions / current_sum[:, np.newaxis]
predictions = np.clip(predictions, epsilon, 1.0 - epsilon)
return -np.sum(targets * np.log(predictions)) / sample_count
def shadow_bound(error, observables, failure_rate=0.01):
"""
Calculate the shadow bound for the Pauli measurement scheme.
Implements Eq. (S13) from https://arxiv.org/pdf/2002.08953.pdf
Args:
error (float): The error on the estimator.
observables (list) : List of matrices corresponding to the observables we intend to
measure.
failure_rate (float): Rate of failure for the bound to hold.
Returns:
An integer that gives the number of samples required to satisfy the shadow bound and
the chunk size required attaining the specified failure rate.
"""
M = len(observables)
K = 2 * np.log(2 * M / failure_rate)
shadow_norm = (
lambda op: np.linalg.norm(
op - np.trace(op) / 2 ** int(np.log2(op.shape[0])), ord=np.inf
)
** 2
)
N = 34 * max(shadow_norm(o) for o in observables) / error ** 2
return int(np.ceil(N * K)), int(K)
def cross_entropy(X, y):
m = y.shape[0]
p = np.array([softmax(x) for x in X])
# We use multidimensional array indexing to extract
# softmax probability of the correct label for each sample.
log_likelihood = -np.log(p[range(m), y])
loss = np.sum(log_likelihood) / m
return loss
def disc_cost(d_weights):
cost = 0.0
for j in range(MINIBATCH_SIZE):
D_real = prob_real(
real_disc_circuit(d_weights,
data=data[j][0] + [data[j][1]]))
G_real = gen_output(
real_gen_circuit(gen_weights, data=data[j][0]))
D_fake = prob_real(
real_disc_circuit(d_weights,
data=data[j][0] + [G_real]))
if type(D_real) != np.float64:
D_real = D_real._value
if type(D_fake) != np.float64:
D_fake = D_fake._value
cost -= np.log(D_real) + np.log(1 - D_fake)
cost /= MINIBATCH_SIZE
return cost
def EnsembleEntropy(self, ProbDist):
'''
Compute ensemble entropy
from prob dist.
'''
ent = 0.0
# E = sum of entropies since
# ansatz is prod state
for dist in ProbDist:
ent += -1 * np.sum(dist * np.log(dist))
return ent
def cross_entropy(labels, predictions):
""" Categorical cross entropy loss function
Args:
labels (array[float]): 1-d array of labels
predictions (array[float]): 1-d array of predictions
Returns:
float: cross entropy
"""
loss = 0
for label, pred in zip(labels, predictions):
for label_, pred_ in zip(label, pred):
loss -= label_ * np.log(pred_)
loss = loss / len(labels)
return loss
np.random.seed(1)
# initialize some random vals for the periodic convolution
init = np.random.uniform(low=-1, high=1, size=(2))
c = np.zeros(M)
c[0] = init[0]
c[1] = init[1]
# get the fourier transformed values and seperate argument and absolute value
complex_vals = np.fft.fft(c)
scale_arg = np.angle(complex_vals)
scale_abs = np.absolute(complex_vals)
# get the required squeeze scaling argument
r1 = -np.log(scale_abs)
# perform a neural network feed forward using the transformed Fourier matrix, the required phase shift using a rotation gate (phase gate),
# the required squeeze scaling and the Fourier matrix
circ_res = quantum_circ1(x=x,
phi_x=phi_x,
U1=F_H,
U2=F,
r=r1,
phi_r=phi_r,
phi_rot=scale_arg)
# theoretical transformation
mat = F @ np.diag(scale_abs * np.exp(1J * scale_arg)) @ F_H
ansatz = mera_circuit(num_qubits, periodic, fix_layers)
cost_fn = qml.ExpvalCost(ansatz, H, dev)
grad = qml.grad(cost_fn)
num_params_per_gate = 15
num_gates = get_num_mera_gates(num_qubits, periodic, fix_layers)
num_params = num_params_per_gate * num_gates
params = np.pi * (np.random.rand(num_params) - 1.0)
gradient = np.array(grad(params)[0])
grad_vals.append(gradient)
variances.append(np.mean(np.var(grad_vals, axis=0)))
print(variances)
#variances = np.array(np.mean(variances, axis=1))
qubits = np.array(qubits)
# Fit the semilog plot to a straight line
p = np.polyfit(qubits, np.log(variances), 1)
# Plot the straight line fit to the semilog
plt.semilogy(qubits, variances, "o")
plt.semilogy(qubits,
np.exp(p[0] * qubits + p[1]),
"o-.",
label="Slope {:3.2f}".format(p[0]))
plt.xlabel(r"N Qubits")
plt.ylabel(r"$\langle \partial \theta_{1, 1} E\rangle$ variance")
plt.legend()
plt.show()
def classical(p):
"Classical node, requires autograd.numpy functions."
return anp.exp(anp.sum(quantum(p[0], anp.log(p[1]))))
def second_renyi_entropy(rho):
"""Computes the second Renyi entropy of a given density matrix."""
# DO NOT MODIFY anything in this code block
rho_diag_2 = np.diagonal(rho)**2.0
return -np.real(np.log(np.sum(rho_diag_2)))
