def optimize(self, init_guess=None, opti_algo='grid', record_data=False):
"""
runs automatic optimization of thetas and ps
:param init_guess: list of input values for an initial guess
:param opti_algo: string for the algorithm to use 'grid' (self implemented LikeliOptimizer) or 'basin' (using scipy.optimize.basin-hopping)
:param record_data: if True the test points of the optimizer gets recorded (this is needed for plot of optimizer path in plot_likelihoods)
:return: None
"""
timer = TimeTrack('optiTimer')
self.records = None
if record_data:
self.records = []
if 'basin' in opti_algo:
# basinhopping:
if init_guess is None:
init_guess = []
for t in self._theta:
init_guess.append(t)
for p in self._p:
init_guess.append(p)
bnds = []
for i in range(0, self._k):
bnds.append((-5., +5.))
for i in range(0, self._k):
bnds.append((1., 2.))
bounds = BasinHoppingBounds(xmax=list(zip(*bnds))[1],
xmin=list(zip(*bnds))[0])
step = BasinHoppingStep()
minimizer_kwargs = dict(method='SLSQP',
bounds=bnds,
options={
'disp': False,
'maxiter': 5e3
},
tol=1e-4)
timer.tic()
res = basinhopping(self._calc_likelihood_opti_exp,
init_guess,
minimizer_kwargs=minimizer_kwargs,
accept_test=bounds,
take_step=step,
niter=1000,
niter_success=100)
timer.toc(print_it=True)
elif 'grid' in opti_algo:
skipper = LikeliOptimizer(debug=True)
timer.tic()
res = skipper.find(self._calc_likelihood_opti_exp, self._k)
timer.toc(print_it=True)
else:
raise Exception('ERROR: unknown optimizer selected')
exps = res.x[0:self._k]
thetas = []
for e in exps:
thetas.append(10.**e)
if record_data:
print('Kriging Likelihood optimization evaluations: {:d}'.format(
len(self.records)))
self.update_param(thetas, res.x[self._k:])
def auto_run(self,
sampling_type,
sample_point_count,
surro_type,
run_validation=True,
auto_fit=True,
params=[],
sequential_runs=0):
"""
runs whole surrogate process
:param sampling_type: index of the sampling type (definition in defines.py)
:param sample_point_count: number of sampling points
:param surro_type: index of the surrogate type (definition in defines.py)
:param run_validation: run all validations (rmse, mae, press, avg-deviation)
:param auto_fit: auto fit RBF and polynom surrogate by using validation
:param params: adiational parameters to pass to the surrogate algorithm
:param sequential_runs: number of sequential runs (add found optimum to sampling plan and build a new surrogate including the prev. optimum)
:return: results as instance of SurroResults, pointer to the surrogate model instance
"""
suc = self.generate_sampling_plan(sampling_type, sample_point_count)
if not suc:
return self.results, None
self.run_validation_points()
for i in range(0, sequential_runs + 1):
if self.results.optimum_weight > 0.:
self.known_params = np.append(
self.known_params,
[[self.results.optimum_rib, self.results.optimum_shell]],
axis=0)
self._generate_scaled_sampling_points()
self.run_fem_calculation()
fit_time = TimeTrack('FitTime')
fit_time.tic()
if surro_type == SURRO_POLYNOM and auto_fit:
suc = self.auto_fit_poly()
elif surro_type == SURRO_RBF and auto_fit:
suc = self.auto_fit_rbf(params=params)
else:
suc = self.train_model(surro_type, params=params)
self.results.runtime = fit_time.toc()
if not suc:
return self.results, None
self.optimize()
if run_validation:
self.run_validation_points(flip_points=True)
self.run_validation(full_validation=True)
self.print_results()
if self.show_plots:
self.plot_it()
return self.results, self.surro
likely[i2][i1] = krig.calc_likelihood()
krig.optimize(opti_algo='basin')
minLike = krig.calc_likelihood()
print('minLike = ' + str(minLike))
print('@theta1 = ' + str(krig._theta[0]))
print('@theta2 = ' + str(krig._theta[1]))
pltTheta = PlotHelper([r'$\theta_{1}$', r'$\theta_{1}$'], fancy=False)
pltTheta.ax.set_xscale('log')
pltTheta.ax.set_yscale('log')
pcol = pltTheta.ax.pcolor(thetas, thetas, likely)
pltTheta.fig.colorbar(pcol)
pltTheta.ax.plot(krig._theta[0], krig._theta[1], 'rx')
pltTheta.finalize()
#pltTheta.show()
plt1.plot_function_3d(krig.predict,
fx,
fy,
r'$\widehat{f}_{krig}$',
color='b')
plt1.ax.view_init(20, 50)
plt1.finalize()
#plt1.save('data_out/krigingRn.svg')
#plt1.save('data_out/krigingRn.pdf')
#plt1.animate()
t1.toc()
plt1.show()
print('done')
pro1.solve_abaqus()
pro1.post_process_abaqus()
print('min displacement: ' + str(pro1.resultsAba.dispD3Min))
print('max displacement: ' + str(pro1.resultsAba.dispD3Max))
print('min mieses stress: ' + str(pro1.resultsAba.stressMisesMin))
print('max mieses stress: ' + str(pro1.resultsAba.stressMisesMax))
print('weight: ' + str(pro1.calc_wight()))
pro1.errorFlag = False
pro1.solve()
if not pro1.errorFlag:
pro1.post_process()
#pro1.post_process(template='wing_post_max_mises_fixed')
if not pro1.errorFlag:
runTime = t.toc()
print('min displacement: ' + str(pro1.resultsCalcu.dispD3Min))
print('max displacement: ' + str(pro1.resultsCalcu.dispD3Max))
print('min mieses stress: ' + str(pro1.resultsCalcu.stressMisesMin))
print('max mieses stress: ' + str(pro1.resultsCalcu.stressMisesMax))
print('weight: ' + str(pro1.calc_wight()))
#l = pro1.validate_load('load.frc')
l = pro1.validate_load('loadTop.frc')
l += pro1.validate_load('loadBot.frc')
print('load error: ' + str((-1. * wing_load) - l))
pro1.save_results()
print('done')