def peak(cls, maxcps, datapoints, dwelltime, skew=0, sigma=3, location=0):
location = 0
scale = 1
alpha = skew
# delta = alpha / np.sqrt(1+alpha**2)
# uz = np.sqrt(2/np.pi) * delta
# sigmaz = np.sqrt(1.0-uz**2.0)
# gamma = (4-np.pi)/2 * (delta*np.sqrt(2/np.pi))**3/(1-2*delta**2/np.pi)**(3/2)
# moa = uz - (gamma * sigmaz / 2) - (np.sign(alpha))*np.exp(-2*np.pi/np.abs(alpha))
# mode = location + scale * moa
# _norm_ = skewnorm.pdf(x=mode, a=alpha, loc=location, scale=scale) # 標準正規分布の高さ
times = np.linspace(-sigma, sigma, datapoints)
_refpeak_ = skewnorm.pdf(x=times, a=alpha, loc=0, scale=scale)
# _refpeak_ = [skewnorm.pdf(x = time, a=alpha, loc=0, scale=scale) for time in times]
_norm_ = np.max(_refpeak_)
maxindex = np.argmax(_refpeak_)
maxtime = times[maxindex]
# refpeak = np.array(_refpeak_) * maxcps / _norm_
# refpeak = np.array([skewnorm.pdf(x=time, a=alpha, loc= location - maxtime, scale=scale) * maxcps / _norm_ for time in times])
#refpeak = np.array(skewnorm.pdf(x=times, a=alpha, loc= location - maxtime, scale=scale) * maxcps / _norm_ )
refpeak = skewnorm.pdf(
x=times, a=alpha, loc=location - maxtime,
scale=scale) * maxcps / _norm_
# print('maxindex:', maxindex)
# print('maxpos:', maxtime)
# samplepeak = np.array([np.random.poisson(peak * dwelltime / 1000) * 1000 / dwelltime for peak in refpeak])
# return times, refpeak, samplepeak
return refpeak
def fig4(name, func, eps):
"""Makes figure 4.
Args:
name (str): Descriptive name of the model. Posterior samples, statistics, and
figures are generated and saved in a subdirectory with this name.
func (:obj:`<class 'function'>): Function for model construction. Should
return a formatted copy of the data.
eps (bool): If True, saves the figures to the manuscript subdirectory in .eps
format.
"""
with pm.Model() as m:
fit_model(name, func)
trace = pm.load_trace(name)
params = sorted(
[p.name for p in m.deterministics if "Lambda" in p.name])
set_fig_defaults()
rcParams["figure.figsize"] = (3, 3 * 2)
fig, axes = plt.subplots(5, 1, constrained_layout=True)
for p, ax in zip(params, axes):
vals, bins, _ = ax.hist(trace[p],
bins=50,
density=True,
histtype="step",
color="lightgray")
ax.set_xlabel(p)
if ax == axes[0]:
ax.set_ylabel("Posterior density")
start, stop = pm.stats.hpd(trace[p])
for n, l, r in zip(vals, bins, bins[1:]):
if l > start:
if r < stop:
ax.fill_between([l, r], 0, [n, n], color="lightgray")
elif l < stop < r:
ax.fill_between([l, stop], 0, [n, n], color="lightgray")
elif l < start < r:
ax.fill_between([start, r], 0, [n, n], color="lightgray")
x = np.linspace(min([bins[0], 0]), max([0, bins[-1]]))
theta = skewnorm.fit(trace[p])
ax.plot(x, skewnorm.pdf(x, *theta), "k", label="Normal approx.")
ax.plot(x, norm.pdf(x), "k--", label="Prior")
ax.plot([0, 0], [skewnorm.pdf(0, *theta), norm.pdf(0)], "ko")
fig.savefig(f"{name}/fig4.png")
if eps is True:
fig.savefig("manuscript/fig4.eps")
def _random_skewed_norm(n):
"""Generate a random skewed normal distribution.
This function will construct & return a specified number of skewed normal
distributions using scipy's stats.skewnorm function.
Arguments:
n: Number of distributions to return.
Returns:
distributions: A nx100 array where each row is a separate distribution.
"""
from scipy.stats import skewnorm
# The range of the distributions
x_values = np.linspace(-6.0, 6.0, 100)
# Generate an array of `n` distributions
distributions = np.array([
skewnorm.pdf(
# The x values
x_values,
# How much to skew the distribution by
2.5 - (np.random.rand() * 5),
# How much to scale the distribution by
scale=np.random.rand() * 3) for _ in range(n)
])
# Return the distributions
return distributions
def gen_bets(self, total_dice, bet_history, last_bet=None, num_bets=30):
if last_bet:
bets = set()
i = 0
probs = skewnorm.pdf(range(last_bet.num_of_dice, total_dice + 1),
5, .5, 4)
probs = probs / sum(probs)
dice_probs = [1 / 5 for _ in range(5)]
for die in bet_history.keys():
dice_probs[i - 2] += bet_history[die] / 100
dice_probs = [x / sum(dice_probs) for x in dice_probs]
while len(bets) != num_bets and i < 150:
die_value = int(
np.random.choice(np.arange(2, 7), 1, p=dice_probs)[0])
die_amount = int(
np.random.choice(np.arange(last_bet.num_of_dice,
total_dice + 1),
1,
p=probs)[0])
bet = Bet(die_value, die_amount)
if bet.verify_bet(total_dice, last_bet, verbose=False):
bets.add(bet)
i += 1
return list(bets)
return [Bet(x, y) for x in range(2, 7) for y in range(1, 4)]
def compare_hist_to_norm_ax(x, data, bins=25):
mu, std = scipy.stats.norm.fit(data)
ax[x].hist(data,
bins=bins,
density=True,
alpha=0.6,
color='purple',
label="Données")
# Plot le PDF.
xmin, xmax = plt.xlim()
X = np.linspace(xmin, xmax)
ax[x].plot(X,
scipy.stats.norm.pdf(X, mu, std),
label="Normal Distribution")
ax[x].plot(X,
skewnorm.pdf(X, *skewnorm.fit(data)),
color='black',
label="Skewed Normal Distribution")
mu, std = scipy.stats.norm.fit(data)
sk = scipy.stats.skew(data)
title2 = "Moments mu: {}, sig: {}, sk: {}".format(round(mu, 4),
round(std, 4),
round(sk, 4))
ax[x].ylabel("Fréquence", rotation=90)
ax[x].title(title2)
ax[x].legend()
pass
def loss_func(params, data_stimuli, data_response, Type=None):
# Negative Log-likelihood function for directional tuning curves??
return -np.log(
np.prod(
skewnorm.pdf(
data_stimuli, a=params[0], loc=params[1], scale=params[2])))
def skewnorm_eval(s1, s2, xi_popts, ome_popts, alp_popts):
"""
skewnorm_eval
Evaluates probability of S1 and S2 events
inputs: mass of WIMP, number of events
"""
xi = FUNC_EPS(s1, *xi_popts)
omega = FUNC_OME(s1, *ome_popts)
alpha = FUNC_ALP(s1, *alp_popts)
return skewnorm.pdf(s2, alpha, loc=xi, scale=omega)
def mixturemodel_skew(params, x):
"""Mixture of two skew normal distributions.
Parameters
----------
params : list or ndarray
List of parameters (expect 2x3).
x : float or ndarray
Values to calculate the model.
Returns
-------
model : float or ndarray
Mixture model evaluated at x.
"""
a, mua, sga, askew = params[:4]
b, mub, sgb, bskew = params[4:]
return a*skewnorm.pdf(x, askew, loc=mua, scale=sga) + \
b*skewnorm.pdf(x, bskew, loc=mub, scale=sgb)
def get_sample_by_params(self, name: str, params: np.ndarray):
fractions = params[-self.n_components:] / np.sum(params[-self.n_components:])
distributions = np.array([skewnorm.pdf(self.classes_φ, *params[i*3:(i+1)*3]) * self.interval_φ for i in range(self.n_components)])
mixed = (fractions.reshape((1, -1)) @ distributions).reshape((-1))
mixed += np.random.random(mixed.shape) * 10 ** (-self.noise)
mixed = np.round(mixed, self.precision)
parameter = self.get_generate_parameter(params)
sample = ArtificialSample(name, self.classes_μm, self.classes_φ,
mixed, distributions, fractions, parameter)
return sample
def get_samples_from_percentiles(val,
ehi,
elo,
Nsamp=1e3,
add_p5_p95=True,
pltt=False):
'''Given the 16, 50, and 84 percentiles of a parameter's distribution,
fit a Skew normal CDF and sample it.'''
# don't do anything if NaNs are input
if np.any(np.isnan([val, ehi, elo])):
return np.nan, np.nan, np.repeat(np.nan, int(Nsamp))
# get percentiles
p16, med, p84 = float(val - elo), float(val), float(val + ehi)
assert p16 < med
assert med < p84
# add approximate percentiles to help with fitting the wings
# otherwise the resulting fitting distritubions tend to
if add_p5_p95:
p5_approx = med - 2 * (med - p16)
p95_approx = med + 2 * (p84 - med)
xin = [p5_approx, p16, med, p84, p95_approx]
yin = [.05, .16, .5, .84, .95]
else:
xin, yin = [p16, med, p84], [.16, .5, .84]
# make initial parameter guess
mu, sig = med, np.mean([abs(p16), abs(p84)])
a = (abs(p16) - abs(p84)) / sig
p0 = a, mu, sig
popt, pcov = curve_fit(Skewnorm_CDF_func,
xin,
yin,
p0=p0,
sigma=np.repeat(.01, len(yin)),
absolute_sigma=False)
# sample the fitted pdf
samples = skewnorm.rvs(*popt, size=int(Nsamp))
# plot distribution if desired
if pltt:
plt.hist(samples,
bins=30,
normed=True,
label='Sampled parameter posterior')
plt.plot(np.sort(samples),
skewnorm.pdf(np.sort(samples), *popt),
'-',
label='Skew-normal fit: a=%.3f, m=%.3f, s=%.3f' % tuple(popt))
plt.xlabel('Parameter values'), plt.legend(loc='upper right')
plt.show()
return p0, popt, samples
def calculate_gradient(t_values, gradient_function, skew_norm_params,
n_classes):
gradient_arguments = [
skewnorm.pdf(t_values[i], *skew_norm_params[i][j])
for i in range(n_classes) for j in range(n_classes)
]
gradient_arguments += [
skewnorm.cdf(t_values[i], *skew_norm_params[i][j])
for i in range(n_classes) for j in range(n_classes)
]
return np.array(gradient_function(*gradient_arguments))
def interpret(parameters: np.ndarray, classes: np.ndarray, interval: float):
n_samples, n_components, n_classes = classes.shape
assert parameters.ndim == 3
assert parameters.shape == (n_samples, SkewNormal.N_PARAMETERS + 1, n_components)
shapes = np.expand_dims(parameters[:, 0, :], 2).repeat(n_classes, 2)
locations = np.expand_dims(parameters[:, 1, :], 2).repeat(n_classes, 2)
scales = np.expand_dims(relu(parameters[:, 2, :]), 2).repeat(n_classes, 2)
proportions = np.expand_dims(softmax(parameters[:, 3, :], axis=1), 1)
components = skewnorm.pdf(classes, shapes, loc=locations, scale=scales) * interval
m, v, s, k = skewnorm.stats(shapes[:, :, 0], loc=locations[:, :, 0], scale=scales[:, :, 0], moments="mvsk")
return proportions, components, (m, np.sqrt(v), s, k)
def _count_p_days(self, n, t, pdf='poisson'):
if pdf == 'poisson':
p_days = n * poisson.pmf(np.arange(self.n_days - self.day), mu=t)
elif pdf == 'skewnorm':
p_days = n * skewnorm.pdf(
np.arange(self.n_days - self.day), a=5, loc=t, scale=15)
elif pdf == 'lognorm':
p_days = n * lognorm(np.arange(self.n_days - self.day))
else:
raise NotImplementedError(
"Density function pdf='%s' not implemented!" % pdf)
return np.pad(p_days, (self.day, 0), mode='constant')
def sensing_pdf(self,C,Q,z,x):
if self.noisetype == 'multivariate_normal':
k = len(z)
e = z-np.matmul(C,x)
p1 = np.power((2*np.pi),-k/2)*np.power(np.linalg.det(Q),-0.5)
p2 = np.exp(-0.5*(e).T*np.linalg.inv(Q)*(e))
e_ = e*(np.linalg.norm(e)-0.5)
p2_ = np.exp(-0.5*(e_).T*np.linalg.inv(Q)*(e_))
return float(p1*p2) + float(p1*p2_)
if self.noisetype == 'skewnorm':
e = z-np.matmul(C,x) + self.sensingNoiseMode
return np.linalg.norm(skewnorm.pdf(e, self.Q[0], self.Q[1], self.Q[2]))
def plot_hist(data, mu, std, smu, sstd, skew, title):
"""
create a histogram plot panel
input: data --- a list of data
mu --- estimated center location
std --- estimated width
smu --- estimated skewed center location
sstd --- estimated skewed width
skew --- estimated skewness
title --- the title of the plot
output: a histogram plot panel (does not create a plot file)
"""
#
#--- plot histogram data
#
try:
#
#--- older format... if the starndard one does not work
#
plt.hist(data,
bins=20,
range=(-10, 10),
normed=True,
alpha=0.4,
color='green')
except:
plt.hist(data,
bins=20,
range=(-10, 10),
density=True,
alpha=0.4,
color='green')
#
#--- plot the normal/skewed normal fitting
#
xmin, xmax = plt.xlim()
xlist = numpy.linspace(xmin, xmax, 100)
ylist = snorm.pdf(xlist, mu, std)
plt.plot(xlist, ylist, color='blue', linewidth=2)
ylist = skewnorm.pdf(xlist, skew, smu, sstd)
plt.plot(xlist, ylist, color='red', linewidth=2)
plt.title(title)
ymin, ymax = plt.ylim()
ydiff = ymax - ymin
ypos1 = ymax - 0.1 * ydiff
ypos2 = ymax - 0.2 * ydiff
plt.text(-11, ypos1, 'normal', color='blue')
plt.text(-11, ypos2, 'skewed', color='red')
def predict_log_capacity(m, n, p, logX, params, raw=False):
x = np.linspace(np.amin(logX), np.amax(logX), num=100)
m_frac = float(m) / float(n)
f = skewnorm.pdf(x, *get_interpolated_params(m_frac, p, params))
f = f / np.sum(f)
C = np.random.choice(x, p=f, size=(n, 100000))
pred_raw = np.amin(C, axis=0)
pred_mean = np.mean(pred_raw)
return pred_raw if raw else pred_mean
def simulate_PDF(median, lower_err, upper_err, size=1, plot=True):
'''
Simulates a draw of posterior samples from a value and asymmetric errorbars
by assuming the underlying distribution is a skewed normal distribution.
Developed to estimate PDFs from literature exoplanet parameters that did not report their MCMC chains.
Inputs:
-------
median : float
the median value that was reported
lower_err : float
the lower errorbar that was reported
upper_err : float
the upper errorbar that was reported
size : int
the number of samples to be drawn
Returns:
--------
samples : array of float
the samples drawn from the simulated skrewed normal distribution
'''
sigma, omega, alpha = calculate_skewed_normal_params(
median, lower_err, upper_err)
samples = skewnorm.rvs(alpha, loc=sigma, scale=omega, size=size)
if plot == False:
return samples
else:
lower_err = np.abs(lower_err)
upper_err = np.abs(upper_err)
x = np.arange(median - 4 * lower_err, median + 4 * upper_err, 0.01)
fig = plt.figure()
for i in range(3):
plt.axvline([median - lower_err, median, median + upper_err][i],
color='k',
lw=2)
plt.plot(x, skewnorm.pdf(x, alpha, loc=sigma, scale=omega), 'r-', lw=2)
fit_percentiles = skewnorm.ppf([0.16, 0.5, 0.84],
alpha,
loc=sigma,
scale=omega)
for i in range(3):
plt.axvline(fit_percentiles[i], color='r', ls='--', lw=2)
plt.hist(samples, density=True, color='red', alpha=0.5)
return samples, fig
def plot_skew_norm_fit(ax,
data,
bins,
color='k',
linestyle='-',
linewidth=3,
label=None):
s, loc, scale = skewnorm.fit(data)
pdf = skewnorm.pdf(bins, s, scale=scale, loc=loc)
ax.plot(bins,
pdf,
color=color,
linestyle=linestyle,
linewidth=linewidth,
label=label)
def __init__(self,N,init_range,random_ratio,noisetype=None,R=None,Q=None):
self.X = np.zeros((N,len(init_range)))
self.W = np.ones(N)/N
self.N = N
self.random_ratio = random_ratio
self.init_range = init_range
self.noisetype = noisetype
if noisetype == 'skewnorm':
self.Q = Q
s = np.linspace(skewnorm.ppf(0.01, Q[0], Q[1], Q[2]),skewnorm.ppf(0.99, Q[0], Q[1], Q[2]), 100)
y = skewnorm.pdf(s, Q[0], Q[1], Q[2])
self.sensingNoiseMode = s[np.argmax(y)]
for i,random_range in enumerate(init_range):
self.X[:,i] = np.random.uniform(random_range[0],random_range[1],N)
def predict_log_capacity(m, n, p, logX, params, raw=False):
m_frac = float(m) / float(n)
a, loc, scale = get_interpolated_params(m_frac, p, params)
x_min = loc - 5. * scale
x_max = loc + 5. * scale
x = np.linspace(x_min, x_max, num=100)
f = skewnorm.pdf(x, a, loc, scale)
f = f / np.sum(f)
C = np.random.choice(x, p=f, size=(n, 100000))
pred_raw = np.amin(C, axis=0)
pred_mean = np.mean(pred_raw)
return pred_raw if raw else pred_mean
def main():
symbol = 'BTCUSDT'
start = int(datetime.datetime.timestamp(datetime.datetime(2019, 6, 1))) * 1000 - 365 * 24 * 60 * 60 * 1000
previous = start
trades = []
total_trades = 0
max_trades = 0
time_step = 1
with open('../Binance/' + symbol + '.csv', 'r') as csvfile:
reader = csv.DictReader(csvfile)
for line in reader:
if int(line['Timestamp']) > previous + time_step * 60 * 60 * 1000:
previous += time_step * 60 * 60 * 1000
trades.append(total_trades)
if max_trades < total_trades:
max_trades = total_trades
total_trades = 0
total_trades += 1
mean = np.mean(trades)
print(mean)
trades = [t for t in trades if t != 1]
#mean, scale = norm.fit(np.log(trades))
a, loc, scale = skewnorm.fit(np.log(trades))
loc_n, scale_n = norm.fit(np.log(trades))
k, loc_ne, scale_ne = exponnorm.fit(np.log(trades))
plt.hist(np.log(trades), bins=100, density=True)
x = np.linspace(6, 12, 100)
plt.plot(x, skewnorm.pdf(x, a, loc=loc, scale=scale), label='skewnorm')
plt.plot(x, norm.pdf(x, loc=loc_n, scale=scale_n), label='norm')
plt.plot(x, exponnorm.pdf(x, k, loc=loc_n, scale=scale_n), label='Exponentially modified Gaussian')
plt.xlabel('Log Trades')
plt.ylabel('Density')
plt.legend()
#plt.plot([i for i in range(1, max_trades)], poisson_density(np.array([i for i in range(1, max_trades)]), mean))
#plt.plot([i for i in range(0, max_trades)], norm.pdf([i for i in range(max_trades)], loc=mean, scale=np.sqrt(mean)))
plt.savefig(symbol + ' log Trades')
plt.show()
def calc_distribution(y, type='norm', lower=0.01, upper=99.99, points=100):
lo, up = get_percentiles(y, lower, upper)
X = np.linspace(lo, up, points)
if type == 'norm':
p1, p2 = norm.fit(y)
Y = norm.pdf(X, p1, p2)
return X, Y
elif type == 'skewed':
p1, p2, p3 = skewnorm.fit(y)
Y = skewnorm.pdf(X, p1, p2, p3)
return X, Y
else:
raise AttributeError("'type' not recognized.")
def table2(name, func, tex):
"""Makes table 2.
Args:
name (str): Descriptive name of the model. Posterior samples, statistics, and
figures are generated and saved in a subdirectory with this name.
func (:obj:`<class 'function'>): Function for model construction. Should
return a formatted copy of the data.
tex (bool): If True, saves the table to the manuscript subdirectory.
"""
with pm.Model() as m:
fit_model(name, func)
trace = pm.load_trace(name)
params = sorted([p.name for p in m.deterministics if "Lambda" in p.name])
df = pm.summary(trace, var_names=params)
table = []
for p, i in zip(params, interps):
theta = skewnorm.fit(trace[p])
p0 = norm.pdf(0)
p1 = skewnorm.pdf(0, *theta)
bf = p0 / p1
a, b, c = df.loc[p, ["mean", "hpd_2.5", "hpd_97.5"]]
dic = {
"Variable": p,
"Posterior mean (95% HPD)": "%s (%s, %s)" % (
latexify(a), latexify(b), latexify(c)),
"During roved-frequency trials ...": i,
"BF": latexify(bf),
"Evidence": interpret(bf),
}
table.append(dic)
# print(p, bf)
df = pd.DataFrame(table)[dic.keys()]
df.to_latex(f"{name}/table2.tex", escape=False, index=False)
if tex is True:
df.to_latex("manuscript/table2.tex", escape=False, index=False)
def test_summary_max_central_3(self):
c = ChainConsumer()
c.add_chain(self.data_skew)
summary_area = 0.95
c.configure(statistics="max_central",
bins=1.0,
summary_area=summary_area)
summary = c.analysis.get_summary()['0']
xs = np.linspace(-1, 5, 1000)
pdf = skewnorm.pdf(xs, 5, 1, 1.5)
cdf = skewnorm.cdf(xs, 5, 1, 1.5)
xval = interp1d(
cdf, xs)([0.5 - 0.5 * summary_area, 0.5 + 0.5 * summary_area])
xmax = xs[pdf.argmax()]
assert np.isclose(xmax, summary[1], atol=0.05)
assert np.isclose(xval[0], summary[0], atol=0.05)
assert np.isclose(xval[1], summary[2], atol=0.05)
def test_summary_max_symmetric_3(self):
c = ChainConsumer()
c.add_chain(self.data_skew)
summary_area = 0.95
c.configure(statistics="max_symmetric",
bins=1.0,
summary_area=summary_area)
summary = c.analysis.get_summary()['0']
xs = np.linspace(0, 2, 1000)
pdf = skewnorm.pdf(xs, 5, 1, 1.5)
xmax = xs[pdf.argmax()]
cdf_top = skewnorm.cdf(summary[2], 5, 1, 1.5)
cdf_bottom = skewnorm.cdf(summary[0], 5, 1, 1.5)
area = cdf_top - cdf_bottom
assert np.isclose(xmax, summary[1], atol=0.05)
assert np.isclose(area, summary_area, atol=0.05)
assert np.isclose(summary[2] - summary[1], summary[1] - summary[0])
def LL_FUNCTION(theta, array):
alpha = theta[0]
mu = theta[1]
sigma = theta[2]
N = len(array)
try:
constant = GLOBAL_INTERP([alpha, mu, sigma])[0]
except:
return -np.inf
#LL = N*np.log(constant) + (erf((array - mu)/(np.sqrt(2) * sigma)*alpha) - 0.5*np.square((array - mu)/sigma) - np.log(sigma)).sum()
LL = N * np.log(constant) + np.log(skewnorm.pdf(array, alpha, mu,
sigma)).sum()
if not np.isfinite(LL):
return -np.inf
return LL + alpha_prior(alpha) + mu_prior(mu)
def skewgauss(n, relative_location=0, alpha=0):
''' Generate a squew gaussian.
Args:
n: (int) timesteps
relative_location: (float) relative shifting of the
distribution [0, 1] (0.1 indicates a shifting toward
the beginning of the interval,0.9 indicates a shifting
toward its end)
alpha: (float) skewness
Example:
stime = 1500
plt.plot(stime, skewgauss(stime, location=0.6, alpha=4))
'''
location = 10 * relative_location - 5
rng = np.array([-2, 2]) - location
x = np.linspace(rng[0], rng[1], n)
return skewnorm.pdf(x, alpha)
def plot_histogram_and_skew_norm(train_features_given_class, skew_norm_params,
n_classes, do_skew_norm_plots):
if do_skew_norm_plots:
all_min = np.min(train_features_given_class)
all_max = np.max(train_features_given_class)
for class_i in range(n_classes):
for feature_i in range(n_classes):
plt.subplot(3, 3, 1 + feature_i + n_classes * class_i)
plt.hist(train_features_given_class[class_i, :, feature_i],
density=True)
minf = np.min(train_features_given_class[class_i, :,
feature_i])
maxf = np.max(train_features_given_class[class_i, :,
feature_i])
x = np.linspace(minf, maxf)
plt.plot(
x, skewnorm.pdf(x, *skew_norm_params[class_i][feature_i]))
plt.xlim((all_min, all_max))
plt.ylim((0, 0.5))
plt.title("C=" + str(class_i + 1) + " F=" + str(feature_i + 1))
plt.show()
def cal_tot_sf(SFR, SFEN):
# Skew normal distribution for star formation history
# took input: maximum star formation rate, star formation event number
import numpy as np
from scipy.stats import skewnorm
# from scipy.stats import f
global skewness, location
x = np.linspace(skewnorm.ppf(0.01, skewness, location, 1),
skewnorm.ppf(0.99, skewness, location, 1), SFEN)
y = skewnorm.pdf(x, skewness, location, 1)
# skewnorm.pdf(x, a, loc, scale) is the location and scale parameters,
# [identically equivalent to skewnorm.pdf(y, a) / scale with y = (x - loc) / scale]
# The scale is not used as the SFEN & SFR setup the scale through parameter tot_sf_set & mult.
mult = 10**SFR / max(y)
j = 0
tot_sf = 0
while j < SFEN:
sf = mult * y[j]
tot_sf += sf
(j) = (j + 1)
return tot_sf, mult, y
def compare_hist_to_norm(data, bins=25):
"""
:param data:
:param bins:
:return:
"""
fig = plt.figure(figsize=(10, 5))
mu, std = scipy.stats.norm.fit(data)
plt.hist(data,
bins=bins,
density=True,
alpha=0.6,
color='purple',
label="Données")
# Plot le PDF.
xmin, xmax = plt.xlim()
X = np.linspace(xmin, xmax)
plt.plot(X, scipy.stats.norm.pdf(X, mu, std), label="Normal Distribution")
plt.plot(X,
skewnorm.pdf(X, *skewnorm.fit(data)),
color='black',
label="Skewed Normal Distribution")
mu, std = scipy.stats.norm.fit(data)
sk = scipy.stats.skew(data)
title2 = "Moments mu: {}, sig: {}, sk: {}".format(round(mu, 4),
round(std, 4),
round(sk, 4))
plt.ylabel("Fréquence", rotation=90)
plt.title(title2)
plt.legend()
#plt.show()
pass
def s(p):
func_s = skewnorm.pdf(p,alpha,mu,sigma)
return func_s
return (1 + erf(x/sqrt(2))) / 2
def skew(x,e=0,w=1,a=0):
t = (x-e) / w
return 2 / w * pdf(t) * cdf(a*t)
# You can of course use the scipy.stats.norm versions
# return 2 * norm.pdf(t) * norm.cdf(a*t)
n = 2**12
e = 1.0 # location
w = 2.0 # scale
x = linspace(0,7,n)
#p = skew(x,e,w,9)
p = skewnorm.pdf(x, 5, loc=1, scale=1.5)
print(x[p.argmax()])
c = skewnorm.cdf(x, 5, loc=1, scale=1.5)
#c = p.cumsum()
#c /= c.max()
b0 = np.where(c > 0.15865)[0][0]
bm = np.where(c > 0.5)[0][0]
b1 = np.where(c > 0.84135)[0][0]
x0 = x[b0]
x1 = x[b1]
s=30
def fit_funct(self, x, A, mu, sigma, kurt, c):
return A * skewnorm.pdf(x, kurt, mu, sigma) + c
