def update(self, r, x):
u0_long = 0.5 * np.ones(self.H)
u0_lat = 0.5 * np.ones(self.H)
constraints = {'type': 'ineq', 'fun': self.con_long}
options = {'disp': False}
# t0 = time.time()
res_f = minimize(self.obj_long,
u0_long,
args=(r, x),
bounds=Bounds(-5.0, 5.0),
options=options,
method='slsqp')
res_tau = minimize(self.obj_lat,
u0_lat,
args=(r, x),
bounds=Bounds(-0.5, 0.5),
options=options,
method='slsqp')
# t1 = time.time() - t0
# print('Time elapsed:', t1)
# print("x = ", res.x)
# print('f = ', res.fun)
# print(res.success)
# print(res.message)
x_long_star = res_f.x
x_lat_star = res_tau.x
return np.array([[res_f.x.item(0) + self.Fe], [res_tau.x.item(0)]])
def max_likelihood(size_dist, distribution_mean=None):
""" Returns the estimated mean, sd from size dist
Arguments
------------
size_dist: dict of the form {str: float or int} where the string is 'a_i-a_i+1' or 'a_n+' and the float or int is the proportion or number of companies in that bin.
(optional) distribution_mean: if the mean of the distribution is known then this is a constraint that can be used to improve the estimation.
"""
if distribution_mean is None:
result = minimize(lambda x: -likelihood(x, size_dist), (0.5, 1.5),
jac=lambda x: -likelihood_jacobian(x, size_dist),
bounds=Bounds([-np.inf, 0], [np.inf, np.inf]))
else:
result = minimize(
lambda x: -likelihood(x, size_dist), (0.5, 1.5),
jac=lambda x: -likelihood_jacobian(x, size_dist),
bounds=Bounds([-np.inf, 0], [np.inf, np.inf]),
constraints={
'type': 'eq',
'fun': lambda x: np.exp(x[0] + x[1]**2 / 2) - distribution_mean
})
#print(result)
if result.success:
return result.x
else:
return None
class TestBoundedNelderMead:
@pytest.mark.parametrize('bounds, x_opt', [
(Bounds(-np.inf, np.inf), Rosenbrock().x_opt),
(Bounds(-np.inf, -0.8), [-0.8, -0.8]),
(Bounds(3.0, np.inf), [3.0, 9.0]),
(Bounds([3.0, 1.0], [4.0, 5.0]), [3., 5.]),
])
def test_rosen_brock_with_bounds(self, bounds, x_opt):
prob = Rosenbrock()
with suppress_warnings() as sup:
sup.filter(UserWarning, "Initial guess is not within "
"the specified bounds")
result = minimize(prob.fun, [-10, -10],
method='Nelder-Mead',
bounds=bounds)
assert np.less_equal(bounds.lb, result.x).all()
assert np.less_equal(result.x, bounds.ub).all()
assert np.allclose(prob.fun(result.x), result.fun)
assert np.allclose(result.x, x_opt, atol=1.e-3)
def test_equal_all_bounds(self):
prob = Rosenbrock()
bounds = Bounds([4.0, 5.0], [4.0, 5.0])
with suppress_warnings() as sup:
sup.filter(UserWarning, "Initial guess is not within "
"the specified bounds")
result = minimize(prob.fun, [-10, 8],
method='Nelder-Mead',
bounds=bounds)
assert np.allclose(result.x, [4.0, 5.0])
def test_equal_one_bounds(self):
prob = Rosenbrock()
bounds = Bounds([4.0, 5.0], [4.0, 20.0])
with suppress_warnings() as sup:
sup.filter(UserWarning, "Initial guess is not within "
"the specified bounds")
result = minimize(prob.fun, [-10, 8],
method='Nelder-Mead',
bounds=bounds)
assert np.allclose(result.x, [4.0, 16.0])
def test_invalid_bounds(self):
prob = Rosenbrock()
with raises(ValueError,
match=r"one of the lower bounds is greater "
r"than an upper bound."):
bounds = Bounds([-np.inf, 1.0], [4.0, -5.0])
minimize(prob.fun, [-10, 3], method='Nelder-Mead', bounds=bounds)
@pytest.mark.xfail(reason="Failing on Azure Linux and macOS builds, "
"see gh-13846")
def test_outside_bounds_warning(self):
prob = Rosenbrock()
with raises(UserWarning,
match=r"Initial guess is not within "
r"the specified bounds"):
bounds = Bounds([-np.inf, 1.0], [4.0, 5.0])
minimize(prob.fun, [-10, 8], method='Nelder-Mead', bounds=bounds)
def __init__(self, name, weight_bounds=Bounds([0, 0], [1, 1])):
self.name = name
if bounds_re(name) is None:
raise Exception("re function is not implemented")
self.numVars, self.numObjs, self.numConstr, lower, upper = bounds_re(
name)
self.bounds = Bounds(lower, upper)
self.weight_bounds = weight_bounds # weighting of objectives
def minimizer_L1(self, x):
# D: (M, N)
D = x[1]
y = x[0].T
x0 = np.ones(D.shape[1], )
if (D.shape[0] < D.shape[1]):
# less observations than nodes
# Adjust the options' parameters to speed up when N >= 300
# see https://docs.scipy.org/doc/scipy/reference/optimize.minimize-slsqp.html#optimize-minimize-slsqp
options = {
'maxiter': 10,
'ftol': 1e-01,
'iprint': 1,
'disp': False,
'eps': 1.4901161193847656e-02
}
upcons = {
'type': 'ineq',
'fun': self.lessObsUpConstrain,
'args': (D, y)
}
cur_time = datetime.now()
result = minimize(self.square_sum,
x0,
args=(),
method='SLSQP',
jac=None,
bounds=Bounds(0, 1),
constraints=[upcons],
tol=None,
callback=None,
options=options)
logging.info("minimizer_L1 time:" +
str(datetime.now() - cur_time) + "," + str(options) +
" result.fun:" + str(result.fun) + ", " +
str(result.success) + ", " + str(result.message))
else:
logging.info("more observations than nodes")
result = minimize(self.moreObsfunc,
x0,
args=(D, y),
method='L-BFGS-B',
jac=None,
bounds=Bounds(0, 1),
tol=None,
callback=None,
options={
'disp': None,
'maxcor': 10,
'ftol': 2.220446049250313e-09,
'gtol': 1e-05,
'eps': 1e-08,
'maxfun': 15000,
'maxiter': 15000,
'iprint': -1,
'maxls': 20
})
return result.x
def solverprog(util, par):
""" Runs SLSQP optimizer for a parameterization for each piecewise linear part of the budget constraint (3),
and evaluates the kink points (2) aswell, then compares the utility of these 5 points, and returns the leisure consumption
associated with the highest utility bundle.
INPUT:
Util: Utility function of agents.
par: Parameters of the utility function (tuple if multipile); For cobddouglas an args=alpha (bt. 0 and 1),
For CES a 2-tuple, where par[0]=a and par[1]=r, 0<=a<=1 and r <=1.
OUTPUT
c^*: optimal leisure consumption (float)
"""
# Optimize behaviour in no tax bracket (l_bot < l < T):
guess_no = (goods(1 / 2 * (T - l_bot)), 1 / 2 * (T - l_bot))
best_notax = optimize.minimize(
util,
guess_no,
args=par,
method='SLSQP',
constraints=[budget_func(wage_prog, maxlabinc_prog, leiexp_prog)],
options={'disp': False},
bounds=Bounds((0, l_bot), (np.inf, T)))
# Optimize behaviour in low tax bracket ( l_top < l <l_bot):
guess_low = (goods(1 / 2 * (l_bot - l_top)), 1 / 2 * (l_bot - l_top))
best_lowtax = optimize.minimize(
util,
guess_low,
args=par,
method='SLSQP',
constraints=[budget_func(wage_prog, maxlabinc_prog, leiexp_prog)],
options={'disp': False},
bounds=Bounds((0, l_top), (np.inf, l_bot)))
#Optimize behaviour in top tax bracket ( 0 < l < l_top):
guess_high = (goods(1 / 2 * (l_top)), 1 / 2 * l_top)
best_hightax = optimize.minimize(
util,
guess_high,
args=par,
method='SLSQP',
constraints=[budget_func(wage_prog, maxlabinc_prog, leiexp_prog)],
options={'disp': False},
bounds=Bounds((0, 0), (np.inf, l_top)))
#Evaluate utility at kink point between no tax and low tax (util(l=l_bot, c=R_0-leiexp(l_bot,wage)):
Kink_bot = util(x_bot, par)
kink_top = util(x_top, par)
# Evaluate candidates and choose optimal bundle
candidates = np.array([
[best_notax.fun, best_notax.x[0], best_notax.x[1]],
[best_lowtax.fun, best_lowtax.x[0], best_lowtax.x[1]],
[best_hightax.fun, best_hightax.x[0], best_hightax.x[1]],
[Kink_bot, x_bot[0], x_bot[1]], [kink_top, x_top[0], x_top[1]]
]) # Create array with all candidates where first element is utility
# 2nd is the consumption bundle as a tuple.
best_cand = np.argmin(candidates,
axis=0) # exstract row number for best bundle.
return candidates[best_cand[0], 2] # returns only optimal leisure choice.
def stark_intervals(y,
K,
alpha,
h,
options_dict={'maxiter': 500},
method='slsqp'):
"""
Starks chi-sq intervals.
NOTE:
- data and K matrix are assumed to be Cholesky transformed
Parameters:
y (np arr) : m element array Cholesky trans observations
K (np arr) : mxn smearing matrix
alpha (float) : interval level
h (np arr) : n element functional on the parameters
options_dict (dict) : optimizer options
method (str) : optimizer method for scipy.optimize
Returns:
tuple -- lower/upper bound
"""
# dimensions of problem
m, n = K.shape
# find the chi-sq critical value
chisq_q = stats.chi(df=m).ppf(1 - alpha)
# define constraint
constr_stark = [{
'type': 'ineq',
'fun': lambda x: chisq_q - np.linalg.norm(y - K @ x)
}]
# find the bounds for full rank
stark_lb = minimize(fun=lambda x: np.dot(h, x),
x0=np.zeros(n),
constraints=constr_stark,
bounds=Bounds(lb=np.zeros(n), ub=np.ones(n) * np.inf),
method='slsqp',
options=options_dict)
stark_ub = minimize(fun=lambda x: -np.dot(h, x),
x0=np.zeros(n),
constraints=constr_stark,
bounds=Bounds(lb=np.zeros(n), ub=np.ones(n) * np.inf),
method='slsqp',
options=options_dict)
assert stark_lb['success']
assert stark_ub['success']
return stark_lb['fun'], -stark_ub['fun']
def solver_prog(util, par):
""" Runs SLSQP optimizer for a parameterization for each piecewise linear part of the budget constraint,
and evaluates the kink points aswell.
INPUT:
Util: Utility function of agents.
par: Parameters of the utility function (tuple if multipile); For cobddouglas an args=alpha (bt. 0 and 1),
For CES a 2-tuple, where par[0]=a and par[1]=r, 0<=a<=1 and r <=1.
"""
# Optimize behaviour in no tax bracket (l_bot < l < T):
best_notax = optimize.minimize(
util,
guess,
args=par,
method='SLSQP',
constraints=[budget_func(wage_prog, maxlabinc_prog, leiexp_prog)],
options={'disp': False},
bounds=Bounds((0, l_bot), (np.inf, T)))
# Optimize behaviour in low tax bracket ( l_top < l <l_bot):
best_lowtax = optimize.minimize(
util,
guess,
args=par,
method='SLSQP',
constraints=[budget_func(wage_prog, maxlabinc_prog, leiexp_prog)],
options={'disp': False},
bounds=Bounds((0, l_top), (np.inf, l_bot)))
#Optimize behaviour in top tax bracket ( 0 < l < l_top):
best_hightax = optimize.minimize(
util,
guess,
args=par,
method='SLSQP',
constraints=[budget_func(wage_prog, maxlabinc_prog, leiexp_prog)],
options={'disp': False},
bounds=Bounds((0, 0), (np.inf, l_top)))
#Evaluate utility at kink point between no tax and low tax (util(l=l_bot, c=R_0-leiexp(l_bot,wage)):
Kink_bot = util(goods_bot, l_bot)
kink_top = util(goods_top, l_top)
# Evaluate candidates and choose optimal bundle
candidates = np.array([
[best_notax.fun, best_notax.x[0], best_notax.x[1]],
[best_lowtax.fun, best_lowtax.x[0], best_lowtax.x[1]],
[best_hightax.fun, best_hightax.x[0], best_hightax.x[1]],
[Kink_bot, x_bot[0], x_bot[1]], [kink_top, x_top[0], x_top[1]]
]) # Create array with all candidates where first element is utility
# 2nd is the consumption bundle as a tuple.
best_cand = np.argmax(candidates,
axis=0) # Restract row number for best bundle.
return (candidates[best_cand[0], 1], candidates[best_cand[0], 2])
def __find_adv(self, model, x0, y0, lw, up):
def obj_func(x, model, y0):
output = model.apply(x).reshape(-1)
y0_score = output[y0]
output_no_y0 = output - np.eye(len(output))[y0] * 1e9
max_score = np.max(output_no_y0)
return y0_score - max_score
# print('Finding adversarial sample! Try {} times'.format(self.max_sus))
for i in range(self.max_sus):
if self.max_sus == 1:
x = x0.copy()
else:
x = generate_x(len(x0), lw, up)
args = (model, y0)
jac = grad(obj_func)
bounds = Bounds(lw, up)
res = minimize(obj_func, x, args=args, jac=jac, bounds=bounds)
if res.fun <= 0: # an adversarial sample is generated
valid = self.__validate_adv(model, res.x, y0)
assert valid
return res.x
return None
def _get_thresholds(stratifications: List[Tuple], means: pd.DataFrame,
sds: pd.DataFrame, weights_df: pd.DataFrame,
draw: int) -> pd.Series:
col = f'draw_{draw}'
thresholds = pd.Series(0, index=means.index, name=col)
ts = time.time()
print(f'Start: {ts}')
for i, stratification in enumerate(stratifications):
mu = means.loc[stratification, col]
sigma = sds.loc[stratification, col]
threshold = 0
if mu and sigma:
weights = weights_df.loc[stratification].reset_index()
weights = (weights[weights['parameter'] != 'glnorm'].
loc[:, ['parameter', 'value']].set_index(
'parameter').to_dict()['value'])
weights = {k: [v] for k, v in weights.items()}
ens_dist = EnsembleDistribution(weights=weights, mean=mu, sd=sigma)
threshold = minimize(lambda x: (ens_dist.ppf(x) - 7)**2, [0.5],
bounds=Bounds(0, 1.0),
method='Nelder-Mead').x[0]
print(f'mu: {mu}, sigma: {sigma}, threshold: {threshold}')
thresholds.loc[stratification] = threshold
tf = time.time()
print(f'End: {tf}')
print(f'Duration: {tf - ts}')
return thresholds
def test_solver():
X, y = load_breast_cancer(return_X_y=True)
clfs = [
LogisticRegression(solver="lbfgs", penalty="l1", warm_start=True),
LogisticRegression(solver="lbfgs",
penalty="elasticnet",
warm_start=True)
]
for clf in clfs:
with raises(ValueError):
clf.fit(X, y)
lb = np.r_[np.full(X.shape[1], -1), -np.inf]
ub = np.r_[np.zeros(X.shape[1]), np.inf]
bounds = Bounds(lb, ub)
clfs = [
LogisticRegression(solver="lbfgs", penalty="l1"),
LogisticRegression(solver="lbfgs", penalty="elasticnet")
]
for clf in clfs:
with raises(ValueError):
clf.fit(X, y, bounds=bounds)
lb = np.array([0.0])
ub = np.array([0.5])
A = np.zeros((1, X.shape[1] + 1))
A[0, :2] = np.array([-1, 1])
constraints = LinearConstraint(A, lb, ub)
for clf in clfs:
with raises(ValueError):
clf.fit(X, y, constraints=constraints)
def _fit_train(self, b: np.ndarray, A: np.ndarray, warm_start: bool=True) -> Any:
""" Fit method
Defines the model and fit it to the data.
Args
----
b: np.array, dtype float
A: np.ndarray, dtype float
mask: np.ndarray, dtype int | bool
mask_gray > 0.1
Return
------
reconstructor: Recontructor
The object after fit. To get the data access the attribute 'x' otherwise call fit_predict
Note
----
b, A and mask are not required if the proble has been previously formulated (e.g. if self.warmstart = True)
"""
x_guess = np.ones(A.shape[1]) * np.mean(b)/10.
bounds = Bounds(np.zeros_like(x_guess), np.full_like(x_guess, np.sum(b)/5.))
x = optimize.minimize(obj_logNbl1tv_grad, x0 = x_guess, args = (A, b, self.alpha, self.beta, self.sa, self.sb, self.r, self.ixs),
method="L-BFGS-B",jac=True, bounds=bounds).x
return x
def get_min(coefs, state_dim):
b = Bounds([0] * state_dim, [1] * state_dim)
res = scipy.optimize.minimize(poly_obj_fn,
0.5 * np.ones((state_dim, 1)),
args=coefs,
bounds=b)
return res.x, res.fun
def suggest(self, timeout=10):
x1 = np.expand_dims(self.top_points_real[0, ...], 0)
x1 = self.tr.continuous_transform(x1)
c0 = self.cost(x1)
x = self.tr.to_hyper_space(x1)
iter_time = 0
_iter_c = 0
_iter = cycle(self.top_points_real.tolist())
end_time = time.time() + timeout
_x0 = self.top_points_real[0, ...]
while (time.time() + 1.25 * iter_time) < end_time:
start_time = time.time()
dx = self.tr.random_continuous(1, self.random) * 0.01
x0 = _x0 + dx
ret = minimize(self.cost,
x0,
method="l-bfgs-b",
bounds=Bounds(self.tr._lb, self.tr._ub))
iter_time = time.time() - start_time
if ret.success:
_x = np.expand_dims(ret.x, 0)
x1 = self.tr.continuous_transform(_x)
c = self.cost(x1)
if c < c0:
c0 = c
x = self.tr.to_hyper_space(x1)
# print(_iter_c, c, x, dx)
_iter_c += 1
return {k: v[0][0] for k, v in x.items()}
def suggest(self, timeout=10):
x1 = self.tr.random_continuous(1, self.random)
x1 = self.tr.continuous_transform(x1)
c0 = self.cost(x1)
x = self.tr.to_hyper_space(x1)
end_time = time.time() + timeout
iter_time = 0
_iter = 0
while (time.time() + 1.25 * iter_time) < end_time:
start_time = time.time()
x0 = self.tr.random_continuous(1, self.random)
ret = minimize(self.cost,
x0,
method="l-bfgs-b",
bounds=Bounds(self.tr._lb, self.tr._ub))
iter_time = time.time() - start_time
if ret.success:
x1 = self.tr.continuous_transform(ret.x.reshape(1, -1))
c = self.cost(x1)
if c < c0:
c0 = c
x = self.tr.to_hyper_space(x1)
# print(_iter, c, x,)
_iter += 1
return {k: v[0][0] for k, v in x.items()}
def test_bounds_class(self):
# test that result does not depend on the bounds type
def func(x):
f = np.sum(x * x - 10 * np.cos(2 * np.pi * x)) + 10 * np.size(x)
return f
lw = [-5.12] * 5
up = [5.12] * 5
# Unbounded global minimum is all zeros. Most bounds below will force
# a DV away from unbounded minimum and be active at solution.
up[0] = -2.0
up[1] = -1.0
lw[3] = 1.0
lw[4] = 2.0
# run optimizations
bounds = Bounds(lw, up)
ret_bounds_class = dual_annealing(func, bounds=bounds, seed=1234)
bounds_old = list(zip(lw, up))
ret_bounds_list = dual_annealing(func, bounds=bounds_old, seed=1234)
# test that found minima, function evaluations and iterations match
assert_allclose(ret_bounds_class.x, ret_bounds_list.x, atol=1e-8)
assert_allclose(ret_bounds_class.x, np.arange(-2, 3), atol=1e-7)
assert_allclose(ret_bounds_list.fun, ret_bounds_class.fun, atol=1e-9)
assert ret_bounds_list.nfev == ret_bounds_class.nfev
def internal_optimization(self) -> OptimizeResult:
"""
method to do internal optimization process, with a hyperpath setted you can get a optimization of the network
:return: res : OptimizeResult
The optimization result represented as a ``OptimizeResult`` object.
Important attributes are: ``x`` the solution array, ``success`` a
Boolean flag indicating if the optimizer exited successfully and
``message`` which describes the cause of the termination. See
`OptimizeResult` for a description of other attributes.
"""
constr_func = lambda fopt: np.array(self.get_constrains(fopt))
lb = [-1 * np.inf] * self.len_constrains
ub = [0] * self.len_constrains
nonlin_con = NonlinearConstraint(constr_func, lb=lb, ub=ub)
lb = [0] * self.len_var
ub = [np.inf] * self.len_var
bounds = Bounds(lb=lb, ub=ub)
res = minimize(self.VRC, self.f_opt, method='trust-constr', constraints=nonlin_con, tol=0.01, bounds=bounds)
logger.info(self.string_information_internal_optimization(res))
return res
def get_pow(self, S, controller='P', dof=2):
Fexc = self.get_waveExcitation(S)['Fexc'].isel(influenced_dof=dof).squeeze()
Zi = self.hydro['Zi'].isel(dict(influenced_dof=dof,
radiating_dof=dof)).squeeze()
if controller == 'P':
def dampingPower(x):
P = -0.5 * x[0] * np.sum(np.abs(Fexc / (Zi + x[0]))**2)
fval = P.values[()]
return fval
x0 = [1e-10]
bounds = Bounds(lb=0, ub=np.inf)
res = minimize(dampingPower,
x0,
method='L-BFGS-B',
bounds=bounds,
options={
'disp': False,
# 'maxiter': 10,
})
return res.fun
def bounds_constr(self):
""" Create bound constraints."""
number_wells = self.res_param["nb_prod"] + self.res_param["nb_inj"]
number_cycles = self.res_param["nb_cycles"]
lower = np.zeros((number_cycles * number_wells, 1))
upper = np.ones((number_cycles * number_wells, 1))
return Bounds(lower, upper)
def growth(x, y, f, noise='gamma', init=None):
def loglik(x, y, f, p):
a, b, c, w0, w1, scale = p
_mu = logistic(x, f, [a, b, c, w0, w1])
if noise == 'gamma':
return -np.sum(gamma.logpdf(y, np.maximum(_mu / scale, 1e-12), scale=scale))
if noise == 'normal':
return -np.sum(norm.logpdf(y, loc=_mu, scale=scale))
fx = lambda p: loglik(x, y, f, p)
lb = np.ones((6,)) * 0.00001
lb[2] = 1
lb[3] = -np.inf
lb[4] = -np.inf
ub = np.ones((6,)) * np.inf
bounds = Bounds(lb, ub)
if init is None:
init = [np.nanmean(y), 0.1, 10, 0, 0, np.nanstd(y)]
options_trust = {'maxiter': 10000}
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=UserWarning)
result = minimize(fx, init, bounds=bounds, method='trust-constr', options=options_trust)
if result.success is False:
print('optimization failed')
return GrowthModel(result, noise, x, y, f)
def compute_opt_ratios(self, workloads, init_ratios, new_idd):
el_time = time.time() * 1000 - self.last_time
ideal_mems = np.array([w.ideal_mem for w in workloads])
percents = np.array([(1 - (w.idd == new_idd)) * min(
(w.percent + el_time / w.profile(w.ratio)) /
self.slow_downs[w.wname], 0.95) for w in workloads])
profiles = [w.profile for w in workloads]
mem_gradients = [w.mem_gradient for w in workloads]
gradients = [w.gradient for w in workloads]
x0 = np.array(init_ratios)
eq_cons = {
'type': 'eq',
'fun': eq,
'jac': eq_grad,
'args': (ideal_mems, self.total_mem)
}
bounds = Bounds(0.5, 1.0)
beta = 0
res = minimize(obj_new,
x0,
method='SLSQP',
jac=obj_grad_new,
args=(ideal_mems, percents, profiles, gradients,
mem_gradients, beta),
constraints=eq_cons,
options={'disp': False},
bounds=bounds)
final_ratios = res.x
return np.round(final_ratios, 3), res.fun
def fit(self, y, v, X):
"""Fit the estimator to data."""
# use D-L estimate for initial values
est_DL = DerSimonianLaird().fit(y, v, X).params_
beta = est_DL["fe_params"]
tau2 = est_DL["tau2"]
theta_init = np.r_[beta.ravel(), tau2]
lb = np.ones(len(theta_init)) * -np.inf
ub = -lb
lb[-1] = 0.0 # bound only the variance
bds = Bounds(lb, ub, keep_feasible=True)
res = minimize(self._nll_func,
theta_init, (y, v, X),
bounds=bds,
**self.kwargs)
beta, tau = res.x[:-1], float(res.x[-1])
tau = np.max([tau, 0])
_, inv_cov = weighted_least_squares(y, v, X, tau, True)
self.params_ = {
"fe_params": beta[:, None],
"tau2": tau,
"inv_cov": inv_cov
}
return self
def match_expectation(size_dist):
result = minimize(lambda x: expectation_difference(x, size_dist), (0, 1),
bounds=Bounds([-np.inf, 0], [np.inf, np.inf]))
if result.success:
return result.x
else:
return None
def fit(self, y, n, X):
"""Fit the estimator to data."""
if n.std() < np.sqrt(np.finfo(float).eps):
raise ValueError("Sample size-based likelihood estimator cannot "
"work with all-equal sample sizes.")
if n.std() < n.mean() / 10:
raise Warning(
"Sample sizes are too close, sample size-based likelihood estimator may fail."
)
# set tau^2 to 0 and compute starting values
tau2 = 0.0
k, p = X.shape
beta = weighted_least_squares(y, n, X, tau2)
sigma = ((y - X.dot(beta))**2 * n).sum() / (k - p)
theta_init = np.r_[beta.ravel(), sigma, tau2]
lb = np.ones(len(theta_init)) * -np.inf
ub = -lb
lb[-2:] = 0.0 # bound only the variances
bds = Bounds(lb, ub, keep_feasible=True)
res = minimize(self._nll_func,
theta_init, (y, n, X),
bounds=bds,
**self.kwargs)
beta, sigma, tau = res.x[:-2], float(res.x[-2]), float(res.x[-1])
tau = np.max([tau, 0])
_, inv_cov = weighted_least_squares(y, sigma / n, X, tau, True)
self.params_ = {
"fe_params": beta[:, None],
"sigma2": np.array(sigma),
"tau2": tau,
"inv_cov": inv_cov,
}
return self
def _retry_loop(pid,
rgs,
store,
optimize,
value_limit,
stop_fitness=-math.inf):
fun = store.wrapper if store.statistic_num > 0 else store.fun
#reinitialize logging config for windows - multi threading fix
if 'win' in sys.platform and not store.logger is None:
store.logger = logger()
while store.get_runs_compare_incr(
store.num_retries) and store.best_y.value > stop_fitness:
if _crossover(fun, store, optimize, rgs[pid]):
continue
try:
rg = rgs[pid]
dim = len(store.lower)
sol, y, evals = optimize(fun, Bounds(store.lower,
store.upper), None,
[rg.uniform(0.05, 0.1)] * dim, rg, store)
store.add_result(y, sol, store.lower, store.upper, evals,
value_limit)
except Exception as ex:
continue
def optimize(num_iter, init_p, init_err, M, m, c_1, c_2):
""" This method is used to iteratively optimize obj_func_p and obj_func_err. The estimated parameters are used for alternative hypothesis test"""
estimated_err = [init_err]
estimated_p = [init_p]
p_bound = Bounds(0.5, 0.9)
e_bound = Bounds(1e-100, 0.3)
opts = {'disp':False, 'gtol':1e-100}
for i in range(num_iter):
# estimate proportion of a major strain given estimated error
res_p = minimize(obj_func_p, [init_p], args = (estimated_err[i], M, m, c_1, c_2), method='TNC',bounds=p_bound, options=opts)
estimated_p.append(res_p.x[0])
# estimate error given proportion
res_err = minimize(obj_func_err, [init_err], args = (estimated_p[i], M, m, c_1, c_2), method='TNC', bounds=e_bound, options=opts)
estimated_err.append(res_err.x[0])
return [estimated_p, estimated_err]
def initial_setup(filename, tn, dtype, space_order, nbl, datakey="m0", exclude_boundaries=True, water_depth=20):
model = overthrust_model_iso(filename, datakey=datakey, dtype=dtype, space_order=space_order, nbl=nbl)
geometry = create_geometry(model, tn)
nbl = model.nbl
if exclude_boundaries:
v = trim_boundary(model.vp, model.nbl)
else:
v = model.vp.data
# Define physical constraints on velocity - we know the maximum and minimum velocities we are expecting
vmax = np.ones(v.shape) * 6.5
vmin = np.ones(v.shape) * 1.3
# Constrain the velocity for the water region. We know the velocity of water beforehand.
if exclude_boundaries:
vmax[:, 0:water_depth] = v[:, 0:water_depth]
vmin[:, 0:water_depth] = v[:, 0:water_depth]
else:
vmax[:, 0:water_depth+nbl] = v[:, 0:water_depth+nbl]
vmin[:, 0:water_depth+nbl] = v[:, 0:water_depth+nbl]
b = Bounds(mat2vec(vmin), mat2vec(vmax))
return model, geometry, b
def vertical_tail(plane, req, s, u, tol=10e-4):
zeta_dr_req = req['stability_and_control']['zeta_dr']
c_n_b_req = req['stability_and_control']['c_n_b']
alpha = arctan(s[2] / s[0])
a = Atmosphere(s[-1]).speed_of_sound()
def obj(x):
return x[0]
def constraint(x):
plane['vertical']['planform'] = x[0]
c_n_b = directional_stability(plane, s[0] / a, alpha)
zeta_dr, omega_dr = dutch_roll_mode(plane, s, u)
c = array([zeta_dr - zeta_dr_req, c_n_b - c_n_b_req])
return c
lim = Bounds(0.1, float(plane['wing']['planform']))
x0 = array([float(plane['vertical']['planform'])])
ineq_con = {'type': 'ineq', 'fun': constraint}
u_out = minimize(obj,
x0,
bounds=lim,
tol=tol,
constraints=ineq_con,
options=({
'maxiter': 200
}))
return u_out['x'][0]
def run_least_squares(self):
"""
Run least squares minimization algorithm to calibrate model parameters.
"""
lower_bounds = []
upper_bounds = []
x0 = []
for prior in self.priors:
lower_bound, upper_bound = get_parameter_bounds_from_priors(prior)
lower_bounds.append(lower_bound)
upper_bounds.append(upper_bound)
if not any([math.isinf(lower_bound), math.isinf(upper_bound)]):
x0.append(0.5 * (lower_bound + upper_bound))
elif all([math.isinf(lower_bound), math.isinf(upper_bound)]):
x0.append(0.0)
elif math.isinf(lower_bound):
x0.append(upper_bound)
else:
x0.append(lower_bound)
bounds = Bounds(lower_bounds, upper_bounds)
sol = minimize(self.loglikelihood, x0, bounds=bounds)
self.mle_estimates = sol.x
# FIXME: need to fix dump_mle_params_to_yaml_file
logger.info("Best solution: %s", self.mle_estimates)
def _update_Z(self, A, Z):
n, n_archetypes = A.shape
# build the vbar matrix used in the CLS problem
mask = np.eye(n_archetypes, dtype=bool)
before_dot_products = A[:, :, None] * Z
V = self.X[:, :, None] - np.tensordot(
before_dot_products, ~mask, axes=[1, 0])
#V = self.X - A[:,None][~mask].dot(Z)
diagonal = A.dot(mask)
diagonal[diagonal == 0] = commons.EPSILON
V /= diagonal[:, None, :]
A2 = A**2
vbar = (np.einsum("ir,ipr->pr", A2, V) / A2.sum(axis=0)).T
# solve a CLS problem for archetypes coefficients
beta = np.zeros_like(A.T)
new_Z = np.zeros_like(Z)
for l in range(n_archetypes):
bounds = Bounds(np.zeros(n), np.ones(n))
ones = np.array(1)
constraint = LinearConstraint(np.ones(n).T, ones, ones)
res = minimize(lambda beta: commons._least_squares_cost(
vbar[l], self.X, beta),
self.beta[l],
method="SLSQP",
bounds=bounds,
constraints=[constraint])
beta[l] = res.x
new_Z[l] = beta[l].dot(self.X)
return beta, new_Z
