def main():
fig, ax = plt.subplots(figsize=gfs)
xs = np.linspace(0., 10., 500)
rvs = stats.lomax(c).pdf(xs)
ax.plot(xs, rvs, label='$\lambda(x) = c/x$')
rvs = stats.expon(scale=1 / c).pdf(xs)
ax.plot(xs, rvs, label='$\lambda(x) = c$')
rvs = stats.rayleigh(scale=np.sqrt(1 / c)).pdf(xs)
ax.plot(xs, rvs, label='$\lambda(x) = cx$')
ax.set_xlim(0, 10)
ax.set_ylim(0, 2)
ax.set_xlabel('$X$ (failure rv)', fontsize=fs)
ax.set_ylabel('$p(x)$', fontsize=fs)
ax.tick_params(labelsize=fs)
ax.legend(fontsize=fs)
plt.tight_layout()
plt.savefig('../hf2pdf-examples.png', bbox_inches='tight')
plt.close()
# logspace now
fig, ax = plt.subplots(figsize=gfs)
xs = np.linspace(0.1, 100., 1000)
rvs = stats.lomax(c).pdf(xs)
ax.plot(xs, rvs, label='$\lambda(x) = c/x$')
rvs = stats.expon(scale=1 / c).pdf(xs)
ax.plot(xs, rvs, label='$\lambda(x) = c$')
rvs = stats.rayleigh(scale=np.sqrt(1 / c)).pdf(xs)
ax.plot(xs, rvs, label='$\lambda(x) = cx$')
ax.set_xlabel('$X$ (failure rv)', fontsize=fs)
ax.set_ylabel('$p(x)$', fontsize=fs)
ax.tick_params(labelsize=fs)
ax.legend(fontsize=fs)
ax.set_ylim(10**-9, )
ax.set_yscale('log')
ax.set_xscale('log')
plt.tight_layout()
plt.savefig('../hf2pdf-examples-loglog.png', bbox_inches='tight')
plt.close()
def diagnostic_plot(x, y, flag=None):
if flag is None:
flag = np.zeros(len(x))
idx = flag.astype(bool)
# Turned off outlier detection because it doesn't work well.
# idx = find_outliers(x, y, initial_clip=idx, threshold=1e-5)
mu_x = np.mean(x[~idx])
mu_y = np.mean(y[~idx])
sma, smi = compute_eigen_vectors(x[~idx], y[~idx])
plt.clf()
plt.gcf().set_size_inches((10, 8))
plt.plot(x, y, "ko", mec="w", label="Centroids", zorder=+5)
if np.any(idx):
plt.plot(x[idx],
y[idx],
"o",
color="pink",
label="Outliers",
zorder=+6)
# prob = compute_prob_of_points(x, y, sma, smi)
for i in range(len(x)):
plt.text(x[i], y[i], " %i" % (i), zorder=+5)
sigma_a = np.linalg.norm(sma)
sigma_b = np.linalg.norm(smi)
angle_deg = np.degrees(np.arctan2(sma[1], sma[0]))
ax = plt.gca()
if 1:
for p in [0.68, 0.95, 0.997]:
scale = spstats.rayleigh().isf(1 - p)
width = 2 * sigma_a * scale
height = 2 * sigma_b * scale
ell = Ellipse(
[mu_x, mu_y],
width=width,
height=height,
angle=angle_deg,
color="gray",
alpha=0.2,
label="%g%% Prob" % (100 * p),
)
ax.add_patch(ell)
plt.axhline(0)
plt.axvline(0)
plt.plot(0, 0, "*", color="c", ms=28, mec="w", mew=2)
plt.xlabel("Column shift (pixels)")
plt.ylabel("Row shift (pixels)")
plt.axis("equal")
plt.legend()
offset, signif = compute_offset_and_signif(x[~idx], y[~idx])
msg = "Offset %i pixels\nProb Transit on Target: %.0e" % (offset, signif)
plt.title(msg)
return plt.gcf()
def rayleigh(x):
#f = get_fading(num_channels)
f = ss.rayleigh().pdf(
ss.rayleigh.rvs(size=2)) # hardcoded in order to save checkpoints
f = f * 0.631 # to correct for skewness
x = x - f
return x
def test_2pl_mml_eap_method(self):
"""Testing the 2PL EAP/MML Method."""
np.random.seed(618331)
n_items = 5
n_people = 150
difficulty = stats.norm(0, 1).rvs(n_items)
discrimination = stats.rayleigh(loc=0.25, scale=.8).rvs(n_items)
thetas = np.random.randn(n_people)
syn_data = create_synthetic_irt_dichotomous(difficulty, discrimination,
thetas)
result = twopl_mml_eap(syn_data, {'hyper_quadrature_n': 21})
# Smoke Tests / Regression Tests
expected_difficulty = np.array(
[-0.2436698, 0.66299148, 1.3451037, -0.68059041, 0.40516614])
expected_discrimination = np.array(
[1.99859796, 0.67420679, 1.18591025, 1.60937911, 1.19672389])
expected_rayleigh_scale = 0.9106036068099617
np.testing.assert_allclose(result['Difficulty'],
expected_difficulty,
atol=1e-3,
rtol=1e-3)
np.testing.assert_allclose(result['Discrimination'],
expected_discrimination,
atol=1e-3,
rtol=1e-3)
self.assertAlmostEqual(result['Rayleigh_Scale'],
expected_rayleigh_scale, 3)
def test_2pl_mml_eap_method_csirt(self):
"""Testing the 2PL EAP/MML Method with CSIRT."""
np.random.seed(779841)
n_items = 10
n_people = 300
difficulty = stats.norm(0, 1).rvs(n_items)
discrimination = stats.rayleigh(loc=0.25, scale=.8).rvs(n_items)
thetas = np.random.randn(n_people)
syn_data = create_synthetic_irt_dichotomous(difficulty, discrimination,
thetas)
result = twopl_mml_eap(syn_data, {'estimate_distribution': True})
# Smoke Tests / Regression Tests
expected_difficulty = np.array([
-0.91561408, 1.29631473, 1.01751178, -0.10536047, -0.02235909,
-0.56510317, -1.67564893, -1.45646904, 1.89544833, -0.78602385
])
expected_discrimination = np.array([
0.9224411, 0.88102312, 0.86716565, 1.38012222, 0.67176012,
1.84035622, 1.58453053, 1.11488035, 1.07633054, 1.44767879
])
expected_rayleigh_scale = 0.7591785686427288
np.testing.assert_allclose(result['Difficulty'],
expected_difficulty,
atol=1e-3,
rtol=1e-3)
np.testing.assert_allclose(result['Discrimination'],
expected_discrimination,
atol=1e-3,
rtol=1e-3)
self.assertAlmostEqual(result['Rayleigh_Scale'],
expected_rayleigh_scale, 3)
def __init__(self, ecc_prior=True, p_prior=True, inc_prior=True,
m1_prior=True, m2_prior=True, para_prior=True,
para_est=0, para_err=0, m1_est=0, m1_err=0, m2_est=0, m2_err=0,
ecc_beta_a=0.867, ecc_beta_b=3.03,
ecc_J08_sig=0.3, ecc_Rexp_lamda=5.12, ecc_Rexp_a=0.781,
ecc_Rexp_sig=0.272, ecc_ST08_a=4.33, ecc_ST08_k=0.2431,p_gamma=-0.7,
mins_ary=[],maxs_ary=[]):
## check min and max range arrays
if (len(mins_ary)>1) and (len(maxs_ary)>1):
self.mins_ary = mins_ary
self.maxs_ary = maxs_ary
else:
raise IOError('\n\n No min/max ranges were provided to the priors object!!')
## push in two manual constants
self.days_per_year = 365.2422
self.sec_per_year = 60*60*24*self.days_per_year
## choices
## choices:'2e', 'ST08','J08', 'RayExp', 'beta', 'uniform'. Default is 'beta'.
self.e_prior = ecc_prior
## `best-fit' alpha and beta from Kipping+2013
self.ecc_beta = stats.beta(ecc_beta_a,ecc_beta_b) #https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.beta.html
## 'best-fit' for the basic Rayleigh from Juric+2008
self.ecc_J08_sig = ecc_J08_sig ### Put this into the advanced settings ???
## `best-fit' alpha, lambda and sig from Kipping+2013
self.ecc_Rexp_lamda = ecc_Rexp_lamda ### Put this into the advanced settings ???
self.ecc_Rexp_a = ecc_Rexp_a ### Put this into the advanced settings ???
self.ecc_Rexp_sig = ecc_Rexp_sig ### Put this into the advanced settings ???
#https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.rayleigh.html#scipy.stats.rayleigh
self.ecc_R = stats.rayleigh()
#https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.expon.html
self.ecc_exp = stats.expon()
## `best-fit' for the Shen&Turner 2008 pdf
self.ecc_ST08_a = ecc_ST08_a ### Put this into the advanced settings ???
self.ecc_ST08_k = ecc_ST08_k ### Put this into the advanced settings ???
#self.ecc_norm = stats.norm
#self.ecc_norm_mean = ##
#self.ecc_norm_sig = ##
#self.ecc_norm.pdf(ecc,loc=self.ecc_norm_mean, scale=self.ecc_norm_sig)
## choices: power-law, Jeffrey's
self.p_prior = p_prior
self.p_gamma = p_gamma
## choices:sin, cos
self.inc_prior = inc_prior
## choices:IMF, PDMF
self.m1_prior = m1_prior
## choices:CMF, IMF, PDMF
self.m2_prior = m2_prior
## choices:gauss
self.para_prior = para_prior
## values necessary to calculate priors
self.para_est = para_est
self.para_err = para_err
self.m1_est = m1_est
self.m1_err = m1_err
self.m2_est = m2_est
self.m2_err = m2_err
def test_rayleigh_random(self, sigma):
"""
测试瑞利分布
"""
randoms = [self.gen_rayleigh_random(sigma) for i in range(self.N)]
print("==========瑞利分布==========\n", stats.rayleigh.fit(randoms), "\n")
t1 = np.linspace(0, 10, 101)
p, t2 = np.histogram(randoms, bins=100, normed=True)
t2 = (t2[:-1] + t2[1:]) / 2
plt.plot(t2, p, "ro-", t1, stats.rayleigh(loc=0, scale=sigma).pdf(t1))
def plot_maxwell(vel, label=None, draw=True):
speed = (vel*vel).sum(1)**0.5
loc, scale = rayleigh.fit(speed, floc=0)
dist = rayleigh(scale=scale)
if draw:
plt.hist(speed, 20, density=True)
x = np.linspace(dist.ppf(0.01), dist.ppf(0.99), 1000)
plt.plot(x, dist.pdf(x), label=label)
if label:
plt.legend()
return kstest(speed, dist.cdf)[0]
def rayleigh_dist(sc):
"""Rayleigh Distribution"""
#mean, variance, skew, kurt = st.rayleigh.stats(moments='mvsk')
x = np.linspace(0,10,100)
#print mean, variance, skew, kurt
for i in range(len(sc)):
rv = st.rayleigh(loc=0,scale=sc[i])
plt.plot(x,rv.pdf(x), linewidth=4, label='$\sigma=%0.1f$' %sc[i])
plt.title('Rayleigh Distribution', fontsize=26)
plt.xlabel('X', fontsize=22)
plt.ylabel('Probability', fontsize=22)
plt.legend()
plt.show()
def compute_prob_of_points(x, y, sma_vec, smi_vec, cent_vec=None):
"""Compute the probability of observing points as far away as (x,y) for
a given ellipse.
For the ellipse described by centroid, semi-major and semi-minor axes
`sma_vec` and `smi_vec`, compute the
probability of observing points at least as far away as x,y in
the direction of that point.
If no cent_vec supplied, it is computed as the centroid of the
input points.
Inputs
---------
x, y
(1d numpy arrays). x and y coordinates of points to fit.
sma_vec
(2 elt numpy array) Vector describing the semi-major axis
smi_vec
(2 elt numpy array) Vector describing the semi-minor axis
cent_vec
(2 elt numpy array) Vector describing centroid of ellipse.
If **None**, is set to the centroid of the input points.
Returns
--------
1d numpy array of the probabilities for each point.
"""
if cent_vec is None:
cent_vec = get_centroid_point(x, y)
assert len(x) == len(y)
assert len(cent_vec) == 2
assert len(sma_vec) == 2
assert len(smi_vec) == 2
xy = np.vstack([x, y]).transpose()
rel_vec = xy - cent_vec
# The covector of a vector **v** is defined here as a vector that
# is parallel to **v**, but has length :math:`= 1/|v|`
# Multiplying a vector by the covector of the semi-major axis
# gives the projected distance of that vector along that axis.
sma_covec = sma_vec / np.linalg.norm(sma_vec)**2
smi_covec = smi_vec / np.linalg.norm(smi_vec)**2
coeff1 = np.dot(rel_vec, sma_covec) # Num sigma along major axis
coeff2 = np.dot(rel_vec, smi_covec) # Num sigma along minor axis
dist_sigma = np.hypot(coeff1, coeff2)
prob = spstats.rayleigh().sf(dist_sigma)
return prob
def __init__(self, scale):
if scale is None:
self.scale = 1.0
else:
self.scale = scale
self.bounds = np.array([0.999, np.inf])
if self.scale < 0:
raise ValueError(
'Invalid parameters in Rayleigh distribution. Scale should be positive.'
)
self.parent = rayleigh(scale=self.scale)
self.mean, self.variance, self.skewness, self.kurtosis = self.parent.stats(
moments='mvsk')
self.x_range_for_pdf = np.linspace(0.0, 8.0 * self.scale,
RECURRENCE_PDF_SAMPLES)
def __init__(self, name, mean, stdv, input_type=None, startpoint=None):
self.dist_type = "ShiftedRayleigh"
if input_type is None:
a = stdv / ((2 - np.pi * 0.5) ** 0.5)
x_zero = mean - stdv * (np.pi / (4 - np.pi)) ** 0.5
else:
a = mean
x_zero = stdv
# use scipy to do the heavy lifting
self.dist_obj = rayleigh(loc=x_zero, scale=a)
super().__init__(
name=name, dist_obj=self.dist_obj, startpoint=startpoint,
)
def __init__(self, scale):
"""
Parameters
----------
scale : float, positive
Scale parameter
"""
assert scale > 0, "scale parameter must be positive"
self.scale = scale
self.sigma = scale
# Scipy backend
self.sp = rayleigh(scale=scale)
# Initialize super
super().__init__(2, scale * 2**0.5)
def test_grm_mml_eap_method(self):
"""Testing the GRM EAP/MML Method."""
np.random.seed(99854)
n_items = 10
n_people = 300
difficulty = stats.norm(0, 1).rvs(n_items * 3).reshape(n_items, -1)
difficulty = np.sort(difficulty, axis=1)
discrimination = stats.rayleigh(loc=0.25, scale=.8).rvs(n_items)
thetas = np.random.randn(n_people)
syn_data = create_synthetic_irt_polytomous(difficulty, discrimination,
thetas)
result = grm_mml_eap(syn_data, {'hyper_quadrature_n': 21})
# Smoke Tests / Regression Tests
expected_difficulty = np.array(
[[-0.68705911, 0.25370937, 0.62872705],
[-1.81331475, -1.52607597, 0.01957819],
[-2.16305964, -0.51648053, 0.20447022],
[-1.51064069, -1.18709807, 1.74368598],
[-2.44714587, -1.01438472, -0.44406173],
[-1.38622596, -0.11417447, 1.14001425],
[-0.92724279, -0.11335446, 1.30273993],
[-0.55972331, -0.28527674, 0.01131112],
[-1.72941028, -0.34732405, 1.17681916],
[-1.73346085, -0.12292641, 0.91797906]])
expected_discrimination = np.array([
1.35572245, 0.77018004, 0.92848851, 1.6339604, 0.79229545,
2.35881697, 0.64452994, 1.86795956, 1.56986454, 1.93426233
])
expected_rayleigh_scale = 0.9161607303681261
np.testing.assert_allclose(result['Difficulty'],
expected_difficulty,
atol=1e-3,
rtol=1e-3)
np.testing.assert_allclose(result['Discrimination'],
expected_discrimination,
atol=1e-3,
rtol=1e-3)
self.assertAlmostEqual(result['Rayleigh_Scale'],
expected_rayleigh_scale, 3)
def Rayleigh(mean=1.):
"""
A Rayleigh distribution function that returns a frozen distribution of the `scipy.stats.rv_continuous <http://http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.stats.rayleigh.html#scipy.stats.rayleigh.html>`_ class.
:param mean: mean value
:type mean: float
:rtype: scipy.stats.rv_continuous instance
>>> import compmod
>>> ray = compmod.distributions.Rayleigh
>>> ray = compmod.distributions.Rayleigh(5.)
>>> ray.rvs(15)
array([ 4.46037568, 4.80288465, 5.37309281, 4.80523501, 5.39211872,
4.50159587, 4.99945365, 4.96324001, 5.48935765, 6.3571905 ,
5.01412849, 4.37768037, 5.99915989, 4.71909481, 5.25259294])
.. plot:: example_code/distributions/rayleigh.py
:include-source:
"""
return stats.rayleigh(scale=mean * (2. / np.pi)**.5)
def Rayleigh(mean = 1):
"""
A Rayleigh distribution function that returns a frozen distribution of the `scipy.stats.rv_continuous <http://http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.stats.rayleigh.html#scipy.stats.rayleigh.html>`_ class.
:param mean: mean value
:type mean: float
:rtype: scipy.stats.rv_continuous instance
>>> import compmod
>>> ray = compmod.distributions.Rayleigh
>>> ray = compmod.distributions.Rayleigh(5.)
>>> ray.rvs(15)
array([ 4.46037568, 4.80288465, 5.37309281, 4.80523501, 5.39211872,
4.50159587, 4.99945365, 4.96324001, 5.48935765, 6.3571905 ,
5.01412849, 4.37768037, 5.99915989, 4.71909481, 5.25259294])
.. plot:: example_code/distributions/rayleigh.py
:include-source:
"""
return stats.rayleigh(mean-1)
class TestUtil:
def test_execute_direct(self):
out,err = util.execute('echo test')
assert out=='test\n' and err==''
def test_execute_env(self):
out,err = util.execute('sh -c "echo $test_for_execute"',env={'test_for_execute':'test'})
assert out=='test\n' and err==''
def test_croak(self):
util.croak('Burp!')
@pytest.mark.parametrize('input,output',
[
([0,-2],[0,-1]),
([-0.5,0.5],[-1,1]),
([1./2.,1./3.],[3,2]),
([2./3.,1./2.,1./3.],[4,3,2]),
])
def test_scale2coprime(self,input,output):
assert np.allclose(util.scale_to_coprime(np.array(input)),
np.array(output).astype(int))
def test_lackofprecision(self):
with pytest.raises(ValueError):
util.scale_to_coprime(np.array([1/333.333,1,1]))
@pytest.mark.parametrize('rv',[stats.rayleigh(),stats.weibull_min(1.2),stats.halfnorm(),stats.pareto(2.62)])
def test_hybridIA(self,rv):
bins = np.linspace(0,10,100000)
centers = (bins[1:]+bins[:-1])/2
N_samples = bins.shape[0]-1000
dist = rv.pdf(centers)
selected = util.hybrid_IA(dist,N_samples)
dist_sampled = np.histogram(centers[selected],bins)[0]/N_samples*np.sum(dist)
assert np.sqrt(((dist - dist_sampled) ** 2).mean()) < .025 and selected.shape[0]==N_samples
def grm_mml_eap(dataset, options=None):
"""Estimate parameters for graded response model.
Estimate the discrimination and difficulty parameters for
a graded response model using a mixed Bayesian / Marginal Maximum
Likelihood algorithm, good for small sample sizes
Args:
dataset: [n_items, n_participants] 2d array of measured responses
options: dictionary with updates to default options
Returns:
results_dictionary:
* Discrimination: (1d array) estimate of item discriminations
* Difficulty: (2d array) estimates of item difficulties by item thresholds
* LatentPDF: (object) contains information about the pdf
* Rayleigh_Scale: (int) Rayleigh scale value of the discrimination prior
* AIC: (dictionary) null model and final model AIC value
* BIC: (dictionary) null model and final model BIC value
Options:
* estimate_distribution: Boolean
* number_of_samples: int >= 5
* max_iteration: int
* distribution: callable
* quadrature_bounds: (float, float)
* quadrature_n: int
* hyper_quadrature_n: int
"""
options = validate_estimation_options(options)
cpr_result = condition_polytomous_response(dataset, trim_ends=False)
responses, item_counts, valid_response_mask = cpr_result
invalid_response_mask = ~valid_response_mask
n_items = responses.shape[0]
# Only use LUT
_integral_func = _solve_integral_equations_LUT
_interp_func = create_beta_LUT((.15, 5.05, 500), (-6, 6, 500), options)
# Quadrature Locations
latent_pdf = LatentPDF(options)
theta = latent_pdf.quadrature_locations
# Compute the values needed for integral equations
integral_counts = list()
for ndx in range(n_items):
temp_output = _solve_for_constants(responses[ndx,
valid_response_mask[ndx]])
integral_counts.append(temp_output)
# Initialize difficulty parameters for estimation
betas = np.full((item_counts.sum(), ), -10000.0)
discrimination = np.ones_like(betas)
cumulative_item_counts = item_counts.cumsum()
start_indices = np.roll(cumulative_item_counts, 1)
start_indices[0] = 0
for ndx in range(n_items):
end_ndx = cumulative_item_counts[ndx]
start_ndx = start_indices[ndx] + 1
betas[start_ndx:end_ndx] = np.linspace(-1, 1, item_counts[ndx] - 1)
betas_roll = np.roll(betas, -1)
betas_roll[cumulative_item_counts - 1] = 10000
# Set invalid index to zero, this allows minimal
# changes for invalid data and it is corrected
# during integration
responses[invalid_response_mask] = 0
# Prior Parameters
ray_scale = 1.0
eap_options = {
'distribution': stats.rayleigh(loc=.25, scale=ray_scale).pdf,
'quadrature_n': options['hyper_quadrature_n'],
'quadrature_bounds': (0.25, 5)
}
prior_pdf = LatentPDF(eap_options)
alpha_evaluation = np.zeros((eap_options['quadrature_n'], ))
# Meta-Prior Parameter
hyper_options = {
'distribution': stats.lognorm(loc=0, s=0.25).pdf,
'quadrature_n': options['hyper_quadrature_n'],
'quadrature_bounds': (0.1, 5)
}
hyper_pdf = LatentPDF(hyper_options)
hyper_evaluation = np.zeros((hyper_options['quadrature_n'], ))
base_hyper = (hyper_pdf.weights *
hyper_pdf.null_distribution).astype('float128')
linear_hyper = base_hyper * hyper_pdf.quadrature_locations
for iteration in range(options['max_iteration']):
previous_discrimination = discrimination.copy()
previous_betas = betas.copy()
previous_betas_roll = betas_roll.copy()
# Quadrature evaluation for values that do not change
# This is done during the outer loop to address rounding errors
partial_int = np.ones((responses.shape[1], theta.size))
for item_ndx in range(n_items):
partial_int *= _graded_partial_integral(
theta, betas, betas_roll, discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
# Estimate the distribution if requested
distribution_x_weight = latent_pdf(partial_int, iteration)
partial_int *= distribution_x_weight
# Update the lookup table if necessary
if (options['estimate_distribution'] and iteration > 0):
new_options = dict(options)
new_options.update({'distribution': latent_pdf.cubic_splines[-1]})
_interp_func = create_beta_LUT((.15, 5.05, 500), (-6, 6, 500),
new_options)
# EAP Discrimination Parameter
discrimination_pdf = stats.rayleigh(loc=0.25, scale=ray_scale).pdf
base_alpha = (prior_pdf.weights * discrimination_pdf(
prior_pdf.quadrature_locations)).astype('float128')
linear_alpha = (base_alpha *
prior_pdf.quadrature_locations).astype('float128')
for item_ndx in range(n_items):
# pylint: disable=cell-var-from-loop
# Indices into linearized difficulty parameters
start_ndx = start_indices[item_ndx]
end_ndx = cumulative_item_counts[item_ndx]
old_values = _graded_partial_integral(
theta, previous_betas, previous_betas_roll,
previous_discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
partial_int /= old_values
def _local_min_func(estimate):
# Solve integrals for diffiulty estimates
new_betas = _integral_func(estimate, integral_counts[item_ndx],
distribution_x_weight, theta,
_interp_func)
betas[start_ndx + 1:end_ndx] = new_betas
betas_roll[start_ndx:end_ndx - 1] = new_betas
discrimination[start_ndx:end_ndx] = estimate
new_values = _graded_partial_integral(
theta, betas, betas_roll, discrimination,
responses[item_ndx], invalid_response_mask[item_ndx])
new_values *= partial_int
otpt = np.sum(new_values, axis=1)
return np.log(otpt.clip(1e-313, np.inf)).sum()
# Mean Discrimination Value
for ndx, disc_location in enumerate(
prior_pdf.quadrature_locations):
alpha_evaluation[ndx] = _local_min_func(disc_location)
alpha_evaluation -= alpha_evaluation.max()
total_probability = np.exp(alpha_evaluation.astype('float128'))
numerator = np.sum(total_probability * linear_alpha)
denominator = np.sum(total_probability * base_alpha)
alpha_eap = numerator / denominator
# Reset the Value the updated discrimination estimation
_local_min_func(alpha_eap.astype('float64'))
new_values = _graded_partial_integral(
theta, betas, betas_roll, discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
partial_int *= new_values
# Compute the Hyper prior mean value
for ndx, scale_value in enumerate(hyper_pdf.quadrature_locations):
temp_distribution = stats.rayleigh(loc=0.25, scale=scale_value).pdf
hyper_evaluation[ndx] = np.log(
temp_distribution(discrimination) + 1e-313).sum()
hyper_evaluation -= hyper_evaluation.max()
hyper_evaluation = np.exp(hyper_evaluation.astype('float128'))
ray_scale = (np.sum(hyper_evaluation * linear_hyper) /
np.sum(hyper_evaluation * base_hyper)).astype('float64')
# Check Termination Criterion
if np.abs(previous_discrimination - discrimination).max() < 1e-3:
break
# Recompute partial int for later calculations
partial_int = np.ones((responses.shape[1], theta.size))
for item_ndx in range(n_items):
partial_int *= _graded_partial_integral(
theta, betas, betas_roll, discrimination, responses[item_ndx],
invalid_response_mask[item_ndx])
# Trim difficulties to conform to standard output
# TODO: look where missing values are and place NAN there instead
# of appending them to the end
output_betas = np.full((n_items, item_counts.max() - 1), np.nan)
for ndx, (start_ndx,
end_ndx) in enumerate(zip(start_indices,
cumulative_item_counts)):
output_betas[ndx, :end_ndx - start_ndx - 1] = betas[start_ndx +
1:end_ndx]
# Compute statistics for final iteration
null_metrics = latent_pdf.compute_metrics(
partial_int, latent_pdf.null_distribution * latent_pdf.weights, 0)
full_metrics = latent_pdf.compute_metrics(partial_int,
distribution_x_weight,
latent_pdf.n_points - 3)
# Ability estimates
eap_abilities = _ability_eap_abstract(partial_int, distribution_x_weight,
theta)
return {
'Discrimination': discrimination[start_indices],
'Difficulty': output_betas,
'Ability': eap_abilities,
'LatentPDF': latent_pdf,
'Rayleigh_Scale': ray_scale,
'AIC': {
'final': full_metrics[0],
'null': null_metrics[0],
'delta': null_metrics[0] - full_metrics[0]
},
'BIC': {
'final': full_metrics[1],
'null': null_metrics[1],
'delta': null_metrics[1] - full_metrics[1]
}
}
for j in range(1,len(gauss_mean)):
ax1.plot(gauss_x,mlab.normpdf(gauss_x, gauss_mean[j], gauss_sigma[1]), linewidth=4, label='$\mu=%d, \sigma^2=%0.1f$' %(gauss_mean[j], gauss_variance[1]))
ax1.set_title('Gaussian Distribution', fontsize=26)
#ax1.set_xlabel('X', fontsize=22)
ax1.set_ylabel('Probability', fontsize=22)
ax1.set_yscale('log')
ax1.legend(loc='best')
# Rayleigh Distribution
rayl_scale = [0.5, 1, 2, 3, 4]
#mean, variance, skew, kurt = st.rayleigh.stats(moments='mvsk')
rayl_x = np.linspace(0,10,100)
#print mean, variance, skew, kurt
for i in range(len(rayl_scale)):
rv = st.rayleigh(loc=0,scale=rayl_scale[i])
ax2.plot(rayl_x,rv.pdf(rayl_x), linewidth=4, label='$\sigma=%0.1f$' %rayl_scale[i])
ax2.set_title('Rayleigh Distribution', fontsize=26)
#ax2.set_xlabel('X', fontsize=22)
ax2.set_ylabel('Probability', fontsize=22)
ax2.set_yscale('log')
ax2.legend(loc='best')
# Gamma Distribution
gamma_shape = [0.5, 1, 2, 3, 5, 7.5, 9]
gamma_scale = [1, 2, 2, 2, 1, 1, 0.5]
gamma_x = np.linspace(0,30,100)
for i in range(len(gamma_scale)):
rv = st.gamma(gamma_shape[i], loc=0, scale=gamma_scale[i])
ax3.plot(rv.pdf(gamma_x), linewidth=4, label='$k=%0.1f, \Theta=%0.1f $' %(gamma_shape[i], gamma_scale[i]))
def main(argv):
# Get and parse the command line arguments
image_loc, target_name = get_arguments(argv)
# Read the input image
img = cv2.imread(image_loc, 0)
# Check if image exists or not
if (img is None):
print ("Cannot open {} image".format(image_loc))
print ("Make sure you provide the correct image path")
sys.exit(2)
# Calculate the input images' histogram
input_hist = cv2.calcHist([img], [0], None, [256], [0,256])
# Normalize the input histogram
total = sum(input_hist)
input_hist /= total
# Calculate the cumulative input histogram
cum_input_hist = []
cum = 0.0
for i in range(len(input_hist)):
cum += input_hist[i][0]
cum_input_hist.append(cum)
# Calculate the variance of the image
input_img_var = np.var(img)
# Calculate the variance of the image square
input_img_sqr_var = np.var(img**2)
# Calculate the target dist for diff dist's
target_dist = []
target_hist = None
if (target_name == "uniform"):
# Import the package of the target distribution
from scipy.stats import uniform
# Create uniform distribution object
unif_dist = uniform(0, 246)
# Calculate the target distribution
for i in range(0, 246):
x = unif_dist.pdf(i)
target_dist.append(x)
for i in range(246, 256):
target_dist.append(0)
# Calculate the target histogram
target_hist = np.ndarray(shape=(256,1))
for i in range(0,256):
target_hist[i][0] = target_dist[i]
elif (target_name == "normal"):
# Import the package of the target distribution
from scipy.stats import norm
# Create standard normal distribution object
norm_dist = norm(0, 1)
# Calculate the target distribution
for i in range(0, 256):
x = norm_dist.pdf(i/42.0 - 3)
target_dist.append(x)
# Calculate the target histogram
target_hist = np.ndarray(shape=(256,1))
for i in range(0,256):
target_hist[i][0] = target_dist[i]
# Normalize the target histogram
total = sum(target_hist)
target_hist /= total
elif (target_name == "rayleigh"):
# Import the package of the target distribution
from scipy.stats import rayleigh
# Create rayleigh distribution object
rayleigh_dist = rayleigh(0.5)
# Calculate the target distribution
for i in range(0, 256):
x = rayleigh_dist.pdf(i/128.0)
target_dist.append(x)
# Calculate the target histogram
target_hist = np.ndarray(shape=(256,1))
for i in range(0,256):
target_hist[i][0] = target_dist[i]
# Normalize the target histogram
total = sum(target_hist)
target_hist /= total
elif (target_name == "gamma"):
# Import the package of the target distribution
from scipy.stats import gamma
# Create gamma distribution object
gamma_dist = gamma(0.5, 0, 1.0)
# Calculate the target distribution
target_dist.append(1)
for i in range(1, 256):
x = gamma_dist.pdf(i/256.0)
target_dist.append(x)
# Calculate the target histogram
target_hist = np.ndarray(shape=(256,1))
for i in range(0,256):
target_hist[i][0] = target_dist[i]
# Normalize the target histogram
total = sum(target_hist)
target_hist /= total
elif (target_name == "weibull"):
# Import the package of the target distribution
from scipy.stats import weibull_min
# Create weibull distribution object
weibull_dist = weibull_min(c=1.4, scale=input_img_var)
# Calculate the target distribution
for i in range(0, 256):
x = weibull_dist.pdf(i/256.0)
target_dist.append(x)
# Calculate the target histogram
target_hist = np.ndarray(shape=(256,1))
for i in range(0,256):
target_hist[i][0] = target_dist[i]
# Normalize the target histogram
total = sum(target_hist)
target_hist /= total
elif (target_name == "beta1"):
# Import the package of the target distribution
from scipy.stats import beta
# Create beta distribution object
beta_dist = beta(0.5, 0.5)
# Calculate the target distribution
target_dist.append(6)
for i in range(1, 255):
x = beta_dist.pdf(i/256.0)
target_dist.append(x)
target_dist.append(6)
# Calculate the target histogram
target_hist = np.ndarray(shape=(256,1))
for i in range(0,256):
target_hist[i][0] = target_dist[i]
# Normalize the target histogram
total = sum(target_hist)
target_hist /= total
elif (target_name == "beta2"):
# Import the package of the target distribution
from scipy.stats import beta
# Create beta distribution object
beta_dist = beta(5, 1)
# Calculate the target distribution
for i in range(0, 255):
x = beta_dist.pdf(i/256.0)
target_dist.append(x)
target_dist.append(6)
# Calculate the target histogram
target_hist = np.ndarray(shape=(256,1))
for i in range(0,256):
target_hist[i][0] = target_dist[i]
# Normalize the target histogram
total = sum(target_hist)
target_hist /= total
elif (target_name == "lognorm"):
# Import the package of the target distribution
from scipy.stats import lognorm
# Create lognorm distribution object
lognorm_dist = lognorm(1)
# Calculate the target distribution
for i in range(0, 256):
x = lognorm_dist.pdf(i/100.0)
target_dist.append(x)
# Calculate the target histogram
target_hist = np.ndarray(shape=(256,1))
for i in range(0,256):
target_hist[i][0] = target_dist[i]
# Normalize the target histogram
total = sum(target_hist)
target_hist /= total
elif (target_name == "laplace"):
# Import the package of the target distribution
from scipy.stats import laplace
# Create lognorm distribution object
laplace_dist = laplace(4)
# Calculate the target distribution
target_dist.append(0)
for i in range(1, 256):
x = laplace_dist.pdf(i/256.0)
target_dist.append(x)
# Calculate the target histogram
target_hist = np.ndarray(shape=(256,1))
for i in range(0,256):
target_hist[i][0] = target_dist[i]
# Normalize the target histogram
total = sum(target_hist)
target_hist /= total
elif (target_name == "beta3"):
# Import the package of the target distribution
from scipy.stats import beta
# Create beta distribution object
beta_dist = beta(8, 2)
# Calculate the target distribution
for i in range(0, 255):
x = beta_dist.pdf(i/256.0)
target_dist.append(x)
target_dist.append(0)
# Calculate the target histogram
target_hist = np.ndarray(shape=(256,1))
for i in range(0,256):
target_hist[i][0] = target_dist[i]
# Normalize the target histogram
total = sum(target_hist)
target_hist /= total
else: # Image itself is a target distribution case
# Read the image
target_dist = cv2.imread(target_name, 0)
# Check if image is read or not
if (target_dist is None):
print ("{} is not a valid target name (or) image does not exist".format(target_name))
print ("Make sure you give correct target name or correct target image location")
sys.exit(2)
# Create target histogram from the image
target_hist = cv2.calcHist([target_dist], [0], None, [256], [0,256])
# Normalize the target histogram
total = sum(target_hist)
target_hist /= total
# Calculate the cumulative target histogram
cum_target_hist = []
cum = 0.0
for i in range(len(target_hist)):
cum += target_hist[i][0]
cum_target_hist.append(cum)
# Obtain the mapping from the input hist to target hist
lookup = {}
for i in range(len(cum_input_hist)):
min_val = abs(cum_target_hist[0] - cum_input_hist[i])
min_j = 0
for j in range(1, len(cum_target_hist)):
val = abs(cum_target_hist[j] - cum_input_hist[i])
if (val < min_val):
min_val = val
min_j = j
lookup[i] = min_j
# Create the transformed image using the img's pixel values and the lookup table
trans_img = img.copy()
for i in range(img.shape[0]):
for j in range(img.shape[1]):
trans_img[i][j] = lookup[img[i][j]]
# Write the transformed image to a png file
cv2.imwrite('images/transformed.png', trans_img)
# Plot the input image and the target image in one plot
input_img_resized = cv2.resize(img, (0,0), None, 0.25, 0.25)
trans_img_resized = cv2.resize(trans_img, (0,0), None, 0.25, 0.25)
numpy_horiz = np.hstack((input_img_resized, trans_img_resized))
cv2.imshow('Input image ------------------------ Trans image', numpy_horiz)
cv2.waitKey(25)
# Calculate the transformed image's histogram
trans_hist = cv2.calcHist([trans_img], [0], None, [256], [0,256])
# Normalize the transformed image's histogram
total = sum(trans_hist)
trans_hist /= total
# Convert cum_input_hist to matrix for plotting
cum_input_hist_matrix = np.ndarray(shape=(256,1))
for i in range(0,256):
cum_input_hist_matrix[i][0] = cum_input_hist[i]
# Calculate the cum transformed histogram for plotting
cum_trans_hist = np.ndarray(shape=(256,1))
cum = 0.0
for i in range(0,256):
cum += trans_hist[i][0]
cum_trans_hist[i][0] = cum
# Convert cum_target_hist to matrix for plotting
cum_target_hist_matrix = np.ndarray(shape=(256,1))
for i in range(0,256):
cum_target_hist_matrix[i][0] = cum_target_hist[i]
plt.subplot(2, 3, 1)
plt.title('Original hist')
plt.plot(input_hist)
plt.subplot(2, 3, 2)
plt.title('Original cdf')
plt.plot(cum_input_hist_matrix)
plt.subplot(2, 3, 3)
plt.title('Target pdf')
plt.plot(target_hist)
plt.subplot(2, 3, 4)
plt.title('Transformed hist')
plt.plot(trans_hist)
plt.subplot(2, 3, 5)
plt.title('Transformed cdf')
plt.plot(cum_trans_hist)
plt.subplot(2, 3, 6)
plt.title('Target cdf')
plt.plot(cum_target_hist_matrix)
plt.show()
# noise parameters
mean_noise = 0
std_noise = np.sqrt(1 / (2 * R * snr))
#print("\nVariance: ", std_noise)
noise = mean_noise + std_noise * np.random.randn(
size_test_data, M) # randn => standard normal distribution
################################################################################
################################################################################
# HEY JOHN, HERE'S WHERE I NEED YOUR HELP
# fading
# https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.rayleigh.html
#fading = ss.rayleigh().pdf(ss.rayleigh.rvs(size=M))
fading = ss.rayleigh().pdf(
np.linspace(ss.rayleigh.ppf(0.01), ss.rayleigh.ppf(0.99), M))
fading = fading * 0.631 # correct for skewness
signal = signal - fading
################################################################################
################################################################################
# construct signal
signal = signal + noise
signal = np.round(signal)
# compute errors
errors = np.not_equal(signal, test_data) # boolean test
ber[i] = np.mean(errors)
def test_Exponential_to_Rayleigh(self):
X = RV(Exponential(rate=5))
sims = sqrt(X).sim(Nsim)
cdf = stats.rayleigh(scale=1 / sqrt(2 * 5)).cdf
pval = stats.kstest(sims, cdf).pvalue
self.assertTrue(pval > .01)
def rayleigh():
return stats.rayleigh()
def make_rayleigh_rand_var_of_abs_fft_noise(squared_energy_of_window, variance_of_noise_in_time_domain):
rayleigh_scale_parameter_abs_fft_noise = calc_rayleigh_scale_parameter_abs_fft_noise(
squared_energy_of_window, variance_of_noise_in_time_domain
)
return rayleigh(loc=0.0, scale=rayleigh_scale_parameter_abs_fft_noise)
def run():
telescope_area = np.pi * (1 * u.m)**2
total_efficiency = 0.7
observation_cadence = 5 * u.s
observation_duration = 2 * u.hr
telescope_random_seed = 99
approximate_num_flares = 60
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Create an observation target:
spectral_band = eep.simulate.spectral.JohnsonPhotometricBand('U')
emission_type = eep.simulate.spectral.SpectralEmitter(spectral_band,
magnitude=16)
star_radius = 1. * u.R_sun
star_rotation_rate = 2 * pi_u / observation_duration # Spin quickly for demo purposes
MyStar = eep.simulate.Star(radius=star_radius,
spectral_type=emission_type,
rotation_rate=star_rotation_rate,
limb=eep.simulate.Limb(
'nonlinear', coeffs=[0.5, 0.1, 0.1, -0.1]),
name="My Star",
point_color='saddlebrown')
MyStar.set_view_from_earth(0 * u.deg, 90 * u.deg)
# eep.visualize.render_3d_planetary_system(MyStar)
# ============================================================= #
# Delta-function-like region centered on equator:
long_1 = pi_u
lat_1 = pi_u / 2
region_1 = eep.simulate.active_regions.Region(long_1, lat_1)
region_1_name = 'DelFlares Reg1'
# Approx. max flare intensity:
max_intensity = MyStar.get_flux()
min_intensity = max_intensity / 10
# To explicitly specify units, use a tuple of (pdf, unit):
delta_flare_intensities = ([min_intensity,
max_intensity], max_intensity.unit)
MyDeltaFlareActivity = eep.simulate.active_regions.FlareActivity(
eep.simulate.flares.DeltaFlare,
intensity_pdf=delta_flare_intensities,
label=region_1_name)
ActiveRegion1 = eep.simulate.active_regions.ActiveRegion(
flare_activity=MyDeltaFlareActivity,
occurrence_freq_pdf=approximate_num_flares / 2 / observation_duration,
region=region_1)
MyStar.add_active_regions(ActiveRegion1)
# ============================================================= #
MyTelescope = eep.simulate.Telescope(collection_area=telescope_area,
efficiency=total_efficiency,
cadence=observation_cadence,
observation_target=MyStar,
random_seed=telescope_random_seed,
name="My First Telescope")
MyTelescope.prepare_continuous_observational_run(observation_duration,
print_report=True)
MyTelescope.collect_data(save_diagnostic_data=True)
eep.visualize.render_telescope_lightcurve(MyTelescope,
flare_color='orange')
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
print("""
Now we'll create a second active regions on opposite side of the star,
and give it different phenomenology to make it distinct. This active region will have a wider range
of flare locations, so it won't disappear behind the star quite as cleanly.
""")
# Hemispherical region:
min_long_2 = -pi_u / 2
max_long_2 = pi_u / 2
# Center around equator, but do not extend all the way to the poles:
min_lat_2 = pi_u / 12
max_lat_2 = pi_u - min_lat_2
region_2 = eep.simulate.active_regions.Region([min_long_2, max_long_2],
[min_lat_2, max_lat_2])
region_2_name = 'ExpFlares Reg2'
# To allow default units of ph/s-m², do not specify a unit (will throw a warning as a reminder):
exponential_flare_intensities = stats.expon(scale=max_intensity)
MyExpFlareActivity = eep.simulate.active_regions.FlareActivity(
eep.simulate.flares.ParabolicRiseExponentialDecay,
intensity_pdf=exponential_flare_intensities,
onset_pdf=[1, 4] * u.s,
decay_pdf=(stats.rayleigh(scale=10), u.s),
label=region_2_name)
ActiveRegion2 = eep.simulate.active_regions.ActiveRegion(
flare_activity=MyExpFlareActivity,
occurrence_freq_pdf=approximate_num_flares / 2 / observation_duration,
region=region_2)
MyStar.add_active_regions(ActiveRegion2)
# ============================================================= #
# Telescope is already defined and already knows changes in star, just need to re-prepare observations:
MyTelescope.prepare_continuous_observational_run(observation_duration,
print_report=True)
MyTelescope.collect_data(save_diagnostic_data=True)
eep.visualize.render_telescope_lightcurve(MyTelescope,
flare_color={
region_1_name: "orange",
region_2_name: "b"
})
# ============================================================= #
MyTelescope.prepare_continuous_observational_run(observation_duration * 5)
MyTelescope.collect_data(save_diagnostic_data=True)
print("""
Upon close inspection of the lightcurve, you can see the general trend of alternating between
delta-like flares and exponential flares, which matches the star's rotation."""
)
eep.visualize.interactive_lightcurve(MyTelescope._time_domain,
MyTelescope._pure_lightcurve)
# -*- coding: utf-8 -*-
"""
Created on Mon Jan 05 13:24:41 2015
@author: rarossi
"""
import scipy as sp
from scipy import stats
def printppf(model, rv):
print '%s\t%.2f\t%.2f\t%.2f\t%.2f' % (model, rv.ppf(0.9),rv.ppf(0.99),rv.ppf(0.999),rv.ppf(0.9999))
data = sp.loadtxt('data25h.txt',skiprows=1, usecols= (1,))
data -= data.mean()
print 'Model\t90%\t99%\t99.9%\t99.99%'
l, s = stats.rayleigh.fit(data)
ray = stats.rayleigh(scale=s, loc=l)
printppf('Rayleigh', ray)
sp, l, s = stats.weibull_max.fit(data)
wei = stats.weibull_max(scale=s, loc=l, c=sp)
printppf('Weibull', wei)
l, s = stats.gumbel_r.fit(data)
gum = stats.gumbel_r(scale=s, loc=l)
printppf('Gumbel',gum)
# Calculate a few first moments: mean, var, skew, kurt = rayleigh.stats(moments='mvsk') # Display the probability density function (``pdf``): x = np.linspace(rayleigh.ppf(0.01), rayleigh.ppf(0.99), 100) ax.plot(x, rayleigh.pdf(x), 'r-', lw=5, alpha=0.6, label='rayleigh pdf') # Alternatively, the distribution object can be called (as a function) # to fix the shape, location and scale parameters. This returns a "frozen" # RV object holding the given parameters fixed. # Freeze the distribution and display the frozen ``pdf``: rv = rayleigh() ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') # Check accuracy of ``cdf`` and ``ppf``: vals = rayleigh.ppf([0.001, 0.5, 0.999]) np.allclose([0.001, 0.5, 0.999], rayleigh.cdf(vals)) # True # Generate random numbers: r = rayleigh.rvs(size=1000) # And compare the histogram: ax.hist(r, density=True, histtype='stepfilled', alpha=0.2)
class TestUtil:
def test_execute_direct(self):
out,err = util.execute('echo test')
assert out=='test\n' and err==''
def test_execute_env(self):
out,err = util.execute('sh -c "echo $test_for_execute"',env={'test_for_execute':'test'})
assert out=='test\n' and err==''
def test_execute_runtime_error(self):
with pytest.raises(RuntimeError):
util.execute('false')
@pytest.mark.parametrize('input,output',
[
([0,-2],[0,-1]),
([-0.5,0.5],[-1,1]),
([1./2.,1./3.],[3,2]),
([2./3.,1./2.,1./3.],[4,3,2]),
])
def test_scale2coprime(self,input,output):
assert np.allclose(util.scale_to_coprime(np.array(input)),
np.array(output).astype(int))
def test_lackofprecision(self):
with pytest.raises(ValueError):
util.scale_to_coprime(np.array([1/333.333,1,1]))
@pytest.mark.parametrize('rv',[stats.rayleigh(),stats.weibull_min(1.2),stats.halfnorm(),stats.pareto(2.62)])
def test_hybridIA(self,rv):
bins = np.linspace(0,10,100000)
centers = (bins[1:]+bins[:-1])/2
N_samples = bins.shape[0]-1000
dist = rv.pdf(centers)
selected = util.hybrid_IA(dist,N_samples)
dist_sampled = np.histogram(centers[selected],bins)[0]/N_samples*np.sum(dist)
assert np.sqrt(((dist - dist_sampled) ** 2).mean()) < .025 and selected.shape[0]==N_samples
@pytest.mark.parametrize('point,direction,normalize,keepdims,answer',
[
([1,0,0],'z',False,True, [1,0,0]),
([1,0,0],'z',True, False,[1,0]),
([0,1,1],'z',False,True, [0,0.5,0]),
([0,1,1],'y',True, False,[0.41421356,0]),
([1,1,0],'x',False,False,[0.5,0]),
([1,1,1],'y',True, True, [0.3660254, 0,0.3660254]),
])
def test_project_stereographic(self,point,direction,normalize,keepdims,answer):
assert np.allclose(util.project_stereographic(np.array(point),direction=direction,
normalize=normalize,keepdims=keepdims),answer)
@pytest.mark.parametrize('fro,to,mode,answer',
[
((),(1,),'left',(1,)),
((1,),(7,),'right',(1,)),
((1,2),(1,1,2,2),'right',(1,1,2,1)),
((1,2),(1,1,2,2),'left',(1,1,1,2)),
((1,2,3),(1,1,2,3,4),'right',(1,1,2,3,1)),
((10,2),(10,3,2,2,),'right',(10,1,2,1)),
((10,2),(10,3,2,2,),'left',(10,1,1,2)),
((2,2,3),(2,2,2,3,4),'left',(1,2,2,3,1)),
((2,2,3),(2,2,2,3,4),'right',(2,2,1,3,1)),
])
def test_shapeshifter(self,fro,to,mode,answer):
assert util.shapeshifter(fro,to,mode) == answer
@pytest.mark.parametrize('fro,to,mode',
[
((10,3,4),(10,3,2,2),'left'),
((2,3),(10,3,2,2),'right'),
])
def test_invalid_shapeshifter(self,fro,to,mode):
with pytest.raises(ValueError):
util.shapeshifter(fro,to,mode)
@pytest.mark.parametrize('a,b,answer',
[
((),(1,),(1,)),
((1,),(),(1,)),
((1,),(7,),(1,7)),
((2,),(2,2),(2,2)),
((1,2),(2,2),(1,2,2)),
((1,2,3),(2,3,4),(1,2,3,4)),
((1,2,3),(1,2,3),(1,2,3)),
])
def test_shapeblender(self,a,b,answer):
assert util.shapeblender(a,b) == answer
@pytest.mark.parametrize('style',[util.emph,util.deemph,util.warn,util.strikeout])
def test_decorate(self,style):
assert 'DAMASK' in style('DAMASK')
@pytest.mark.parametrize('complete',[True,False])
def test_D3D_base_group(self,tmp_path,complete):
base_group = ''.join(random.choices('DAMASK', k=10))
with h5py.File(tmp_path/'base_group.dream3d','w') as f:
f.create_group(os.path.join(base_group,'_SIMPL_GEOMETRY'))
if complete:
f[os.path.join(base_group,'_SIMPL_GEOMETRY')].create_dataset('SPACING',data=np.ones(3))
if complete:
assert base_group == util.DREAM3D_base_group(tmp_path/'base_group.dream3d')
else:
with pytest.raises(ValueError):
util.DREAM3D_base_group(tmp_path/'base_group.dream3d')
@pytest.mark.parametrize('complete',[True,False])
def test_D3D_cell_data_group(self,tmp_path,complete):
base_group = ''.join(random.choices('DAMASK', k=10))
cell_data_group = ''.join(random.choices('KULeuven', k=10))
cells = np.random.randint(1,50,3)
with h5py.File(tmp_path/'cell_data_group.dream3d','w') as f:
f.create_group(os.path.join(base_group,'_SIMPL_GEOMETRY'))
f[os.path.join(base_group,'_SIMPL_GEOMETRY')].create_dataset('SPACING',data=np.ones(3))
f[os.path.join(base_group,'_SIMPL_GEOMETRY')].create_dataset('DIMENSIONS',data=cells[::-1])
f[base_group].create_group(cell_data_group)
if complete:
f[os.path.join(base_group,cell_data_group)].create_dataset('data',shape=np.append(cells,1))
if complete:
assert cell_data_group == util.DREAM3D_cell_data_group(tmp_path/'cell_data_group.dream3d')
else:
with pytest.raises(ValueError):
util.DREAM3D_cell_data_group(tmp_path/'cell_data_group.dream3d')
@pytest.mark.parametrize('full,reduced',[({}, {}),
({'A':{}}, {}),
({'A':{'B':{}}}, {}),
({'A':{'B':'C'}},)*2,
({'A':{'B':{},'C':'D'}}, {'A':{'C':'D'}})])
def test_prune(self,full,reduced):
assert util.dict_prune(full) == reduced
@pytest.mark.parametrize('full,reduced',[({}, {}),
({'A':{}}, {}),
({'A':'F'}, 'F'),
({'A':{'B':{}}}, {}),
({'A':{'B':'C'}}, 'C'),
({'A':1,'B':2},)*2,
({'A':{'B':'C','D':'E'}}, {'B':'C','D':'E'}),
({'B':'C','D':'E'},)*2,
({'A':{'B':{},'C':'D'}}, {'B':{},'C':'D'})])
def test_flatten(self,full,reduced):
assert util.dict_flatten(full) == reduced
def test_double_Bravais_to_Miller(self):
with pytest.raises(KeyError):
util.Bravais_to_Miller(uvtw=np.ones(4),hkil=np.ones(4))
def test_double_Miller_to_Bravais(self):
with pytest.raises(KeyError):
util.Miller_to_Bravais(uvw=np.ones(4),hkl=np.ones(4))
@pytest.mark.parametrize('vector',np.array([
[1,0,0],
[1,1,0],
[1,1,1],
[1,0,-2],
]))
@pytest.mark.parametrize('kw_Miller,kw_Bravais',[('uvw','uvtw'),('hkl','hkil')])
def test_Miller_Bravais_Miller(self,vector,kw_Miller,kw_Bravais):
assert np.all(vector == util.Bravais_to_Miller(**{kw_Bravais:util.Miller_to_Bravais(**{kw_Miller:vector})}))
@pytest.mark.parametrize('vector',np.array([
[1,0,-1,2],
[1,-1,0,3],
[1,1,-2,-3],
[0,0,0,1],
]))
@pytest.mark.parametrize('kw_Miller,kw_Bravais',[('uvw','uvtw'),('hkl','hkil')])
def test_Bravais_Miller_Bravais(self,vector,kw_Miller,kw_Bravais):
assert np.all(vector == util.Miller_to_Bravais(**{kw_Miller:util.Bravais_to_Miller(**{kw_Bravais:vector})}))
def exp_to_scipy_distribution(self, p: RayleighEP) -> Any:
return ss.rayleigh(scale=np.sqrt(p.chi / 2.0))
plt.xlabel("Datos")
plt.ylabel("Frecuencia de aparición")
plt.show()
"""
5) Con los datos contenidos en datos.csv, encontrar la mejor curva de ajuste y
graficar la curva de ajuste encontrada
"""
#Gráfica todas las curvas.
plt.hist(DATOS, bins=BINS, alpha=0.7, color="lightblue", normed=True)
xt = plt.xticks()[0]
xmin, xmax = 0, max(xt)
lnspc = np.linspace(xmin, xmax, len(DATOS))
c, d = rayleigh.fit(DATOS)
modelo = rayleigh(c, d)
pdf_g = rayleigh.pdf(lnspc, c, d)
plt.plot(lnspc, pdf_g, 'k-', lw=5, alpha=1, color="blue", label='Rayleigh')
e, f = norm.fit(DATOS)
pdf_g = norm.pdf(lnspc, e, f)
plt.plot(lnspc, pdf_g, 'r-', lw=2, alpha=0.5, color="red", label='Normal')
g, h = uniform.fit(DATOS)
pdf_g = uniform.pdf(lnspc, g, h)
plt.plot(lnspc,
pdf_g,
'r-',
lw=2,
alpha=0.5,
color="black",
def debug_sampler_and_plot():
sampler = Basic_Sampler('gpu')
# gamma
output = sampler.gamma(np.ones(1000)*4.5, 5)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0, 100, 100), stats.gamma.pdf(np.linspace(0, 100, 100), 4.5, scale=5))
plt.title('gamma(4.5, 5)')
plt.show()
# standard_gamma
output = sampler.standard_gamma(np.ones(1000)*4.5)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0, 20, 100), stats.gamma.pdf(np.linspace(0, 20, 100), 4.5))
plt.title('standard_gamma(4.5)')
plt.show()
# dirichlet
output = sampler.dirichlet(np.ones(1000)*4.5)
plt.figure()
plt.hist(output, bins=20, density=True)
# x = np.linspace(np.min(output), np.max(output), 100)
# plt.plot(x, stats.dirichlet.pdf(x, alpha=np.ones(100)*4.5))
plt.title('dirichlet(4.5)')
plt.show()
# beta
output = sampler.beta(np.ones(1000)*0.5, 0.5)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0, 1, 100), stats.beta.pdf(np.linspace(0, 1, 100), 0.5, 0.5))
plt.title('beta(0.5, 0.5)')
plt.show()
# beta(2, 5)
output = sampler.beta(np.ones(1000)*2, 5)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0, 1, 100), stats.beta.pdf(np.linspace(0, 1, 100), 2, 5))
plt.title('beta(2, 5)')
plt.show()
# normal
output = sampler.normal(np.ones(1000)*5, np.ones(1000)*2)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(-2, 13, 100), stats.norm.pdf(np.linspace(-2, 13, 100), 5, scale=2))
plt.title('normal(5, 2)')
plt.show()
# standard_normal
output = sampler.standard_normal(1000)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(-3, 3, 100), stats.norm.pdf(np.linspace(-3, 3, 100)))
plt.title('standard_normal()')
plt.show()
# uniform
output = sampler.uniform(np.ones(1000)*(-2), np.ones(1000)*5)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(-3, 6, 100), stats.uniform.pdf(np.linspace(-3, 6, 100), -2, 7))
plt.title('uniform(-2, 5)')
plt.show()
# standard_uniform
output = sampler.standard_uniform(1000)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(-0.3, 1.3, 100), stats.uniform.pdf(np.linspace(-0.3, 1.3, 100)))
plt.title('standard_uniform()')
plt.show()
# binomial
output = sampler.binomial(np.ones(1000)*10, np.ones(1000)*0.5)
plt.figure()
plt.hist(output, bins=np.max(output)-np.min(output), density=True, range=(np.min(output)-0.5, np.max(output)-0.5))
# plt.scatter(np.arange(10), stats.binom._pmf(np.arange(10), 10, 0.5), c='orange', zorder=10)
plt.title('binomial(10, 0.5)')
plt.show()
# negative_binomial
output = sampler.negative_binomial(np.ones(1000)*10, 0.5)
plt.figure()
plt.hist(output, bins=np.max(output)-np.min(output), density=True, range=(np.min(output)-0.5, np.max(output)-0.5))
plt.scatter(np.arange(30), stats.nbinom._pmf(np.arange(30), 10, 0.5), c='orange', zorder=10)
plt.title('negative_binomial(10, 0.5)')
plt.show()
# multinomial
output = sampler.multinomial(5, [0.8, 0.2], 1000)
# output = sampler.multinomial([10]*4, [[0.8, 0.2]]*4, 3)
plt.figure()
plt.hist(output[0], bins=10, density=True)
plt.title('multinomial(5, [0.8, 0.2])')
plt.show()
a = np.array([np.array([[i] * 6 for i in range(6)]).reshape(-1), np.array(list(range(6)) * 6)]).T
output = stats.multinomial(n=5, p=[0.8, 0.2]).pmf(a)
sns.heatmap(output.reshape(6, 6), annot=True)
plt.ylabel('number of the 1 kind(p=0.8)')
plt.xlabel('number of the 2 kind(p=0.2)')
plt.title('stats.multinomial(n=5, p=[0.8, 0.2])')
plt.show()
# poisson
output = sampler.poisson(np.ones(1000)*10)
plt.figure()
plt.hist(output, bins=22, density=True, range=(-0.5, 21.5))
plt.scatter(np.arange(20), stats.poisson.pmf(np.arange(20), 10), c='orange', zorder=10)
plt.title('poisson(10)')
plt.show()
# cauchy
output = sampler.cauchy(np.ones(1000)*1, 0.5)
plt.figure()
plt.hist(output, bins=20, density=True, range=(-5, 7))
plt.plot(np.linspace(-5, 7, 100), stats.cauchy.pdf(np.linspace(-5, 7, 100), 1, 0.5))
plt.title('cauchy(1, 0.5)')
plt.show()
# standard_cauchy
output = sampler.standard_cauchy(1000)
plt.figure()
plt.hist(output, bins=20, density=True, range=(-7, 7))
plt.plot(np.linspace(-7, 7, 100), stats.cauchy.pdf(np.linspace(-7, 7, 100)))
plt.title('standard_cauchy()')
plt.show()
# chisquare
output = sampler.chisquare(np.ones(1000)*10)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0, 30, 100), stats.chi2.pdf(np.linspace(0, 30, 100), 10))
plt.title('chisquare(10)')
plt.show()
# noncentral_chisquare
output = sampler.noncentral_chisquare(np.ones(1000)*10, 5)
plt.figure()
plt.hist(output, bins=20, density=True)
# nocentral_chi2 = scale^2 * (chi2 + 2*loc*chi + df*loc^2)
# E(Z) = nonc + df
# Var(Z) = 2(df+2nonc)
plt.title('noncentral_chisquare(df=10, nonc=5)')
plt.show()
# exponential
lam = 0.5
output = sampler.exponential(np.ones(1000)*lam)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0.01, 4, 100), stats.expon.pdf(np.linspace(0.01, 4, 100), scale=0.5))
plt.title('exponential(0.5)')
plt.show()
# standard_exponential
output = sampler.standard_exponential(1000)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0.01, 8, 100), stats.expon.pdf(np.linspace(0.01, 8, 100)))
plt.title('standard_exponential()')
plt.show()
# f
output = sampler.f(np.ones(1000)*10, 10)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0, 8, 100), stats.f.pdf(np.linspace(0, 8, 100), 10, 10))
plt.title('f(10, 10)')
plt.show()
# noncentral_f
output = sampler.noncentral_f(np.ones(1000)*10, 10, 5)
plt.figure()
plt.hist(output, bins=20, density=True)
# E(F) = (m+nonc)*n / (m*(n-2)), n>2.
# Var(F) = 2*(n/m)**2 * ((m+nonc)**2 + (m+2*nonc)*(n-2)) / ((n-2)**2 * (n-4))
plt.title('noncentral_f(dfnum=10, dfden=10, nonc=5)')
plt.show()
# geometric
output = sampler.geometric(np.ones(1000)*0.1)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.scatter(np.arange(50), stats.geom.pmf(np.arange(50), p=0.1), c='orange', zorder=10)
plt.title('geometric(0.1)')
plt.show()
# gumbel
output = sampler.gumbel(np.ones(1000)*5, np.ones(1000)*2)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0, 20, 100), stats.gumbel_r.pdf(np.linspace(0, 20, 100)+0.01, 5, scale=2))
plt.title('gumbel(5, 2)')
plt.show()
np.random.gumbel()
# hypergeometric
output = sampler.hypergeometric(np.ones(1000)*5, 10, 10)
plt.figure()
plt.hist(output, bins=np.max(output)-np.min(output), density=True, range=(np.min(output)+0.5, np.max(output)+0.5))
plt.scatter(np.arange(10), stats.hypergeom(15, 5, 10).pmf(np.arange(10)), c='orange', zorder=10) # hypergeom(M, n, N), total, I, tiems
plt.title('hypergeometric(5, 10, 10)')
plt.show()
# laplace
output = sampler.laplace(np.ones(1000)*5, np.ones(1000)*2)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(-10, 20, 100), stats.laplace.pdf(np.linspace(-10, 20, 100), 5, scale=2))
plt.title('laplace(5, 2)')
plt.show()
# logistic
output = sampler.logistic(np.ones(1000)*5, np.ones(1000)*2)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(-10, 20, 100), stats.logistic.pdf(np.linspace(-10, 20, 100), 5, scale=2))
plt.title('logistic(5, 2)')
plt.show()
# power
output = sampler.power(np.ones(1000)*0.5)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0, 1.5, 100), stats.powerlaw.pdf(np.linspace(0, 1.5, 100), 0.5))
plt.title('power(0.5)')
plt.show()
# zipf
output = sampler.zipf(np.ones(1000)*1.1)
counter = Counter(output)
filter = np.array([[key, counter[key]] for key in counter.keys() if key < 50])
plt.figure()
plt.scatter(filter[:, 0], filter[:, 1] / 1000)
plt.plot(np.arange(1, 50), stats.zipf(1.1).pmf(np.arange(1, 50)))
plt.title('zipf(1.1)')
plt.show()
# pareto
output = sampler.pareto(np.ones(1000) * 2, np.ones(1000) * 5)
plt.figure()
count, bins, _ = plt.hist(output, bins=50, density=True, range=(np.min(output), 100))
a, m = 2., 5. # shape and mode
fit = a * m ** a / bins ** (a + 1)
plt.plot(bins, max(count) * fit / max(fit), linewidth=2, color='r')
plt.title('pareto(2, 5)')
plt.show()
# rayleigh
output = sampler.rayleigh(np.ones(1000)*2.0)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0, 8, 100), stats.rayleigh(scale=2).pdf(np.linspace(0, 8, 100)))
plt.title('rayleigh(2)')
plt.show()
# t
output = sampler.t(np.ones(1000)*2.0)
plt.figure()
plt.hist(output, bins=20, density=True, range=(-6, 6))
plt.plot(np.linspace(-6, 6, 100), stats.t(2).pdf(np.linspace(-6, 6, 100)))
plt.title('t(2)')
plt.show()
# triangular
output = sampler.triangular(np.ones(1000)*0.0, 0.3, 1)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0, 1, 100), stats.triang.pdf(np.linspace(0, 1, 100), 0.3))
plt.title('triangular(0, 0.3, 1)')
plt.show()
# weibull
output = sampler.weibull(np.ones(1000)*4.5, 5)
plt.figure()
plt.hist(output, bins=20, density=True)
plt.plot(np.linspace(0, 10, 100), stats.weibull_min.pdf(np.linspace(0, 10, 100), 4.5, scale=5))
plt.title('weibull(4.5, 5)')
plt.show()
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as ss
'''
r = np.random.rayleigh(0.05, (100,))
print(r)
'''
x = []
t = ss.rayleigh().pdf(
np.linspace(ss.rayleigh.ppf(0.01), ss.rayleigh.ppf(0.99), 100))
print(t)
print(t.shape)
sign = np.random.randint(0, 2, 100)
for i in range(len(sign)):
if sign[i] == 0:
sign[i] = -1
print(sign)
w = np.multiply(sign, t)
print(w)
potentialC = np.array( [0.1, 0.5, 1, 2, 3, 3.5] )
potentialCprime = np.linspace( 2.5, 3.55, 20)
estimates = np.zeros_like( potentialCprime)
for i,c in enumerate(potentialCprime):
#sampling_dist = stats.norm( loc = c, scale= 5 )
sampling_dist = stats.gamma(1, loc=Q )
target_c = lambda x: target(x,c)
mci = q2.MCIntegrator( target_c, interval =interval, b_antithetic = False, sampling_dist = sampling_dist, N=100000, verbose= False )
estimates[i] = mci.estimate()
#3.0526315789473681 is about best
c_opt = 3.0526
def rayleigh(u):
return 2*u*np.exp(-u**2)
def target(u):
return ( u > Q)*rayleigh(u)/rayleigh(u-c_opt)
sampling_dist = stats.rayleigh( loc = c_opt, scale=1./np.sqrt(2))
mci = q2.MCIntegrator( target, interval =interval, b_antithetic = False, sampling_dist = sampling_dist, N=100000, verbose= False )
print mci.estimate()
# estimate: 1.13859704116e-06
def all_dists():
# dists param were taken from scipy.stats official
# documentaion examples
# Total - 89
return {
"alpha":
stats.alpha(a=3.57, loc=0.0, scale=1.0),
"anglit":
stats.anglit(loc=0.0, scale=1.0),
"arcsine":
stats.arcsine(loc=0.0, scale=1.0),
"beta":
stats.beta(a=2.31, b=0.627, loc=0.0, scale=1.0),
"betaprime":
stats.betaprime(a=5, b=6, loc=0.0, scale=1.0),
"bradford":
stats.bradford(c=0.299, loc=0.0, scale=1.0),
"burr":
stats.burr(c=10.5, d=4.3, loc=0.0, scale=1.0),
"cauchy":
stats.cauchy(loc=0.0, scale=1.0),
"chi":
stats.chi(df=78, loc=0.0, scale=1.0),
"chi2":
stats.chi2(df=55, loc=0.0, scale=1.0),
"cosine":
stats.cosine(loc=0.0, scale=1.0),
"dgamma":
stats.dgamma(a=1.1, loc=0.0, scale=1.0),
"dweibull":
stats.dweibull(c=2.07, loc=0.0, scale=1.0),
"erlang":
stats.erlang(a=2, loc=0.0, scale=1.0),
"expon":
stats.expon(loc=0.0, scale=1.0),
"exponnorm":
stats.exponnorm(K=1.5, loc=0.0, scale=1.0),
"exponweib":
stats.exponweib(a=2.89, c=1.95, loc=0.0, scale=1.0),
"exponpow":
stats.exponpow(b=2.7, loc=0.0, scale=1.0),
"f":
stats.f(dfn=29, dfd=18, loc=0.0, scale=1.0),
"fatiguelife":
stats.fatiguelife(c=29, loc=0.0, scale=1.0),
"fisk":
stats.fisk(c=3.09, loc=0.0, scale=1.0),
"foldcauchy":
stats.foldcauchy(c=4.72, loc=0.0, scale=1.0),
"foldnorm":
stats.foldnorm(c=1.95, loc=0.0, scale=1.0),
# "frechet_r": stats.frechet_r(c=1.89, loc=0.0, scale=1.0),
# "frechet_l": stats.frechet_l(c=3.63, loc=0.0, scale=1.0),
"genlogistic":
stats.genlogistic(c=0.412, loc=0.0, scale=1.0),
"genpareto":
stats.genpareto(c=0.1, loc=0.0, scale=1.0),
"gennorm":
stats.gennorm(beta=1.3, loc=0.0, scale=1.0),
"genexpon":
stats.genexpon(a=9.13, b=16.2, c=3.28, loc=0.0, scale=1.0),
"genextreme":
stats.genextreme(c=-0.1, loc=0.0, scale=1.0),
"gausshyper":
stats.gausshyper(a=13.8, b=3.12, c=2.51, z=5.18, loc=0.0, scale=1.0),
"gamma":
stats.gamma(a=1.99, loc=0.0, scale=1.0),
"gengamma":
stats.gengamma(a=4.42, c=-3.12, loc=0.0, scale=1.0),
"genhalflogistic":
stats.genhalflogistic(c=0.773, loc=0.0, scale=1.0),
"gilbrat":
stats.gilbrat(loc=0.0, scale=1.0),
"gompertz":
stats.gompertz(c=0.947, loc=0.0, scale=1.0),
"gumbel_r":
stats.gumbel_r(loc=0.0, scale=1.0),
"gumbel_l":
stats.gumbel_l(loc=0.0, scale=1.0),
"halfcauchy":
stats.halfcauchy(loc=0.0, scale=1.0),
"halflogistic":
stats.halflogistic(loc=0.0, scale=1.0),
"halfnorm":
stats.halfnorm(loc=0.0, scale=1.0),
"halfgennorm":
stats.halfgennorm(beta=0.675, loc=0.0, scale=1.0),
"hypsecant":
stats.hypsecant(loc=0.0, scale=1.0),
"invgamma":
stats.invgamma(a=4.07, loc=0.0, scale=1.0),
"invgauss":
stats.invgauss(mu=0.145, loc=0.0, scale=1.0),
"invweibull":
stats.invweibull(c=10.6, loc=0.0, scale=1.0),
"johnsonsb":
stats.johnsonsb(a=4.32, b=3.18, loc=0.0, scale=1.0),
"johnsonsu":
stats.johnsonsu(a=2.55, b=2.25, loc=0.0, scale=1.0),
"ksone":
stats.ksone(n=1e03, loc=0.0, scale=1.0),
"kstwobign":
stats.kstwobign(loc=0.0, scale=1.0),
"laplace":
stats.laplace(loc=0.0, scale=1.0),
"levy":
stats.levy(loc=0.0, scale=1.0),
"levy_l":
stats.levy_l(loc=0.0, scale=1.0),
"levy_stable":
stats.levy_stable(alpha=0.357, beta=-0.675, loc=0.0, scale=1.0),
"logistic":
stats.logistic(loc=0.0, scale=1.0),
"loggamma":
stats.loggamma(c=0.414, loc=0.0, scale=1.0),
"loglaplace":
stats.loglaplace(c=3.25, loc=0.0, scale=1.0),
"lognorm":
stats.lognorm(s=0.954, loc=0.0, scale=1.0),
"lomax":
stats.lomax(c=1.88, loc=0.0, scale=1.0),
"maxwell":
stats.maxwell(loc=0.0, scale=1.0),
"mielke":
stats.mielke(k=10.4, s=3.6, loc=0.0, scale=1.0),
"nakagami":
stats.nakagami(nu=4.97, loc=0.0, scale=1.0),
"ncx2":
stats.ncx2(df=21, nc=1.06, loc=0.0, scale=1.0),
"ncf":
stats.ncf(dfn=27, dfd=27, nc=0.416, loc=0.0, scale=1.0),
"nct":
stats.nct(df=14, nc=0.24, loc=0.0, scale=1.0),
"norm":
stats.norm(loc=0.0, scale=1.0),
"pareto":
stats.pareto(b=2.62, loc=0.0, scale=1.0),
"pearson3":
stats.pearson3(skew=0.1, loc=0.0, scale=1.0),
"powerlaw":
stats.powerlaw(a=1.66, loc=0.0, scale=1.0),
"powerlognorm":
stats.powerlognorm(c=2.14, s=0.446, loc=0.0, scale=1.0),
"powernorm":
stats.powernorm(c=4.45, loc=0.0, scale=1.0),
"rdist":
stats.rdist(c=0.9, loc=0.0, scale=1.0),
"reciprocal":
stats.reciprocal(a=0.00623, b=1.01, loc=0.0, scale=1.0),
"rayleigh":
stats.rayleigh(loc=0.0, scale=1.0),
"rice":
stats.rice(b=0.775, loc=0.0, scale=1.0),
"recipinvgauss":
stats.recipinvgauss(mu=0.63, loc=0.0, scale=1.0),
"semicircular":
stats.semicircular(loc=0.0, scale=1.0),
"t":
stats.t(df=2.74, loc=0.0, scale=1.0),
"triang":
stats.triang(c=0.158, loc=0.0, scale=1.0),
"truncexpon":
stats.truncexpon(b=4.69, loc=0.0, scale=1.0),
"truncnorm":
stats.truncnorm(a=0.1, b=2, loc=0.0, scale=1.0),
"tukeylambda":
stats.tukeylambda(lam=3.13, loc=0.0, scale=1.0),
"uniform":
stats.uniform(loc=0.0, scale=1.0),
"vonmises":
stats.vonmises(kappa=3.99, loc=0.0, scale=1.0),
"vonmises_line":
stats.vonmises_line(kappa=3.99, loc=0.0, scale=1.0),
"wald":
stats.wald(loc=0.0, scale=1.0),
"weibull_min":
stats.weibull_min(c=1.79, loc=0.0, scale=1.0),
"weibull_max":
stats.weibull_max(c=2.87, loc=0.0, scale=1.0),
"wrapcauchy":
stats.wrapcauchy(c=0.0311, loc=0.0, scale=1.0),
}
print(res)
# Crear histograma de Y. RESPUESTA 4
a, bins, c = plt.hist(res, 200, density = 1, facecolor='blue', alpha=0.5)
plt.xlabel('Magnitud')
plt.ylabel('Frecuencia')
plt.grid(True)
plt.title(r'Histograma de mediciones de una variable fisica')
plt.savefig('res4.png')
# RESPUESTA 5
(mu, sigma) = stats.rayleigh.fit(res)
print("mu: ", mu)
print("sigma: ", sigma)
rayleigh = stats.rayleigh(mu, sigma)
print("rayleigh: ", rayleigh)
y = stats.rayleigh.pdf(bins, mu, sigma)
plt.plot(bins, y)
cdf = stats.rayleigh.cdf(bins, mu, sigma)
plt.savefig('res5.png')
# Respuesta 6. Probabilidad en el intervalo [18, 68]
print("La probabilidad en el intervalo [18, 68] es: ", rayleigh.cdf(68) - rayleigh.cdf(18))
contrast = 0
for i in range(0, len(res)):
if res[i] <= 68 and res[i] >= 18:
contrast += 1
contraste = float(contrast)/len(res)
def Threshold_finder(data,
max_population=3,
min_population_size=0.2,
confidence_interval=0.90,
verbose=False):
import warnings
warnings.filterwarnings("ignore")
'''
data: 1D data array with count numbers
max_population: Define the maximal number of populations exist in sample datasets
min_population_size: The smallest population should have at least 20% population
confidence_interval: if unimodel was used, select the confidence interval for lower bound; 0.90 = 5% confidence one tail test
'''
best_population = np.inf
best_loglike = -np.inf
best_mdoel = None
model_kind = 'Gaussian' # Set Gaussian to be the default model type
for n_components in [
n + 1 for n in list(reversed(np.arange(max_population)))
]:
BGM = BayesianGaussianMixture(n_components=n_components,
verbose=0).fit(data)
# Proceed only if the model can converge
if BGM.converged_:
if verbose:
print('%s populations converged' % str(n_components))
dict_wp = dict() # store weighted probability for each population
for p in np.arange(n_components):
para = norm.fit(
mask_list(data, BGM.predict(data),
p)) # fit gaussian model to population p
dict_wp[p] = norm(para[0], para[1]).pdf(data) * BGM.weights_[p]
# Compute log likelyhood of prediction
# wp[0] = norm.pdf(data[i])*weight[0], wp[1] = norm.pdf(data[i])*weight[1] ...
# log(wp[0]+wp[1]+...) gives total log likelyhood
loglike = sum([
np.log(sum([dict_wp[p][i] for p in np.arange(n_components)]))
for i in np.arange(len(data))
])[0]
if loglike > best_loglike and min(
BGM.weights_) > min_population_size: # minimal
best_loglike = loglike
best_population = n_components
best_mdoel = BGM
if verbose:
print('%s model with %s population has log likelyhood of %s ' %
(model_kind, n_components, loglike))
else:
if verbose:
print('%s populations not converged' % str(n_components))
if n_components == 1: # A gaussian model may not best fit one distribution; Other models should also being tested to decide if better 1 model fit exist
para = rayleigh.fit(data)
loglike = sum(np.log(rayleigh(para[0], para[1]).pdf(data)))[0]
if loglike > best_loglike:
best_loglike = loglike
best_population = 1
best_mdoel = rayleigh(para[0], para[1])
model_kind = 'Rayleigh'
if verbose:
print(
'%s model with %s population has log likelyhood of %s '
% (model_kind, n_components, loglike))
if best_mdoel == None: # nither Gaussian nor Rayleight could fit the data
para = chi2.fit(data)
loglike = sum(np.log(chi2(para[0], para[1], para[2]).pdf(data)))[0]
if loglike > best_loglike:
best_loglike = loglike
best_population = 1
best_mdoel = chi2(para[0], para[1], para[2])
model_kind = 'Chi-square'
if verbose:
print('%s model with %s population has log likelyhood of %s ' %
(model_kind, n_components, loglike))
if best_population > 1:
p = list(best_mdoel.means_).index(
min(best_mdoel.means_
)) # Get the population id that represent negatives
threshold = max(mask_list(data, best_mdoel.predict(data), p))[0]
else:
if model_kind == 'Rayleigh' or model_kind == 'Chi-square':
threshold = min(1,
abs(best_mdoel.interval(confidence_interval)[0]))
else:
para = norm.fit(data)
threshold = min(
1,
abs(
norm(data, para[0],
para[1]).interval(confidence_interval)[0]))
print(
'Best model with %s distribution has %s populations with threshold at %s'
% (model_kind, best_population, threshold))
return threshold, model_kind, best_mdoel, best_population
