def plot_hist(ax, sextable, mcolour='blue', fcolour='red', ucolour='none'):
cdict = {0: mcolour, 1: fcolour, None: ucolour}
Mx, Lx, Ma, La, Rl, Rx = [
np.array(map(operator.itemgetter(i), sextable), dtype=float)
for i in range(1, 7)
]
hard_sex, soft_sex, m_dist, f_dist, m_mu, f_mu, m_bound, f_bound, logit_pm = assign_sex(
sextable, sextable[0][5])
males = [Rx[i] for i, j in enumerate(hard_sex) if j == 0]
females = [Rx[i] for i, j in enumerate(hard_sex) if j == 1]
mMx = [Mx[i] for i, j in enumerate(hard_sex) if j == 0]
mMa = [Ma[i] for i, j in enumerate(hard_sex) if j == 0]
fMx = [Mx[i] for i, j in enumerate(hard_sex) if j == 1]
fMa = [Ma[i] for i, j in enumerate(hard_sex) if j == 1]
hardcolours = [cdict[i] for i in hard_sex]
softcolours = [cdict[i] for i in soft_sex]
msoftcolours = [cdict[i] for i in soft_sex if i != 1]
fsoftcolours = [cdict[i] for i in soft_sex if i != 0]
_, bins, _ = ax.hist(Rx, bins=len(Rx) / 4, fill=False)
marea = len(males) * (bins[1] - bins[0])
farea = len(females) * (bins[1] - bins[0])
x = np.linspace(0, 2 * Rl[0], 1000)
ax.plot(x, marea * m_dist.pdf(x), '-', color=mcolour)
#ax.scatter(males, marea*m_dist.pdf(males), facecolor=msoftcolours, edgecolor=mcolour)
ax.plot(x, farea * f_dist.pdf(x), '-', color=fcolour)
#ax.scatter(females, farea*f_dist.pdf(females), facecolor=fsoftcolours, edgecolor=fcolour)
ylim = ax.get_ylim()
ax.vlines(m_mu, 0, ylim[1], color=mcolour, linestyle=':')
ax.vlines(f_mu, 0, ylim[1], color=fcolour, linestyle=':')
ax.vlines(m_bound, 0, ylim[1], color=mcolour, linestyle='--')
ax.vlines(f_bound, 0, ylim[1], color=fcolour, linestyle='--')
ax.set_ylim((0, ylim[1]))
m_patch = mpatches.Patch(color=mcolour)
f_patch = mpatches.Patch(color=fcolour)
ax.legend([m_patch, f_patch], [
'male ($n={}({}), \\bar{{x}}={:.3f}, var={:.2e}, Beta.var={:.2e}$)'.
format(len(males), len([m for m in males if m < m_bound]), m_mu,
np.var(males),
beta.var(np.median(mMa),
np.median(mMa) + np.median(mMx))),
'female ($n={}({}), \\bar{{x}}={:.3f}, var={:.2e}, Beta.var={:.2e}$)'.
format(len(females), len([f for f in females if f > f_bound]), f_mu,
np.var(females),
beta.var(np.median(fMa),
np.median(fMa) + np.median(fMx)))
])
ax.set_xlabel('Proportion of mapped reads: X/(X+Autosome)')
ax.set_ylabel('Frequency (counts)')
ax.set_title('K-means clustering for sex assignment')
def r(theta_hat): # expected reward with sampled model state "theta"
if reward_type == 'least_accurate':
return -theta_hat # E(y|theta_hat)
elif reward_type == 'most_accurate':
return theta_hat
elif reward_type == 'most_biased':
raise ValueError
elif reward_type == 'least_biased':
raise ValueError
elif reward_type == 'groupwise_accuracy':
var_plus_1 = beta.var(self._params[:, 0] + 1, self._params[:,
1])
var_plus_0 = beta.var(self._params[:, 0],
self._params[:, 1] + 1)
E_var = var_plus_1 * theta_hat + var_plus_0 * (1 - theta_hat)
return (self.variance - E_var) * self._weight
elif reward_type == 'difference':
if group0 is None or group1 is None:
raise ValueError
def rope(alpha0, alpha1, beta0, beta1):
num_samples = 10000
theta_0 = np.random.beta(alpha0, beta0, size=(num_samples))
theta_1 = np.random.beta(alpha1, beta1, size=(num_samples))
delta = theta_0 - theta_1
return max((delta < -0.05).mean(),
(np.abs(delta) <= 0.05).mean(),
(delta > 0.05).mean())
alpha0, beta0 = self._params[group0]
alpha1, beta1 = self._params[group1]
rope_plus_1 = np.array([
rope(alpha0 + 1, alpha1, beta0, beta1),
rope(alpha0, alpha1 + 1, beta0, beta1)
])
rope_plus_0 = np.array([
rope(alpha0, alpha1, beta0 + 1, beta1),
rope(alpha0, alpha1, beta0, beta1 + 1)
])
theta_hat = theta_hat[[group0, group1]]
E_rope = rope_plus_1 * theta_hat + rope_plus_0 * (1 -
theta_hat)
r = np.ones(self._k) * (
-1) # set reward of other groups to be -1
r[[group0, group1]] = E_rope
return r
def variance(self) -> float:
"""
Eval variance of posterior of ECE.
:return:
"""
variance_bin = beta.var(self._alpha, self._beta)
if self._weight is not None: # pool weights
weight = self._weight
else: # online weights
tmp = np.sum(self._counts, axis=1)
weight = tmp / sum(tmp)
return np.dot(weight * weight, variance_bin)
def shots_to_obs_moments(bitarray: np.ndarray, qubits: List[int], observable: PauliTerm,
use_beta_dist_unbiased_prior: bool = False) -> Tuple[float, float]:
"""
Calculate the mean and variance of the given observable based on the bitarray of results.
:param bitarray: results from running `qc.run`, a 2D num_shots by num_qubits array.
:param qubits: list of qubits in order corresponding to the bitarray results.
:param observable: the observable whose moments are calculated from the shot data
:param use_beta_dist_unbiased_prior: if true then the mean and variance are estimated from a
beta distribution that incorporates an unbiased Bayes prior. This precludes var = 0.
:return: tuple specifying (mean, variance)
"""
coeff = complex(observable.coefficient)
if not np.isclose(coeff.imag, 0):
raise ValueError(f"The coefficient of an observable should not be complex.")
coeff = coeff.real
obs_qubits = [q for q, _ in observable]
# Identify classical register indices to select
idxs = [idx for idx, q in enumerate(qubits) if q in obs_qubits]
if len(idxs) == 0: # identity term
return coeff, 0
assert bitarray.shape[1] == len(qubits), 'qubits should label each column of the bitarray'
# Pick columns corresponding to qubits with a non-identity out_operation
obs_strings = bitarray[:, idxs]
# Transform bits to eigenvalues; ie (+1, -1)
my_obs_strings = 1 - 2 * obs_strings
# Multiply row-wise to get operator values.
obs_vals = np.prod(my_obs_strings, axis=1)
if use_beta_dist_unbiased_prior:
# For binary classified data with N counts of + and M counts of -, these can be estimated
# using the mean and variance of the beta distribution beta(N+1, M+1) where the +1 is used
# to incorporate an unbiased Bayes prior.
plus_array = obs_vals == 1
n_minus, n_plus = np.bincount(plus_array, minlength=2)
bernoulli_mean = beta.mean(n_plus + 1, n_minus + 1)
bernoulli_var = beta.var(n_plus + 1, n_minus + 1)
obs_mean, obs_var = transform_bit_moments_to_pauli(bernoulli_mean, bernoulli_var)
obs_mean *= coeff
obs_var *= coeff**2
else:
obs_vals = coeff * obs_vals
obs_mean = np.mean(obs_vals).item()
obs_var = np.var(obs_vals).item() / len(bitarray)
return obs_mean, obs_var
def survival_statistics(bitstrings):
"""
Calculate the mean and variance of the estimated probability of the ground state given shot
data on one or more bits.
For binary classified data with N counts of 1 and M counts of 0, these
can be estimated using the mean and variance of the beta distribution beta(N+1, M+1) where the
+1 is used to incorporate an unbiased Bayes prior.
:param ndarray bitstrings: A 2D numpy array of repetitions x bit-arrays.
:return: (survival mean, sqrt(survival variance))
"""
survived = np.sum(bitstrings, axis=1) == 0
# count obmurrences of 000...0 and anything besides 000...0
n_died, n_survived = bincount(survived, minlength=2)
# mean and variance given by beta distribution with a uniform prior
survival_mean = beta.mean(n_survived + 1, n_died + 1)
survival_var = beta.var(n_survived + 1, n_died + 1)
return survival_mean, np.sqrt(survival_var)
def get_var(self):
return beta.var(self.a, self.b)
def variance(self):
return beta.var(self.alpha, self.beta)
def variance(self) -> np.ndarray:
"""
Variance of posterior classwise accuracy.
:return: An (k, ) array of variance of posteriors of classwise accuracies.
"""
return beta.var(self._params[:, 0], self._params[:, 1])
def var(self, n, p):
var = beta.var(self, n, p)
return var
from scipy.stats import beta
a = 7.2
b = 2.3
m, v = beta.stats(a, b, moments="mv")
mean = beta.mean(a=a, b=b)
var = beta.var(a=a, b=b)
print("The mean is " + str(m))
print("The variance is " + str(v))
prob = 1 - beta.cdf(a=a, b=b, x=.90)
print("The probability of having a variance over 90% is " + str(prob))
def variance(self) -> np.ndarray:
return beta.var(self._params[:, 0], self._params[:, 1])
def variance(self):
return beta.var(self._params[:, 0], self._params[:, 1])