def otimizar(self):
# Definindo os parâmetros a serem utilizados
parametros = {
'C': loguniform.rvs(2**-5, 2**15, size=self.tamanho_grid),
'gamma': loguniform.rvs(2**-15, 2**3, size=self.tamanho_grid),
'epsilon': uniform.rvs(0.0, 1, size=self.tamanho_grid)
}
cv_ = ShuffleSplit(n_splits=1, test_size=0.1, train_size=0.9)
# Executando otimização dos parâmetros
self.iniciar_tempo()
grid = GridSearchCV(estimator=SVR(kernel='rbf'),
param_grid=parametros,
scoring="neg_mean_absolute_error",
cv=cv_,
n_jobs=-1)
grid.fit(self.X_treinamento, self.Y_treinamento)
self.finalizar_tempo()
# extraindo os melhores hiperparametros
C = grid.best_params_['C']
gamma = grid.best_params_['gamma']
epsilon = grid.best_params_['epsilon']
# Treinando SVM final com os parâmetros encontrados
self.svm = SVM(gamma, C, epsilon)
self.svm.treinar(self.X_treinamento, self.Y_treinamento)
self.svm.testar(self.X_teste, self.Y_teste)
def create_random_LR(
penalty: tuple = ("none", "l1", "l2", "elasticnet"),
solver: tuple = ("liblinear", "sag", "saga", "newton-cg", "lbfgs"),
max_iter: tuple = (100, 1000),
C: tuple = (1e-5, 10),
) -> LogisticRegression:
"""Create a Logistic Regression model using random hyperparameters.
:param penalty: Tuple with the penalty hyperparameters, defaults to ("none", "l1", "l2", "elasticnet")
:type penalty: tuple, optional
:param solver: Tuple with the solver hyperparameters, defaults to ("liblinear", "sag", "saga", "newton-cg", "lbfgs")
:type solver: tuple, optional
:param max_iter: Tuple with the max_iter hyperparameters, defaults to (100, 1000)
:type max_iter: tuple, optional
:param C: Tuple with the C hyperparameters, defaults to (1e-5, 10)
:type C: tuple, optional
:return: A LogisticRegresion model with the random hyperparameters.
:rtype: LogisticRegression
"""
model = LogisticRegression(
penalty=random.choice(penalty),
solver=random.choice(solver),
max_iter=round(loguniform.rvs(max_iter[0], max_iter[1])),
C=round(loguniform.rvs(C[0], C[1]), int(abs(math.log(C[0], 10)))),
)
return model
def generate_parameters(seed):
np.random.seed(seed)
out = {}
out['nfeatures'] = np.random.randint(3, 25)
out['lr'] = float(loguniform.rvs(0.001, 0.01, size=1))
out['gamma'] = np.random.uniform(0.75, 0.05)
out['penalty'] = float(loguniform.rvs(0.00001, 0.1, size=1))
out['batch'] = np.random.choice([32, 64])
return out
def generate_p0(df_config, nwalkers, fix=None):
config = df_config.copy()
adopts_logprior = config.prior == "log"
_a = config.lo.values
_b = config.hi.values
a = _a[adopts_logprior]
b = _b[adopts_logprior]
loc = _a[~adopts_logprior]
scale = (_b - _a)[~adopts_logprior]
#print(loc,scale)
p0 = empty((nwalkers, len(config)))
#print(p0.shape)
p0[:, ~adopts_logprior] = uniform.rvs(size=(nwalkers,
(~adopts_logprior).sum()),
loc=loc,
scale=scale)
p0[:, adopts_logprior] = loguniform.rvs(size=(nwalkers,
adopts_logprior.sum()),
a=a,
b=b)
if fix is not None:
deleted_index = [list(config.name).index(pname) for pname in fix]
p0 = np.delete(p0, deleted_index, axis=1)
return p0
def gen_params_value(self):
"""
Generates new values (samples randomly) for each parameter.
Returns:
dict: A dictionary containing the parameters whose values should be sampled.
"""
np.random.seed(None)
auto_params_val = {}
for param in self.auto_params:
if param["type"] == "fixed":
auto_params_val.update({param["name"]: param["value"]})
elif param["type"] == "choice":
auto_params_val.update(
{param["name"]: np.random.choice(param["values"])})
elif param["type"] == "range":
if "log_scale" in param and param["log_scale"]:
auto_params_val.update(
{param["name"]: loguniform.rvs(*param["bounds"])})
else:
auto_params_val.update(
{param["name"]: np.random.uniform(*param["bounds"])})
elif param["type"] == "int":
auto_params_val.update(
{param["name"]: np.random.randint(np.iinfo(np.int32).max)})
return auto_params_val
def create_random_SVC(
kernel: tuple = ("linear", "poly", "rbf", "sigmoid", "precomputed"),
gamma: tuple = ("scale", "auto"),
C: tuple = (1e-5, 10),
decision_function_shape: tuple = ("ovo", "ovr"),
probability: bool = True,
) -> SVC:
"""Create a Support Vector Machine model using random hyperparameters.
:param kernel: Tuple with the kernel hyperparameters, defaults to ("linear", "poly", "rbf", "sigmoid", "precomputed")
:type kernel: tuple, optional
:param gamma: Tuple with the gamma hyperparameters, defaults to ("scale", "auto")
:type gamma: tuple, optional
:param C: Tuple with C hyperparameters, defaults to (1e-5, 10)
:type C: tuple, optional
:param decision_function_shape: Tuple with the decision_function_shape hyperparameters, defaults to ("ovo", "ovr")
:type decision_function_shape: tuple, optional
:param probability: Boolean to enable probability prediction, defaults to True
:type probability: tuple, optional
:return: A SVC model with the random hyperparameters.
:rtype: SVC
"""
model = SVC(
kernel=random.choice(kernel),
gamma=random.choice(gamma),
C=round(loguniform.rvs(C[0], C[1]), int(abs(math.log(C[0], 10)))),
decision_function_shape=random.choice(decision_function_shape),
probability=probability,
)
return model
def get_samples(args):
"""Get different samples of hyperparameters
Arguments:
args: Arguments read from command line
returns list of samples for hyperparameters out of given hparam space
"""
# Put values multiple times into list to increase probability to be chosen
param_grid = {
"pooling_type": ["avg"],
"pool_size_y_factor": [i / 30 for i in range(1, 15)],
"pool_size_x": [i for i in range(8, 22)],
"learning_rate": loguniform.rvs(a=1e-3, b=5e-1, size=10000),
"optimizer": ["Adam"],
"regularizer": [i / 100 for i in range(0, 20)],
"filter_rows_lower": [i for i in range(300)],
"filter_cols_upper": [i for i in range(8, 20)],
"filter_cols_lower": [i for i in range(10, 20)],
"batch_size": [32, 64, 128, 256],
"num_units_l1": [i for i in range(3, 10)],
"num_units_l2": [i for i in range(1, 5)],
"activation": ["relu"],
}
dynamic_params = list(ParameterSampler(param_grid, n_iter=args.n_runs))
static_params = get_static_hparams(args)
return [{**dp, **static_params} for dp in dynamic_params]
def sample(self, nsamples=None):
"""
Function that sample points from the prior. Uniform for the slope and intercept --- log-uniform for the standard-deviation.
"""
if nsamples is None:
nsamples = self.nsamples
# Evaluate samples:
beta_samples = np.random.uniform(self.beta1, self.beta2, nsamples)
sigma_poisson_samples = loguniform.rvs(self.sigma_poisson1,
self.sigma_poisson2,
size=nsamples)
sigma_flicker_samples = loguniform.rvs(self.sigma_flicker1,
self.sigma_flicker2,
size=nsamples)
# Return them:
return beta_samples, sigma_poisson_samples, sigma_flicker_samples
def sample(self, nsamples=None):
"""
Function that sample points from the prior. Uniform for the slope and intercept --- log-uniform for the standard-deviation.
"""
if nsamples is None:
nsamples = self.nsamples
# Evaluate samples:
a_samples = np.random.uniform(self.a1, self.a2, nsamples)
b_samples = np.random.uniform(self.b1, self.b2, nsamples)
sigma_samples = loguniform.rvs(self.sigma1, self.sigma2, size=nsamples)
# Return them:
return a_samples, b_samples, sigma_samples
def sample_values():
p2v = dict()
for p in config['tune_params']:
a = config['{}_algo'.format(p)]
if a != 'choice':
min_v, max_v = config['{}_range'.format(p)]
if a == 'loguniform':
p2v[p] = loguniform.rvs(min_v, max_v)
elif a == 'uniform-integer':
p2v[p] = np.random.randint(min_v, max_v + 1)
elif a == 'uniform-float':
p2v[p] = uniform.rvs(min_v, max_v)
else:
print("ERROR: sampling method specified as {}".format(a))
else: # a == 'choice'
p2v[p] = np.random.choice(config['{}_range'.format(p)])
return p2v
def get_samples(args):
"""Get random samples of hyperparameters
Arguments:
args: Arguments read from command line
returns list of samples for hyperparameters out of given hparam space
"""
from scipy.stats import loguniform
# Put values multiple times into list to increase probability to be chosen
param_grid = {
"pooling_type": ["avg"],
"kernel_size": [i for i in range(5, 6)],
"kernel_number": [i for i in range(11, 15)],
"pool_size_y": [2],
"pool_size_x": [2],
"learning_rate": loguniform.rvs(a=7e-6, b=5e-4, size=10000),
"optimizer": ["Adam"], # Nadam, Adagrad
"layer_number": [5],
"batch_normalization": [False, True],
"regularization": [0],
"filter_rows_lower": [0],
"filter_cols_upper": [0],
"filter_cols_lower": [0],
"batch_size": [64, 128],
"loss": ["mae"],
"Recurrent_Celltype": ["GRU"],
"units": [i for i in range(11, 14)],
"squeeze_method": ["1x1_conv", "squeeze"],
"1x1_conv_filters": [i + 1 for i in range(5, 11)],
}
randint = int(
tf.random.uniform(shape=[],
minval=0,
maxval=10,
dtype=tf.dtypes.int32,
seed=None))
dynamic_params = list(
ParameterSampler(param_grid, n_iter=args.n_runs, random_state=randint))
static_params = get_static_hparams(args)
return [{**dp, **static_params} for dp in dynamic_params]
def sample_values(trial_num):
p2v = dict()
for p in config['tune_params']:
a = config['{}_algo'.format(p)]
if a == 'selection': #To select in order from a list of hyperparam values
p2v[p] = config['{}_range'.format(p)][trial_num]
elif a == 'choice': #To randomly select any value from a list of hyperparam values
p2v[p] = np.random.choice(config['{}_range'.format(p)])
else: #To randomly select a value from a given range
min_v, max_v = config['{}_range'.format(p)]
if a == 'loguniform':
p2v[p] = loguniform.rvs(min_v, max_v)
elif a == 'uniform-integer':
p2v[p] = np.random.randint(min_v, max_v + 1)
elif a == 'uniform-float':
p2v[p] = uniform.rvs(min_v, max_v)
else:
print("ERROR: sampling method specified as {}".format(a))
return p2v
def get_samples(args):
"""Get different samples of hyperparameters
Arguments:
args: Arguments read from command line
returns list of samples for hyperparameters out of given hparam space
"""
from scipy.stats import loguniform
# Put values multiple times into list to increase probability to be chosen
param_grid = {
"pooling_type": ["avg", "max"],
"kernel_size": [i for i in range(3, 5)],
"kernel_number": [i for i in range(2, 5)],
"pool_size_y": [2],
"pool_size_x": [2],
"learning_rate": loguniform.rvs(a=1e-6, b=1e-4, size=100000),
"optimizer": ["Adam"],
"layer_number": [1, 2, 3],
"batch_normalization": [False, True],
"regularization": [0],
"filter_cols_upper": [i for i in range(15, 35)],
"filter_cols_lower": [i for i in range(15, 30)],
"batch_size": [32, 64, 128],
"units": [i for i in range(2, 14)],
"loss": ["categorical_crossentropy"],
}
randint = int(
tf.random.uniform(shape=[],
minval=0,
maxval=10,
dtype=tf.dtypes.int32,
seed=None))
dynamic_params = list(
ParameterSampler(param_grid, n_iter=args.n_runs, random_state=randint))
static_params = get_static_hparams(args)
return [{**dp, **static_params} for dp in dynamic_params]
def generate_p0(config_fname):
file_dir = os.path.dirname(__file__) + "/"
path_config_fname = file_dir + config_fname
config = LeptophilicDM(path_config_fname).config
adopts_logprior = config.prior=="log"
_a = config.lo.values
_b = config.hi.values
a = _a[adopts_logprior]
b = _b[adopts_logprior]
loc = _a[~adopts_logprior]
scale = (_b-_a)[~adopts_logprior]
#print(loc,scale)
p0 = empty((nwalkers,len(config)))
#print(p0.shape)
p0[:,~adopts_logprior] = uniform.rvs(size=(nwalkers,(~adopts_logprior).sum()),loc=loc,scale=scale)
p0[:,adopts_logprior] = loguniform.rvs(size=(nwalkers,adopts_logprior.sum()),a=a,b=b)
return p0
def generate_p0(df_config, nwalkers):
config = df_config.copy()
adopts_logprior = config.prior == "log"
_a = config.lo.values
_b = config.hi.values
a = _a[adopts_logprior]
b = _b[adopts_logprior]
loc = _a[~adopts_logprior]
scale = (_b - _a)[~adopts_logprior]
#print(loc,scale)
p0 = empty((nwalkers, len(config)))
#print(p0.shape)
p0[:, ~adopts_logprior] = uniform.rvs(size=(nwalkers,
(~adopts_logprior).sum()),
loc=loc,
scale=scale)
p0[:, adopts_logprior] = loguniform.rvs(size=(nwalkers,
adopts_logprior.sum()),
a=a,
b=b)
return p0
def create_random_LDA(
solver: tuple = ("svd", "lsqr", "eigen"),
shrinkage: tuple = ("auto", round(random.uniform(1e-5, 1),
5), "none"),
tol: tuple = (1e-5, 1e-3),
) -> LinearDiscriminantAnalysis:
"""Create a Linear Discriminant model using random hyperparameters.
:param solver: Tuple with the solver hyperparameters, defaults to ("svd", "lsqr", "eigen")
:type solver: tuple, optional
:param shrinkage: Tuple with the shrinkage hyperparameters, defaults to ("auto", round(random.uniform(1e-5, 1), 5), "none")
:type shrinkage: tuple, optional
:param tol: Tuple with the tolerance hyperparameters, defaults to (1e-5, 1e-3)
:type tol: tuple, optional
:return: A LinearDiscriminantAnalysis model with the random hyperparameters.
:rtype: LinearDiscriminantAnalysis
"""
model = LinearDiscriminantAnalysis(
solver=random.choice(solver),
shrinkage=random.choice(shrinkage),
tol=round(loguniform.rvs(tol[0], tol[1]),
int(abs(math.log(tol[0], 10)))),
)
return model
def fit(self, spaceLocsMeas, timeInstants, y, optimize = False, fun = None):
"""
INPUT:
spaceLocsMeas: Spatial indices of measurements to be fitted
timeInstants: Temporal indices of measurements to be fitted
y: Target values for the given spatial and temporal indices
optimize: Whether to optimize kernel parameters or not
fun: Objective function to be minimized in case of optimization
"""
def obj(theta):
# Set hyperparameters to theta
self.kernel_time.set_hyperparams(theta[:time_params_n])
self.kernel_space.set_hyperparams(theta[time_params_n:])
print(theta)
# Calculate covariances for space kernel
Kss = self.kernel_space.sample(spaceLocsMeas)
self.Ks_chol = np.linalg.cholesky(Kss).conj().T
self.a, self.c, self.v0, self.q = self.kernel_time.createDiscreteTimeSys(self.params.data['samplingTime'])
# initialize quantities needed for kalman estimation
A = np.kron(I, self.a)
C = self.Ks_chol @ np.kron(I,self.c)
V0 = np.kron(I, self.v0)
Q = np.kron(I, self.q)
score = None
if fun == 'nll':
x,V,xp,Vp,logMarginal = self.kalmanEst(A,C,Q,V0,R, y, computeLikelihood = True)
score = logMarginal
elif fun == 'RMSE':
score = self.score(spaceLocsMeas, timeInstants, y, metric = 'RMSE')
print(score)
return score
if self.normalize_y:
self.y_train_mean = np.nanmean(y)
self.y_train_std = np.nanstd(y)
self.y_train = y - self.y_train_mean
else:
self.y_train_mean = 0
self.y_train_std = 1
self.y_train = y
self.y_train_timeInstants = timeInstants
if optimize is True and fun is not None:
# Getting some useful values
numSpaceLocs, numTimeInstants = y.shape
time_params_n = len(self.kernel_time.kernel[:])
space_params_n = len(self.kernel_space.kernel[:])
# Create noise matrix
self.noiseVar = (self.params.data['noiseStd']**2) * np.ones(y.shape)
I = np.eye(numSpaceLocs)
R = np.zeros((numSpaceLocs, numSpaceLocs, numTimeInstants))
for t in np.arange(0, numTimeInstants):
R[:,:,t] = np.diag(self.noiseVar[:,t]).copy()
# Use ML to find best kernel parameters using initial guess
res = minimize(obj, np.concatenate((self.kernel_time.kernel[:], self.kernel_space.kernel[:]), axis=0),
bounds=[(1e-3, 1e+4) for i in range(time_params_n + space_params_n)],
method='L-BFGS-B')
# Repeat for random guesses using loguniform
for r in np.arange(0, self.n_restarts):
print('Optimizer restart:', r+1, ' of ', self.n_restarts)
random_theta0 = loguniform.rvs(1e-4, 1e+4, size= time_params_n + space_params_n)
new_res = minimize(obj, random_theta0,
bounds=[(1e-3, 1e+4) for i in range(time_params_n + space_params_n)],
method='L-BFGS-B')
# Store best values
if new_res.fun < res.fun:
res = new_res
# Update parameters with best results
self.kernel_time.set_hyperparams(res.x[:time_params_n])
self.kernel_space.set_hyperparams(res.x[time_params_n:])
# Update state-space representation
self.a, self.c, self.v0, self.q = self.kernel_time.createDiscreteTimeSys(self.params.data['samplingTime'])
self.Ks_chol = np.linalg.cholesky(self.kernel_space.sample(spaceLocsMeas)).conj().T
print('Best hyperparameters and marginal log value')
print(res.x)
print(res.fun)
def create_random_network(
m: int,
n_classes: int,
metrics: str = "accuracy",
layers: tuple = (1, 5),
n: tuple = (10, 20),
activation: tuple = ("relu", "sigmoid"),
lr: tuple = (1e-5, 1e-3),
optimizer: keras.optimizers.Optimizer = keras.optimizers.Adam,
loss: str = "categorical_crossentropy",
) -> tuple((keras.models.Sequential, keras.optimizers.Optimizer, str)):
"""Return a deep neural network model with pseudo-random hyperparameters according to its arguments, each time it is called.
:param m: Number of input variables which will enter in the neural network
:type m: int
:param n_classes: Number of classes to be classificated
:type n_classes: int
:param metrics: String with the metric to evaluate and compare the different random networks, defaults to "accuracy"
:type metrics: str, optional
:param layers: Tuple with the number of layers of the neural network as hyperparameter, defaults to (1, 5)
:type layers: tuple, optional
:param n: Tuple with the min and max number of neurons per layer, defaults to (10,20)
:type n: tuple, optional
:param activation: Tuple with the activation functions as hyperparameters, defaults to ("relu","sigmoid")
:type activation: tuple, optional
:param lr: Tuple with the min and max values for the learning rate as hyperparameter, defaults to (1e-5, 1e-3)
:type lr: tuple, optional
:param optimizer: A keras Optimizer to be used to train the neural network, defaults to keras.optimizers.Adam
:type optimizer: keras.optimizers.Optimizer
:param loss: String with the lossing function to be used to measure the error, defaults to "categorical_crossentropy"
:type loss: str
:return: A tuple formed by the keras.models.Sequential, keras.optimizers.Optimizer, and the lossing function
:rtype: tuple
"""
# Defining the model class Sequential in order to add layers one by one
model = keras.models.Sequential()
# First layer of de network
model.add(
keras.layers.Dense(
random.randint(n[0], n[1]),
input_dim=m,
activation=random.choice(activation),
)
)
# Input Normalization, working as a StandardScaler() tranformer for input data
keras.layers.BatchNormalization()
# Loop which adds layers following a uniform random distribution
for _ in range(random.randint(layers[0], layers[1])):
model.add(
keras.layers.Dense(
random.randint(n[0], n[1]),
activation=random.choice(activation),
)
)
model.add(keras.layers.Dense(n_classes, activation="softmax"))
# Choosing a learning rate from a logarithmic uniform distrbution
optimizer = optimizer(
learning_rate=round(
loguniform.rvs(lr[0], lr[1]), int(abs(math.log(lr[0], 10)))
)
)
# Define some characteristics for the training process
model.compile(loss=loss, optimizer=optimizer, metrics=metrics)
return model, optimizer, loss
eta_1_distr = lambda: random.uniform(0, 0.1)
eta_2_distr = lambda eta_1: random.uniform(0, eta_1)
delta_eta_distr = lambda eta_1: random.uniform(0, min(eta_1,1.7e-2))
gammap_distr = lambda gamma: random.uniform(gamma, 2*gamma)
gammapp_distr = lambda gammap: random.uniform(gammap, 2*gammap)
sigma_distr = lambda: random.uniform(1/5, 1/2)
sigma_1_distr = lambda: random.uniform(1/5, 1/2)
sigma_2_distr = lambda: random.uniform(1/5, 1/2)
IFR_distr = lambda: random.uniform(1e-3, 1e-1)
IFR1_distr = lambda IFR: random.uniform(1e-3, IFR)
I0_distr = lambda: loguniform.rvs(1e-7, 3e-1)
S0p_distr = lambda: random.uniform(1e-4, 0.1)
S0pp_distr = lambda: random.uniform(1e-4, 0.1)
td_distr = lambda: random.choice(np.arange(7,35))
samples = int(1000)
file = open("decision_tree_output.dat", "w")
file.write("#seed: %d \n"%seed)
file.write("beta,betap,betapp,beta_1,beta_1p,beta_1pp,\
beta_2,beta_2p,beta_2pp,nu_max,eta_1,eta_2,\
gamma,gammap,gammapp,sigma,sigma_1,sigma_2,IFR,IFR1,IFR2,td,\
S0,S0p,S0pp,E0,E0p,E0pp,I0,I0p,I0pp,R0,D0,d1,d2,D1,D2,\
delta < 0,Delta < 0\n")
def bulk_planets_mc(n=100,
names=None,
mini=None,
maxi=None,
pl_kwargs={},
model_kwargs={},
t_eval=None,
log=False,
T_m0_options=None,
propagate_fit_err=False,
verbose=False,
beta_h=p.beta_h,
cov_beta_h=p.cov_beta_h,
**kwargs):
"""varying multiple parameters in 'names' between mini and maxi, use default values otherwise.
update_kwargs can include any TerrestrialPlanet attribute
initial_kwargs can include T_m0, T_c0, D_l0, t0, tf. names, mini, and maxi are in order and must have same lenghts"""
# pl_kwargs and model_kwargs should already be taken from inputs file
if T_m0_options is None:
T_m0_options = np.array([1000, 1250, 1500, 1750, 2000
]) + 273 # [ 1273, 1523, 1773, 2023, 2273]
planets = []
ii = 0
while ii < n:
new_kwargs_pl = pl_kwargs.copy()
new_kwargs_model = model_kwargs.copy()
for iii, name in enumerate(names):
if name == 'T_m0':
# for initial temps do discrete values after johnny seales
val = np.random.choice(T_m0_options, size=1)[0]
elif log:
val = loguniform.rvs(mini[iii], maxi[iii], size=1)
else:
val = rand.uniform(mini[iii], maxi[iii])
if name in ['T_m0', 'T_c0', 'D_l0']:
new_kwargs_model.update({name: val})
else:
new_kwargs_pl.update({name: val})
if verbose:
print(ii, '/', n - 1, ': drew random', name, val)
if propagate_fit_err:
beta_h_new = np.random.multivariate_normal(beta_h, cov_beta_h)
new_kwargs_model.update({'beta_h': beta_h_new})
if verbose:
print(' & drew random errors on h scaling', beta_h_new)
if t_eval is None and ii > 0:
t_eval = planets[0].t
pl = None
while pl is None: # returns None if numerical issue e.g. D_l0 negative
pl = build_planet(planet_kwargs=new_kwargs_pl,
run_kwargs=new_kwargs_model,
t_eval=t_eval,
verbose=verbose,
**kwargs)
planets.append(pl)
ii += 1
return planets
linxbins = np.linspace(10,1500,20)
finxwidths = []
for nlinx,linx in enumerate(linxbins):
try:
linxwidths.append(linxbins[nlinx+1] - linxbins[nlinx])
except:
pass
linxwidths = np.array(linxwidths)
#### for UNIFORM AREAS IN LINEAR SPACE, HEIGHTS NEED TO BE 1/linxwidths
linyheights = 1/linxwidths
"""
uniform_draws = np.random.uniform(10,1500,size=10000)
loguniform_draws = loguniform.rvs(10,1500,size=10000)
logbins = np.logspace(np.log10(10), np.log10(1500),20)
fig, (ax1, ax2) = plt.subplots(2)
ax1.hist(uniform_draws, bins=np.linspace(10,1500,20))
ax1.set_ylabel('uniform draws, uniform binning')
ax2.hist(uniform_draws, bins=logbins)
ax2.set_ylabel('uniform draws, log binning')
plt.show()
uniform_nperbin = plt.hist(uniform_draws, bins=logbins)[0]
plt.xscale('log')
plt.title('uniform nperbin')
plt.show()
uniform_nperbin_20x20 = np.zeros(shape=(19,19)) #### there are actually 19 bins on a side.
def sample_from_prior(self, size=1, width=1.0):
ret = loguniform.rvs(*loguniform.interval(width, self.llim, self.rlim),
size=size)
return ret if size != 1 else ret[0]
min_[np.where(min_ == max_)] = 0
return (data_ - min_) / (max_ - min_), min_, max_
def checkprior(theta, prior):
flag = prior.pdf(theta) > 0
print(f'inside of initial prior: {sum(flag)}')
print(f'out of total: {len(theta)}')
return theta[flag,:]
def loguniform_prior(Ndata=2_500, log=True):
a0, b0 = 0.002, 2
a1, b1 = 0.002, 2
k1 = loguniform.rvs(a0,b0,size=Ndata)
k2 = loguniform.rvs(a1,b1,size=Ndata)
k3 = loguniform.rvs(a0,b0,size=Ndata)
theta = np.vstack((k1,k2,k3)).T
if log:
return np.log(theta)
return theta
from scipy.stats import uniform
class uniform_prior:
def __init__(self, left = [0.002,0.002,0.002], right =[2,2,2]):
self.left = np.asarray(left)
self.right = np.asarray(right)
self.m = (self.left+self.right)/2
def run(fname_prefix,
p0=None,
nwalkers = 20,
nsample = 1000,
nburnin = 100,
enable_vacuum_stability=False,
enable_collider_const=False,
enable_micromegas_likeli=False,
enable_micromegas_prior=False,
enable_gm2=False,
use_pool=False,
config_fname = "config.csv",
project_name = "LeptophilicDM",
dir_models = "/from_taisuke/models",
overwrite=False
):
"""
fname_prefix:
if like "test", save chains into
test_chain.npy
etc. if like "test/", save
test/_chain.npy
etc.
"""
executed_time = datetime.datetime.now()
file_dir = os.path.dirname(__file__) + "/"
path_config_fname = file_dir + config_fname
configs = [enable_vacuum_stability,
enable_collider_const,
enable_micromegas_likeli,
enable_micromegas_prior,
enable_gm2,
use_pool]
config_int = (2**arange(len(configs)) * configs).sum()
fname_prefix += f"_nwalkers={nwalkers}_nsample={nsample}_nburnin={nburnin}_config={config_int}"
print(f"Results will be exported to {fname_prefix}_.gz")
model = LeptophilicDM(path_config_fname,
enable_vacuum_stability,
enable_collider_const,
enable_micromegas_likeli,
enable_micromegas_prior,
enable_gm2,
project_name,
dir_models
)
#nwalkers = 20
#loc = (model.config.hi.values + model.config.lo.values ) / 2
#scale = (model.config.hi.values - model.config.lo.values ) * 0.1
#p0 = norm.rvs(size=(nwalkers,len(model.config)),loc=loc,scale=scale)
# Note: uniform(loc,scale) = [loc, loc+scale]
# Here
if p0 is None:
config = LeptophilicDM(path_config_fname).config
adopts_logprior = config.prior=="log"
_a = config.lo.values
_b = config.hi.values
a = _a[adopts_logprior]
b = _b[adopts_logprior]
loc = _a[~adopts_logprior]
scale = (_b-_a)[~adopts_logprior]
#print(loc,scale)
p0 = empty((nwalkers,len(config)))
#print(p0.shape)
p0[:,~adopts_logprior] = uniform.rvs(size=(nwalkers,(~adopts_logprior).sum()),loc=loc,scale=scale)
p0[:,adopts_logprior] = loguniform.rvs(size=(nwalkers,adopts_logprior.sum()),a=a,b=b)
#pnames = model.param_names
#idx_mchi = pnames[pnames=="m_chi"].index[0]
#loc[idx_mchi] = 500
#idx_mchi = pnames[pnames=="m_phi_L"].index[0]
#loc[idx_mchi] = 1000
#idx_mchi = pnames[pnames=="m_phi_R"].index[0]
#loc[idx_mchi] = 1000
sampler = Sampler(model.lnposterior,p0,nwalkers)
#nsample = 1000
sampler.sample(nburnin,use_pool=use_pool,burnin=True)
sampler.sample(nsample,use_pool=use_pool)
sampler.save(fname_prefix)
sampler.save_pickle(fname_prefix,overwrite=overwrite)
log = dict(fname_prefix=fname_prefix,
p0 = p0,
nwalkers = nwalkers,
nsample = nsample,
nburnin = nburnin,
enable_vacuum_stability = enable_vacuum_stability,
enable_collider_const = enable_collider_const,
enable_micromegas_likeli = enable_micromegas_likeli,
enable_micromegas_prior = enable_micromegas_prior,
enable_gm2 = enable_gm2,
use_pool = use_pool,
config_fname = config_fname,
project_name = project_name,
dir_models = dir_models,
overwrite = overwrite,
executed_time = executed_time)
return sampler
