def test_cantilever_beam_gradients(self): benchmark = setup_benchmark('cantilever_beam') from pyapprox.models.wrappers import ActiveSetVariableModel fun = ActiveSetVariableModel( benchmark.fun, benchmark.variable.num_vars() + benchmark.design_variable.num_vars(), benchmark.variable.get_statistics('mean'), benchmark.design_var_indices) jac = ActiveSetVariableModel( benchmark.jac, benchmark.variable.num_vars() + benchmark.design_variable.num_vars(), benchmark.variable.get_statistics('mean'), benchmark.design_var_indices) init_guess = 2 * np.ones((2, 1)) errors = pya.check_gradients(fun, jac, init_guess, disp=True) assert errors.min() < 4e-7 constraint_fun = ActiveSetVariableModel( benchmark.constraint_fun, benchmark.variable.num_vars() + benchmark.design_variable.num_vars(), benchmark.variable.get_statistics('mean'), benchmark.design_var_indices) constraint_jac = ActiveSetVariableModel( benchmark.constraint_jac, benchmark.variable.num_vars() + benchmark.design_variable.num_vars(), benchmark.variable.get_statistics('mean'), benchmark.design_var_indices) init_guess = 2 * np.ones((2, 1)) errors = pya.check_gradients(constraint_fun, constraint_jac, init_guess, disp=True) assert errors.min() < 4e-7 nsamples = 10 samples = pya.generate_independent_random_samples( benchmark.variable, nsamples) constraint_fun = ActiveSetVariableModel( benchmark.constraint_fun, benchmark.variable.num_vars() + benchmark.design_variable.num_vars(), samples, benchmark.design_var_indices) constraint_jac = ActiveSetVariableModel( benchmark.constraint_jac, benchmark.variable.num_vars() + benchmark.design_variable.num_vars(), samples, benchmark.design_var_indices) init_guess = 2 * np.ones((2, 1)) errors = pya.check_gradients( lambda x: constraint_fun(x).flatten(order='F'), constraint_jac, init_guess, disp=True) assert errors.min() < 4e-7
def test_piston_gradient(self): benchmark = setup_benchmark("piston") sample = pya.generate_independent_random_samples(benchmark.variable, 1) print(benchmark.jac(sample)) errors = pya.check_gradients(benchmark.fun, benchmark.jac, sample) errors = errors[np.isfinite(errors)] assert errors.max() > 0.1 and errors.min() <= 6e-7
def test_evaluate_gradient_2d(self): """ for the PDE ((1+sum(z^2)*x)*u(x)')' = -2, u(0) = 0, u(1) = 1 use model.evaluate_gradient to evaluate the gradient of the QoI with respect to the random parameter vector z. The QoI is the intergral of the solution over the entire domain The adjoint rhs is then just 1. """ order = 20 model = SteadyStateDiffusionEquation2D() lims = [0., 1., 0., 1.] bndry_cond = [0., 0.] model.initialize(order, bndry_cond, lims) model.diffusivity_function = \ lambda x, z: (z[0]**2+z[1]**2)*(x[0]+x[1]) + 1. model.forcing_function = lambda x, z: 0*x[0]-2 sample = np.random.RandomState(2).uniform(-1, 1, (2, 1)) model.diffusivity_derivs_function = \ lambda x, z, i: np.array([2.*(x[0]+x[1])*z[i]]).T model.forcing_derivs_function = \ lambda x, z, i: np.array([0.*x[0]]).T model(sample) # evaluate_gradient has to be called before any more calls to # model.solve with different parameters, because we need to # access self.fwd_solution, which will change with any subsuquent calls errors = pya.check_gradients( model, lambda x: model.evaluate_gradient(x[:, 0]), sample) errors = errors[np.isfinite(errors)] assert errors.max() > 0.1 and errors.min() <= 4e-6
def test_wing_weight_gradient(self): variable = define_wing_weight_random_variables() fun = wing_weight_function grad = wing_weight_gradient sample = pya.generate_independent_random_samples(variable, 1) errors = pya.check_gradients(fun, grad, sample) errors = errors[np.isfinite(errors)] assert errors.max() > 0.1 and errors.min() <= 6e-7
def test_r_oed_objective_and_constraint_wrappers(self): poly_degree = 10 num_design_pts = 101 num_pred_pts = 51 pred_samples = np.random.uniform(-1, 1, num_pred_pts) design_samples = np.linspace(-1, 1, num_design_pts) design_factors = univariate_monomial_basis_matrix( poly_degree, design_samples) pred_factors = univariate_monomial_basis_matrix( poly_degree, pred_samples) homog_outer_prods = compute_homoscedastic_outer_products( design_factors) goptimality_criterion_wrapper = partial(goptimality_criterion, homog_outer_prods, design_factors, pred_factors) mu = np.random.uniform(0, 1, (num_design_pts)) mu /= mu.sum() obj, jac = goptimality_criterion_wrapper(mu) beta = 0.75 pred_weights = np.ones(num_pred_pts) / num_pred_pts r_oed_objective_wrapper = partial(r_oed_objective, beta, pred_weights) r_oed_jac_wrapper = partial(r_oed_objective_jacobian, beta, pred_weights) x0 = np.concatenate([np.ones(num_design_pts + 1), mu])[:, np.newaxis] diffs = pya.check_gradients(r_oed_objective_wrapper, r_oed_jac_wrapper, x0) assert diffs.min() < 6e-5, diffs r_oed_constraint_wrapper = partial( r_oed_constraint_objective, num_design_pts, lambda x: goptimality_criterion_wrapper(x)[0]) r_oed_constraint_jac_wrapper = partial( r_oed_constraint_jacobian, num_design_pts, lambda x: goptimality_criterion_wrapper(x)[1]) x0 = np.concatenate([np.ones(num_pred_pts + 1), mu])[:, np.newaxis] from pyapprox import approx_jacobian print(x0.shape) approx_jacobian(r_oed_constraint_wrapper, x0[:, 0]) diffs = pya.check_gradients(r_oed_constraint_wrapper, r_oed_constraint_jac_wrapper, x0) assert diffs.min() < 6e-5, diffs
def test_rosenbrock_function_gradient_and_hessian_prod(self): benchmark = setup_benchmark("rosenbrock", nvars=2) init_guess = benchmark.variable.get_statistics('mean')+\ benchmark.variable.get_statistics('std') errors = pya.check_gradients(benchmark.fun, benchmark.jac, init_guess, disp=False) assert errors.min() < 1e-5 errors = pya.check_hessian(benchmark.jac, benchmark.hessp, init_guess, disp=False) assert errors.min() < 1e-5
def test_ishigami_function_gradient_and_hessian(self): benchmark = setup_benchmark("ishigami", a=7, b=0.1) init_guess = benchmark.variable.get_statistics('mean')+\ benchmark.variable.get_statistics('std') errors = pya.check_gradients(benchmark.fun, benchmark.jac, init_guess, disp=False) assert errors.min() < 2e-7 hess_matvec = lambda x, v: np.dot(benchmark.hess(x), v) errors = pya.check_hessian(benchmark.jac, hess_matvec, init_guess, disp=False) assert errors.min() < 2e-7
def test_ACVMC_objective_jacobian(self): cov = np.asarray([[1.00, 0.50, 0.25], [0.50, 1.00, 0.50], [0.25, 0.50, 4.00]]) costs = [4, 2, 1] target_cost = 20 nhf_samples, nsample_ratios = pya.allocate_samples_mlmc( cov, costs, target_cost)[:2] estimator = ACVMF(cov, costs) errors = pya.check_gradients( partial(acv_sample_allocation_objective, estimator), partial(acv_sample_allocation_jacobian_torch, estimator), nsample_ratios[:, np.newaxis], disp=False) #print(errors.min()) assert errors.min() < 1e-8
seed = 1 generate_sample_data = partial(generate_monte_carlo_quadrature_data, generate_random_samples, benchmark.variable.num_vars(), benchmark.design_var_indices, seed=seed) num_vars = benchmark.variable.num_vars() + benchmark.design_variable.num_vars() objective = StatisticalConstraint(benchmark.fun, benchmark.jac, expectation_fun, expectation_jac, num_vars, benchmark.design_var_indices, generate_sample_data) init_guess = 2 * np.ones((2, 1)) errors = pya.check_gradients(objective, objective.jacobian, init_guess, disp=False) assert errors.min() < 1e-7 constraint = StatisticalConstraint(benchmark.constraint_fun, benchmark.constraint_jac, expectation_fun, expectation_jac, num_vars, benchmark.design_var_indices, generate_sample_data, bound=0.1, upper_bound=False) print('####') init_guess = 2 * np.ones((2, 1))
def check_derivative(function, num_design_pts, rel=True): design_prob_measure = np.ones((num_design_pts, 1)) / num_design_pts design_prob_measure = np.random.uniform(0, 1, (num_design_pts, 1)) return pya.check_gradients(function, True, design_prob_measure, rel=rel)