diff --git a/doc/OnlineDocs/explanation/analysis/parmest/datarec.rst b/doc/OnlineDocs/explanation/analysis/parmest/datarec.rst index 380bd7cb876..847b90022e9 100644 --- a/doc/OnlineDocs/explanation/analysis/parmest/datarec.rst +++ b/doc/OnlineDocs/explanation/analysis/parmest/datarec.rst @@ -44,8 +44,8 @@ The following example returns model values from a Pyomo Expression. >>> # Define objective >>> def SSE(model): - ... expr = (model.experiment_outputs[model.y[model.hour]] - ... - model.y[model.hour] + ... expr = (model.experiment_outputs[model.y] + ... - model.y ... ) ** 2 ... return expr diff --git a/pyomo/contrib/doe/examples/rooney_biegler_example.py b/pyomo/contrib/doe/examples/rooney_biegler_example.py deleted file mode 100644 index 954f0eed435..00000000000 --- a/pyomo/contrib/doe/examples/rooney_biegler_example.py +++ /dev/null @@ -1,148 +0,0 @@ -# ___________________________________________________________________________ -# -# Pyomo: Python Optimization Modeling Objects -# Copyright (c) 2008-2025 -# National Technology and Engineering Solutions of Sandia, LLC -# Under the terms of Contract DE-NA0003525 with National Technology and -# Engineering Solutions of Sandia, LLC, the U.S. Government retains certain -# rights in this software. -# This software is distributed under the 3-clause BSD License. -# ___________________________________________________________________________ -""" -Rooney Biegler model, based on Rooney, W. C. and Biegler, L. T. (2001). Design for -model parameter uncertainty using nonlinear confidence regions. AIChE Journal, -47(8), 1794-1804. -""" -from pyomo.common.dependencies import numpy as np, pathlib - -from pyomo.contrib.doe.examples.rooney_biegler_experiment import ( - RooneyBieglerExperimentDoE, -) -from pyomo.contrib.doe import DesignOfExperiments - -import pyomo.environ as pyo - -import json -import sys - - -# Example comparing Cholesky factorization -# (standard solve) with grey box objective -# solve for the log-deteriminant of the FIM -# (D-optimality) -def run_rooney_biegler_doe(): - # Create a RooneyBiegler Experiment - experiment = RooneyBieglerExperimentDoE(data={'hour': 2, 'y': 10.3}) - - # Use a central difference, with step size 1e-3 - fd_formula = "central" - step_size = 1e-3 - - # Use the determinant objective with scaled sensitivity matrix - objective_option = "determinant" - scale_nominal_param_value = True - - data = [[1, 8.3], [7, 19.8], [2, 10.3], [5, 15.6], [3, 19.0], [4, 16.0]] - FIM_prior = np.zeros((2, 2)) - # Calculate prior using existing experiments - for i in range(len(data)): - if i > int(sys.argv[1]): - break - prev_experiment = RooneyBieglerExperimentDoE( - data={'hour': data[i][0], 'y': data[i][1]} - ) - doe_obj = DesignOfExperiments( - prev_experiment, - fd_formula=fd_formula, - step=step_size, - objective_option=objective_option, - scale_nominal_param_value=scale_nominal_param_value, - prior_FIM=None, - tee=False, - ) - - FIM_prior += doe_obj.compute_FIM(method='sequential') - - if sys.argv[1] == 0: - FIM_prior[0][0] += 1e-6 - FIM_prior[1][1] += 1e-6 - - # Create the DesignOfExperiments object - # We will not be passing any prior information in this example - # and allow the experiment object and the DesignOfExperiments - # call of ``run_doe`` perform model initialization. - doe_obj = DesignOfExperiments( - experiment, - fd_formula=fd_formula, - step=step_size, - objective_option=objective_option, - scale_constant_value=1, - scale_nominal_param_value=scale_nominal_param_value, - prior_FIM=FIM_prior, - jac_initial=None, - fim_initial=None, - L_diagonal_lower_bound=1e-7, - solver=None, - tee=False, - get_labeled_model_args=None, - _Cholesky_option=True, - _only_compute_fim_lower=True, - ) - - # Begin optimal DoE - #################### - doe_obj.run_doe() - - # Print out a results summary - print("Optimal experiment values: ") - print( - "\tOptimal measurement time: {:.2f}".format( - doe_obj.results["Experiment Design"][0] - ) - ) - print("FIM at optimal design:\n {}".format(np.array(doe_obj.results["FIM"]))) - print( - "Objective value at optimal design: {:.2f}".format( - pyo.value(doe_obj.model.objective) - ) - ) - - print(doe_obj.results["Experiment Design Names"]) - - ################### - # End optimal DoE - - # Begin optimal greybox DoE - ############################ - doe_obj_gb = DesignOfExperiments( - experiment, - fd_formula=fd_formula, - step=step_size, - objective_option=objective_option, - use_grey_box_objective=True, - scale_nominal_param_value=scale_nominal_param_value, - prior_FIM=FIM_prior, - tee=False, - ) - - doe_obj_gb.run_doe() - - print("Optimal experiment values: ") - print( - "\tOptimal measurement time: {:.2f}".format( - doe_obj_gb.results["Experiment Design"][0] - ) - ) - print("FIM at optimal design:\n {}".format(np.array(doe_obj_gb.results["FIM"]))) - print( - "Objective value at optimal design: {:.2f}".format( - np.log10(np.exp(pyo.value(doe_obj_gb.model.objective))) - ) - ) - - ############################ - # End optimal greybox DoE - - -if __name__ == "__main__": - run_rooney_biegler_doe() diff --git a/pyomo/contrib/doe/examples/rooney_biegler_experiment.py b/pyomo/contrib/doe/examples/rooney_biegler_experiment.py deleted file mode 100644 index 4918100b78d..00000000000 --- a/pyomo/contrib/doe/examples/rooney_biegler_experiment.py +++ /dev/null @@ -1,100 +0,0 @@ -# ___________________________________________________________________________ -# -# Pyomo: Python Optimization Modeling Objects -# Copyright (c) 2008-2025 -# National Technology and Engineering Solutions of Sandia, LLC -# Under the terms of Contract DE-NA0003525 with National Technology and -# Engineering Solutions of Sandia, LLC, the U.S. Government retains certain -# rights in this software. -# This software is distributed under the 3-clause BSD License. -# ___________________________________________________________________________ - -""" -Rooney Biegler model, based on Rooney, W. C. and Biegler, L. T. (2001). Design for -model parameter uncertainty using nonlinear confidence regions. AIChE Journal, -47(8), 1794-1804. -""" - -from pyomo.common.dependencies import pandas as pd -import pyomo.environ as pyo -from pyomo.contrib.parmest.experiment import Experiment - - -class RooneyBieglerExperimentDoE(Experiment): - def __init__(self, data=None, theta=None): - if data is None: - self.data = {} - self.data['hour'] = 1 - self.data['y'] = 8.3 - else: - self.data = data - if theta is None: - self.theta = {} - self.theta['asymptote'] = 19.143 - self.theta['rate constant'] = 0.5311 - else: - self.theta = theta - self.model = None - - def create_model(self): - # Creates Roony-Biegler model for - # individual data points as - # an experimental decision. - m = self.model = pyo.ConcreteModel() - - # Specify the unknown parameters - m.asymptote = pyo.Var(initialize=self.theta['asymptote']) - m.rate_constant = pyo.Var(initialize=self.theta['rate constant']) - - # Fix the unknown parameters - m.asymptote.fix() - m.rate_constant.fix() - - # Add the experiment inputs - m.hour = pyo.Var(initialize=self.data['hour'], bounds=(0, 10)) - - # Fix the experimental design variable - m.hour.fix() - - # Add the experiment outputs - m.y = pyo.Var(initialize=self.data['y']) - - # Add governing equation - m.response_function = pyo.Constraint( - expr=m.y - m.asymptote * (1 - pyo.exp(-m.rate_constant * m.hour)) == 0 - ) - - def finalize_model(self): - m = self.model - pass - - def label_model(self): - m = self.model - - # Add y value as experiment output - m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL) - m.experiment_outputs[m.y] = m.y() - - # Add measurement error associated with y - # We are assuming a flat error of 0.3 - # or about 1-3 percent - m.measurement_error = pyo.Suffix(direction=pyo.Suffix.LOCAL) - m.measurement_error[m.y] = 1 - - # Add hour as experiment input - # We are deciding when to sample - m.experiment_inputs = pyo.Suffix(direction=pyo.Suffix.LOCAL) - m.experiment_inputs[m.hour] = m.hour() - - # Adding the unknown parameters - m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL) - m.unknown_parameters.update( - (k, k.value) for k in [m.asymptote, m.rate_constant] - ) - - def get_labeled_model(self): - self.create_model() - self.finalize_model() - self.label_model() - - return self.model diff --git a/pyomo/contrib/doe/tests/test_greybox.py b/pyomo/contrib/doe/tests/test_greybox.py index 1336b266685..beedcc39dfa 100644 --- a/pyomo/contrib/doe/tests/test_greybox.py +++ b/pyomo/contrib/doe/tests/test_greybox.py @@ -32,8 +32,8 @@ from pyomo.contrib.doe.examples.reactor_example import ( ReactorExperiment as FullReactorExperiment, ) - from pyomo.contrib.doe.examples.rooney_biegler_example import ( - RooneyBieglerExperimentDoE, + from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler import ( + RooneyBieglerExperiment, ) import pyomo.environ as pyo @@ -304,7 +304,12 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option): fd_method = "central" obj_used = objective_option - experiment = RooneyBieglerExperimentDoE(data={'hour': 2, 'y': 10.3}) + data = pd.DataFrame(data=[[2, 10.3]], columns=['hour', 'y']) + theta = {'asymptote': 19.143, 'rate_constant': 0.5311} + + experiment = RooneyBieglerExperiment( + data=data.loc[0, :], theta=theta, measure_error=1 + ) DoE_args = get_standard_args(experiment, fd_method, obj_used) DoE_args["use_grey_box_objective"] = True @@ -318,12 +323,13 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option): # Add the grey box solver to DoE_args DoE_args["grey_box_solver"] = grey_box_solver - data = [[1, 8.3], [7, 19.8]] + data = pd.DataFrame(data=[[1, 8.3], [7, 19.8]], columns=['hour', 'y']) + theta = {'asymptote': 19.143, 'rate_constant': 0.5311} FIM_prior = np.zeros((2, 2)) # Calculate prior using existing experiments for i in range(len(data)): - prev_experiment = RooneyBieglerExperimentDoE( - data={'hour': data[i][0], 'y': data[i][1]} + prev_experiment = RooneyBieglerExperiment( + data=data.loc[i, :], theta=theta, measure_error=1 ) doe_obj = DesignOfExperiments( **get_standard_args(prev_experiment, fd_method, obj_used) @@ -347,7 +353,13 @@ def make_greybox_and_doe_objects_rooney_biegler(objective_option): # linear solvers. bad_message = "Invalid option encountered." cyipopt_call_working = True -if numpy_available and scipy_available and ipopt_available and cyipopt_available: +if ( + numpy_available + and scipy_available + and ipopt_available + and cyipopt_available + and pandas_available +): try: objective_option = "determinant" doe_object, _ = make_greybox_and_doe_objects_rooney_biegler( @@ -1110,6 +1122,7 @@ def test_solve_A_optimality_trace_of_inverse(self): @unittest.skipIf( not cyipopt_call_working, "cyipopt is not properly accessing linear solvers" ) + @unittest.skipIf(not pandas_available, "pandas is not available") def test_solve_E_optimality_minimum_eigenvalue(self): # Two locally optimal design points exist # (time, optimal objective value) @@ -1151,6 +1164,7 @@ def test_solve_E_optimality_minimum_eigenvalue(self): @unittest.skipIf( not cyipopt_call_working, "cyipopt is not properly accessing linear solvers" ) + @unittest.skipIf(not pandas_available, "pandas is not available") def test_solve_ME_optimality_condition_number(self): # Two locally optimal design points exist # (time, optimal objective value) diff --git a/pyomo/contrib/parmest/examples/rooney_biegler/bootstrap_example.py b/pyomo/contrib/parmest/examples/rooney_biegler/bootstrap_example.py index c74ce32d5b4..2d7c4dd18c0 100644 --- a/pyomo/contrib/parmest/examples/rooney_biegler/bootstrap_example.py +++ b/pyomo/contrib/parmest/examples/rooney_biegler/bootstrap_example.py @@ -26,9 +26,7 @@ def main(): # Sum of squared error function def SSE(model): - expr = ( - model.experiment_outputs[model.y[model.hour]] - model.y[model.hour] - ) ** 2 + expr = (model.experiment_outputs[model.y] - model.y) ** 2 return expr # Create an experiment list diff --git a/pyomo/contrib/parmest/examples/rooney_biegler/likelihood_ratio_example.py b/pyomo/contrib/parmest/examples/rooney_biegler/likelihood_ratio_example.py index 3b9209b366e..4d5814fd09c 100644 --- a/pyomo/contrib/parmest/examples/rooney_biegler/likelihood_ratio_example.py +++ b/pyomo/contrib/parmest/examples/rooney_biegler/likelihood_ratio_example.py @@ -27,9 +27,7 @@ def main(): # Sum of squared error function def SSE(model): - expr = ( - model.experiment_outputs[model.y[model.hour]] - model.y[model.hour] - ) ** 2 + expr = (model.experiment_outputs[model.y] - model.y) ** 2 return expr # Create an experiment list diff --git a/pyomo/contrib/parmest/examples/rooney_biegler/parameter_estimation_example.py b/pyomo/contrib/parmest/examples/rooney_biegler/parameter_estimation_example.py index 8f56a9d849c..ece018923d4 100644 --- a/pyomo/contrib/parmest/examples/rooney_biegler/parameter_estimation_example.py +++ b/pyomo/contrib/parmest/examples/rooney_biegler/parameter_estimation_example.py @@ -24,37 +24,26 @@ def main(): columns=['hour', 'y'], ) - # Sum of squared error function - def SSE(model): - expr = ( - model.experiment_outputs[model.y[model.hour]] - model.y[model.hour] - ) ** 2 - return expr - # Create an experiment list exp_list = [] for i in range(data.shape[0]): exp_list.append(RooneyBieglerExperiment(data.loc[i, :])) - # View one model - # exp0_model = exp_list[0].get_labeled_model() - # exp0_model.pprint() - # Create an instance of the parmest estimator - pest = parmest.Estimator(exp_list, obj_function=SSE) + pest = parmest.Estimator(exp_list, obj_function="SSE") # Parameter estimation and covariance - n = 6 # total number of data points used in the objective (y in 6 scenarios) - obj, theta, cov = pest.theta_est(calc_cov=True, cov_n=n) - - # Plot theta estimates using a multivariate Gaussian distribution - parmest.graphics.pairwise_plot( - (theta, cov, 100), - theta_star=theta, - alpha=0.8, - distributions=['MVN'], - title='Theta estimates within 80% confidence region', - ) + obj, theta = pest.theta_est() + cov = pest.cov_est() + + if parmest.graphics.seaborn_available: + parmest.graphics.pairwise_plot( + (theta, cov, 100), + theta_star=theta, + alpha=0.8, + distributions=['MVN'], + title='Theta estimates within 80% confidence region', + ) # Assert statements compare parameter estimation (theta) to an expected value relative_error = abs(theta['asymptote'] - 19.1426) / 19.1426 @@ -62,6 +51,11 @@ def SSE(model): relative_error = abs(theta['rate_constant'] - 0.5311) / 0.5311 assert relative_error < 0.01 + return obj, theta, cov + if __name__ == "__main__": - main() + obj, theta, cov = main() + print("Estimated parameters (theta):", theta) + print("Objective function value at theta:", obj) + print("Covariance of parameter estimates:", cov) diff --git a/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler.py b/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler.py index 9f77d75a501..6ce70a56dc0 100644 --- a/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler.py +++ b/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler.py @@ -20,60 +20,78 @@ from pyomo.contrib.parmest.experiment import Experiment -def rooney_biegler_model(data): +def rooney_biegler_model(data, theta=None): model = pyo.ConcreteModel() - model.asymptote = pyo.Var(initialize=15) - model.rate_constant = pyo.Var(initialize=0.5) + if theta is None: + theta = {'asymptote': 15, 'rate_constant': 0.5} - model.y = pyo.Var(data.hour, within=pyo.PositiveReals, initialize=5) + model.asymptote = pyo.Var(initialize=theta['asymptote']) + model.rate_constant = pyo.Var(initialize=theta['rate_constant']) - def response_rule(m, h): - return m.y[h] == m.asymptote * (1 - pyo.exp(-m.rate_constant * h)) + # Fix the unknown parameters + model.asymptote.fix() + model.rate_constant.fix() - model.response_function = pyo.Constraint(data.hour, rule=response_rule) + # Add the experiment inputs + model.hour = pyo.Var(initialize=data["hour"].iloc[0], bounds=(0, 10)) - def SSE_rule(m): - return sum((data.y[i] - m.y[data.hour[i]]) ** 2 for i in data.index) + # Fix the experiment inputs + model.hour.fix() - model.SSE = pyo.Objective(rule=SSE_rule, sense=pyo.minimize) + # Add the response variable + model.y = pyo.Var(within=pyo.PositiveReals, initialize=data["y"].iloc[0]) + + def response_rule(m): + return m.y == m.asymptote * (1 - pyo.exp(-m.rate_constant * m.hour)) + + model.response_function = pyo.Constraint(rule=response_rule) return model class RooneyBieglerExperiment(Experiment): - def __init__(self, data, measure_error=None): + def __init__(self, data, measure_error=None, theta=None): self.data = data self.model = None self.measure_error = measure_error + self.theta = theta def create_model(self): # rooney_biegler_model expects a dataframe data_df = self.data.to_frame().transpose() - self.model = rooney_biegler_model(data_df) + self.model = rooney_biegler_model(data_df, theta=self.theta) def label_model(self): m = self.model + # Add experiment outputs as a suffix + # Experiment outputs suffix is required for parest m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL) - m.experiment_outputs.update([(m.y[self.data['hour']], self.data['y'])]) + m.experiment_outputs.update([(m.y, self.data['y'])]) + # Add unknown parameters as a suffix + # Unknown parameters suffix is required for both Pyomo.DoE and parmest m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL) m.unknown_parameters.update( - (k, pyo.ComponentUID(k)) for k in [m.asymptote, m.rate_constant] + (k, pyo.value(k)) for k in [m.asymptote, m.rate_constant] ) + # Add measurement error as a suffix + # Measurement error suffix is required for Pyomo.DoE and + # `cov` estimation in parmest m.measurement_error = pyo.Suffix(direction=pyo.Suffix.LOCAL) - m.measurement_error.update([(m.y[self.data['hour']], self.measure_error)]) - - def finalize_model(self): + m.measurement_error.update([(m.y, self.measure_error)]) - m = self.model + # Add hour as an experiment input + # Experiment inputs suffix is required for Pyomo.DoE + m.experiment_inputs = pyo.Suffix(direction=pyo.Suffix.LOCAL) + m.experiment_inputs.update([(m.hour, self.data['hour'])]) - # Experiment input values - m.hour = self.data['hour'] + def finalize_model(self): + pass def get_labeled_model(self): self.create_model() @@ -81,22 +99,3 @@ def get_labeled_model(self): self.finalize_model() return self.model - - -def main(): - # These were taken from Table A1.4 in Bates and Watts (1988). - data = pd.DataFrame( - data=[[1, 8.3], [2, 10.3], [3, 19.0], [4, 16.0], [5, 15.6], [7, 19.8]], - columns=['hour', 'y'], - ) - - model = rooney_biegler_model(data) - solver = pyo.SolverFactory('ipopt') - solver.solve(model) - - print('asymptote = ', model.asymptote()) - print('rate constant = ', model.rate_constant()) - - -if __name__ == '__main__': - main() diff --git a/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler_with_constraint.py b/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler_with_constraint.py deleted file mode 100644 index 3416682dca3..00000000000 --- a/pyomo/contrib/parmest/examples/rooney_biegler/rooney_biegler_with_constraint.py +++ /dev/null @@ -1,109 +0,0 @@ -# ___________________________________________________________________________ -# -# Pyomo: Python Optimization Modeling Objects -# Copyright (c) 2008-2025 -# National Technology and Engineering Solutions of Sandia, LLC -# Under the terms of Contract DE-NA0003525 with National Technology and -# Engineering Solutions of Sandia, LLC, the U.S. Government retains certain -# rights in this software. -# This software is distributed under the 3-clause BSD License. -# ___________________________________________________________________________ - -""" -Rooney Biegler model, based on Rooney, W. C. and Biegler, L. T. (2001). Design for -model parameter uncertainty using nonlinear confidence regions. AIChE Journal, -47(8), 1794-1804. -""" - -from pyomo.common.dependencies import pandas as pd -import pyomo.environ as pyo -from pyomo.contrib.parmest.experiment import Experiment - - -def rooney_biegler_model_with_constraint(data): - model = pyo.ConcreteModel() - - model.asymptote = pyo.Var(initialize=15) - model.rate_constant = pyo.Var(initialize=0.5) - - model.hour = pyo.Param(within=pyo.PositiveReals, mutable=True) - model.y = pyo.Param(within=pyo.PositiveReals, mutable=True) - - model.response_function = pyo.Var(data.hour, initialize=0.0) - - # changed from expression to constraint - def response_rule(m, h): - return m.response_function[h] == m.asymptote * ( - 1 - pyo.exp(-m.rate_constant * h) - ) - - model.response_function_constraint = pyo.Constraint(data.hour, rule=response_rule) - - def SSE_rule(m): - return sum( - (data.y[i] - m.response_function[data.hour[i]]) ** 2 for i in data.index - ) - - model.SSE = pyo.Objective(rule=SSE_rule, sense=pyo.minimize) - - return model - - -class RooneyBieglerExperiment(Experiment): - - def __init__(self, data): - self.data = data - self.model = None - - def create_model(self): - # rooney_biegler_model_with_constraint expects a dataframe - data_df = self.data.to_frame().transpose() - self.model = rooney_biegler_model_with_constraint(data_df) - - def label_model(self): - - m = self.model - - m.experiment_outputs = pyo.Suffix(direction=pyo.Suffix.LOCAL) - m.experiment_outputs.update( - [(m.hour, self.data['hour']), (m.y, self.data['y'])] - ) - - m.unknown_parameters = pyo.Suffix(direction=pyo.Suffix.LOCAL) - m.unknown_parameters.update( - (k, pyo.ComponentUID(k)) for k in [m.asymptote, m.rate_constant] - ) - - def finalize_model(self): - - m = self.model - - # Experiment output values - m.hour = self.data['hour'] - m.y = self.data['y'] - - def get_labeled_model(self): - self.create_model() - self.label_model() - self.finalize_model() - - return self.model - - -def main(): - # These were taken from Table A1.4 in Bates and Watts (1988). - data = pd.DataFrame( - data=[[1, 8.3], [2, 10.3], [3, 19.0], [4, 16.0], [5, 15.6], [7, 19.8]], - columns=['hour', 'y'], - ) - - model = rooney_biegler_model_with_constraint(data) - solver = pyo.SolverFactory('ipopt') - solver.solve(model) - - print('asymptote = ', model.asymptote()) - print('rate constant = ', model.rate_constant()) - - -if __name__ == '__main__': - main() diff --git a/pyomo/contrib/parmest/tests/test_examples.py b/pyomo/contrib/parmest/tests/test_examples.py index 8d9331a6166..ce790b7ddb7 100644 --- a/pyomo/contrib/parmest/tests/test_examples.py +++ b/pyomo/contrib/parmest/tests/test_examples.py @@ -33,18 +33,6 @@ def setUpClass(self): def tearDownClass(self): pass - def test_model(self): - from pyomo.contrib.parmest.examples.rooney_biegler import rooney_biegler - - rooney_biegler.main() - - def test_model_with_constraint(self): - from pyomo.contrib.parmest.examples.rooney_biegler import ( - rooney_biegler_with_constraint, - ) - - rooney_biegler_with_constraint.main() - @unittest.skipUnless(pynumero_ASL_available, "test requires libpynumero_ASL") @unittest.skipUnless(seaborn_available, "test requires seaborn") def test_parameter_estimation_example(self): diff --git a/pyomo/contrib/parmest/tests/test_parmest.py b/pyomo/contrib/parmest/tests/test_parmest.py index db71d280f7c..7f71a56e1d2 100644 --- a/pyomo/contrib/parmest/tests/test_parmest.py +++ b/pyomo/contrib/parmest/tests/test_parmest.py @@ -9,6 +9,7 @@ # This software is distributed under the 3-clause BSD License. # ___________________________________________________________________________ +from pyexpat import model import sys import os import subprocess @@ -310,9 +311,7 @@ def setUp(self): # Sum of squared error function def SSE(model): - expr = ( - model.experiment_outputs[model.y[model.hour]] - model.y[model.hour] - ) ** 2 + expr = (model.experiment_outputs[model.y] - model.y) ** 2 return expr # Create an experiment list @@ -1349,7 +1348,7 @@ def test_covariance(self): @unittest.skipIf(not ipopt_available, "The 'ipopt' command is not available") class TestSquareInitialization_RooneyBiegler(unittest.TestCase): def setUp(self): - from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler_with_constraint import ( + from pyomo.contrib.parmest.examples.rooney_biegler.rooney_biegler import ( RooneyBieglerExperiment, ) @@ -1361,10 +1360,8 @@ def setUp(self): # Sum of squared error function def SSE(model): - expr = ( - model.experiment_outputs[model.y] - - model.response_function[model.experiment_outputs[model.hour]] - ) ** 2 + expr = (model.experiment_outputs[model.y] - model.y) ** 2 + return expr exp_list = []