def test_optimise_eq_constrained_function2(self): n = 2 N = 20 value = 2.0 X = np.random.uniform(-1.0, 1.0, (N, n)) # Function values for f and Poly object f = self.ObjFun(X) fparam = eq.Parameter(distribution='uniform', lower=-1., upper=1., order=self.degf) fParameters = [fparam for i in range(n)] myBasis = eq.Basis('total-order') fpoly = eq.Poly(fParameters, myBasis, method='least-squares', sampling_args={ 'sample-points': X, 'sample-outputs': f }) fpoly.set_model() g1Func = lambda x: value - self.ConFun1(x.reshape(1, -1)) for method in ['trust-constr', 'SLSQP']: Opt = eq.Optimisation(method=method) Opt.add_objective(poly=fpoly) Opt.add_nonlinear_eq_con(custom={'function': g1Func}) x0 = np.zeros(n) sol = Opt.optimise(x0) if sol['status'] == 0: np.testing.assert_almost_equal(sol['x'].flatten(), np.array([1.0, 1.0]), decimal=2)
def test_optimise_custom_function_linear_ineq_con2(self): n = 2 N = 20 X = np.random.uniform(-1.0, 1.0, (N, n)) # Function values for f and Poly object f = self.ObjFun(X) fparam = eq.Parameter(distribution='uniform', lower=-1., upper=1., order=self.degf) fParameters = [fparam for i in range(n)] myBasis = eq.Basis('total-order') fpoly = eq.Poly(fParameters, myBasis, method='least-squares', sampling_args={ 'sample-points': X, 'sample-outputs': f }) fpoly.set_model() for method in ['COBYLA', 'SLSQP', 'trust-constr']: Opt = eq.Optimisation(method=method) Opt.add_objective(poly=fpoly) Opt.add_linear_ineq_con(np.eye(n), -np.ones(n), np.inf * np.ones(n)) x0 = np.random.uniform(-1.0, 1.0, n) sol = Opt.optimise(x0) if sol['status'] == 0: np.testing.assert_almost_equal(sol['x'].flatten(), np.array([1.0, 1.0]), decimal=3)
def test_optimise_omorf_as(self): n = 10 Opt = eq.Optimisation(method='omorf') Opt.add_objective(custom={'function': self.ObjFun2}) x0 = -2 * np.ones(n) sol = Opt.optimise(x0, del_k=0.1) # print(sol) np.testing.assert_almost_equal(sol['fun'], -39.1661656 * n, decimal=4)
def test_optimise_trustregion_random(self): n = 2 Opt = eq.Optimisation(method='trust-region') Opt.add_objective(custom={'function': self.ObjFun1}) x0 = np.zeros(n) sol = Opt.optimise(x0, del_k=0.1, random_initial=True) # print(sol) np.testing.assert_almost_equal(sol['fun'], 0.0, decimal=4)
def test_optimise_trustregion_bounds(self): n = 2 Opt = eq.Optimisation(method='trust-region') Opt.add_objective(custom={'function': self.ObjFun1}) Opt.add_bounds(-np.ones(n), np.ones(n)) x0 = np.zeros(n) sol = Opt.optimise(x0) # print(sol) np.testing.assert_almost_equal(sol['fun'], 0.0, decimal=6)
def test_optimise_custom_function_bounds_maximise(self): n = 2 for method in ['L-BFGS-B', 'TNC', 'COBYLA', 'SLSQP']: Opt = eq.Optimisation(method=method) Opt.add_objective( custom={'function': lambda x: self.ConFun1(x.reshape(1, -1))}, maximise=True) Opt.add_bounds(-np.ones(n), np.ones(n)) x0 = np.zeros(n) sol = Opt.optimise(x0) np.testing.assert_almost_equal(sol['x'].flatten(), np.array([1.0, 1.0]), decimal=3)
def test_optimise_constrained_poly2(self): n = 2 N = 20 bounds = [0.0, np.inf] X = np.random.uniform(-1.0, 1.0, (N, n)) # Function values for f and Poly object f = self.ObjFun1(X) fparam = eq.Parameter(distribution='uniform', lower=-1., upper=1., order=self.degf) fParameters = [fparam for i in range(n)] myBasis = eq.Basis('total-order') fpoly = eq.Poly(fParameters, myBasis, method='least-squares', sampling_args={ 'mesh': 'user-defined', 'sample-points': X, 'sample-outputs': f }) fpoly.set_model() # Active subspace and values for g1 g1 = self.ConFun1(X) g1param = eq.Parameter(distribution='uniform', lower=-1., upper=1., order=self.degg1) g1Parameters = [g1param for i in range(n)] myBasis = eq.Basis('total-order') g1poly = eq.Poly(g1Parameters, myBasis, method='least-squares', sampling_args={ 'mesh': 'user-defined', 'sample-points': X, 'sample-outputs': g1 }) g1poly.set_model() for method in ['trust-constr', 'SLSQP', 'COBYLA']: Opt = eq.Optimisation(method=method) Opt.add_objective(poly=fpoly) Opt.add_bounds(-np.ones(n), np.ones(n)) Opt.add_nonlinear_ineq_con({'poly': g1poly, 'bounds': bounds}) x0 = np.zeros(n) sol = Opt.optimise(x0) if sol['status'] == 0: np.testing.assert_almost_equal(sol['x'].flatten(), np.array([1.0, 1.0]), decimal=2)
def test_optimise_trustregion_maximise_bounds(self): n = 2 def StyblinskiTang(s): n = s.size f = 0 for i in range(n): f += 0.5 * (s[i]**4 - 16.0 * s[i]**2 + 5.0 * s[i]) return f Opt = eq.Optimisation(method='trust-region') Opt.add_objective(custom={'function': StyblinskiTang}, maximise=True) Opt.add_bounds(-np.ones(n), np.ones(n)) x0 = np.zeros(n) sol = Opt.optimise(x0) np.testing.assert_almost_equal(sol['x'].flatten(), np.array([0.16, 0.16]), decimal=2)
def test_optimise_ineq_constrained_function1(self): n = 2 N = 20 bounds = [-np.inf, 2.0] X = np.random.uniform(-1.0, 1.0, (N, n)) f = self.ObjFun1(X) fparam = eq.Parameter(distribution='uniform', lower=-1., upper=1., order=self.degf) fParameters = [fparam for i in range(n)] myBasis = eq.Basis('total-order') fpoly = eq.Poly(fParameters, myBasis, method='least-squares', sampling_args={ 'mesh': 'user-defined', 'sample-points': X, 'sample-outputs': f }) fpoly.set_model() g1Func = lambda x: bounds[1] - self.ConFun1(x.reshape(1, -1)) g1Grad = lambda x: -self.ConFun1_Deriv(x.flatten()) g1Hess = lambda x: -self.ConFun1_Hess(x.flatten()) for method in ['trust-constr', 'SLSQP']: Opt = eq.Optimisation(method=method) Opt.add_objective(poly=fpoly) Opt.add_nonlinear_ineq_con( custom={ 'function': g1Func, 'jac_function': g1Grad, 'hess_function': g1Hess }) Opt.add_linear_eq_con(np.eye(n), np.ones(n)) x0 = np.zeros(n) sol = Opt.optimise(x0) if sol['status'] == 0: np.testing.assert_almost_equal(sol['x'].flatten(), np.array([1.0, 1.0]), decimal=2)
def compare_optimisation(fun, s0, bounds): dims = s0.size Opt = eq.Optimisation(method='trust-region') Opt.add_objective(custom={'function': fun}) Opt.add_bounds(bounds[0], bounds[1]) sol = Opt.optimise(s0) print( "Using the trust-region method, an optimal value of {} was found after {} function evaluations" .format(sol['fun'], sol['nfev'])) bounds_2 = [] for i in range(dims): bounds_2.append((bounds[0][i], bounds[1][i])) sol = differential_evolution(fun, bounds_2) print( "Using differential evolution, an optimal value of {} was found after {} function evaluations" .format(sol['fun'], sol['nfev'])) cons = [] for factor in range(len(bounds)): lower, upper = bounds_2[factor] l = {'type': 'ineq', 'fun': lambda x, lb=lower, i=factor: x[i] - lb} u = {'type': 'ineq', 'fun': lambda x, ub=upper, i=factor: ub - x[i]} cons.append(l) cons.append(u) sol = minimize(fun, s0, method='COBYLA', constraints=cons, tol=1.0e-8, options={ 'rhobeg': 1.0, 'maxiter': 100000, 'disp': False, 'catol': 1.0e-8 }) print( "Using COBYLA, an optimal value of {} was found after {} function evaluations" .format(sol['fun'], sol['nfev']))