def test_load_local_asl_library(self): DLL = find_GSL() if not DLL: self.skipTest("Could not find the amplgsl.dll library") LIB = 'test_pyomo_external_gsl.dll' model = ConcreteModel() model.gamma = ExternalFunction(library=LIB, function="gsl_sf_gamma") model.x = Var(initialize=3, bounds=(1e-5, None)) model.o = Objective(expr=model.gamma(model.x)) with TempfileManager.new_context() as tempfile: dname = tempfile.mkdtemp() shutil.copyfile(DLL, os.path.join(dname, LIB)) # Without changing directories, the load should fail with self.assertRaises(OSError): value(model.o) # Changing directories should pick up the library try: orig_dir = os.getcwd() os.chdir(dname) self.assertAlmostEqual(value(model.o), 2.0, 7) finally: os.chdir(orig_dir)
def test_capture_output_logfile_string(self): with TempfileManager.new_context() as tempfile: logfile = tempfile.create_tempfile() self.assertTrue(isinstance(logfile, str)) with tee.capture_output(logfile): print('HELLO WORLD') with open(logfile, 'r') as f: result = f.read() self.assertEqual('HELLO WORLD\n', result)
def _get_files(self): """ Method to get/set paths for .alm and .trc files based on filename configuration argument. If filename is None, temporary files will be created. Args: None Returns: None """ if self._temp_context is None: self._temp_context = TempfileManager.new_context() if self.config.filename is None: # Get a temporary file from the manager almfile = self._temp_context.create_tempfile(suffix=".alm") else: almfile = self.config.filename if not self.config.overwrite_files: # It is OK if the trace file exists, as ALAMO will append to it # The trace file reader handles this case if os.path.isfile(almfile): raise FileExistsError( f"A file with the name {almfile} already exists. " f"Either choose a new file name or set " f"overwrite_files = True.") self._temp_context.add_tempfile(almfile, exists=False) trcfile = os.path.splitext(almfile)[0] + ".trc" self._temp_context.add_tempfile(trcfile, exists=False) if self.config.working_directory is None: wrkdir = self._temp_context.create_tempdir() else: wrkdir = self.config.working_directory # Set attributes to track file names self._almfile = almfile self._trcfile = trcfile self._wrkdir = wrkdir
def test_call_alamo_w_input(self, alamo_trainer): cwd = os.getcwd() alamo_trainer._temp_context = TempfileManager.new_context() alamo_trainer._almfile = os.path.join(dirpath, "alamo_test.alm") alamo_trainer._wrkdir = dirpath alamo_trainer._temp_context.add_tempfile( os.path.join(dirpath, "GUI_trace.trc"), exists=False) alamo_trainer._temp_context.add_tempfile( os.path.join(dirpath, "alamo_test.lst"), exists=False) rc, almlog = alamo_trainer._call_alamo() assert rc == 0 assert "Normal termination" in almlog # Check for clean up alamo_trainer._temp_context.release(remove=True) assert not os.path.exists(os.path.join(dirpath, "GUI_trace.trc")) assert not os.path.exists(os.path.join(dirpath, "alamo_test.lst")) assert cwd == os.getcwd()
def test_obj_con_cache(self): model = ConcreteModel() model.x = Var() model.c = Constraint(expr=model.x >= 1) model.obj = Objective(expr=model.x * 2) with TempfileManager.new_context() as TMP: lp_file = TMP.create_tempfile(suffix='.lp') model.write(lp_file, format='lp') self.assertFalse(hasattr(model, '_repn')) with open(lp_file) as FILE: lp_ref = FILE.read() lp_file = TMP.create_tempfile(suffix='.lp') model._gen_obj_repn = True model.write(lp_file) self.assertEqual(len(model._repn), 1) self.assertIn(model.obj, model._repn) obj_repn = model._repn[model.obj] with open(lp_file) as FILE: lp_test = FILE.read() self.assertEqual(lp_ref, lp_test) lp_file = TMP.create_tempfile(suffix='.lp') model._gen_obj_repn = None model._gen_con_repn = True model.write(lp_file) self.assertEqual(len(model._repn), 2) self.assertIn(model.obj, model._repn) self.assertIn(model.c, model._repn) self.assertIs(obj_repn, model._repn[model.obj]) obj_repn = model._repn[model.obj] c_repn = model._repn[model.c] with open(lp_file) as FILE: lp_test = FILE.read() self.assertEqual(lp_ref, lp_test) lp_file = TMP.create_tempfile(suffix='.lp') model._gen_obj_repn = None model._gen_con_repn = None model.write(lp_file) self.assertEqual(len(model._repn), 2) self.assertIn(model.obj, model._repn) self.assertIn(model.c, model._repn) self.assertIs(obj_repn, model._repn[model.obj]) self.assertIs(c_repn, model._repn[model.c]) with open(lp_file) as FILE: lp_test = FILE.read() self.assertEqual(lp_ref, lp_test) lp_file = TMP.create_tempfile(suffix='.lp') model._gen_obj_repn = True model._gen_con_repn = True model.write(lp_file) self.assertEqual(len(model._repn), 2) self.assertIn(model.obj, model._repn) self.assertIn(model.c, model._repn) self.assertIsNot(obj_repn, model._repn[model.obj]) self.assertIsNot(c_repn, model._repn[model.c]) obj_repn = model._repn[model.obj] c_repn = model._repn[model.c] with open(lp_file) as FILE: lp_test = FILE.read() self.assertEqual(lp_ref, lp_test) lp_file = TMP.create_tempfile(suffix='.lp') model._gen_obj_repn = False model._gen_con_repn = False import pyomo.repn.plugins.ampl.ampl_ as ampl_ gsr = ampl_.generate_standard_repn try: def dont_call_gsr(*args, **kwargs): self.fail("generate_standard_repn should not be called") ampl_.generate_standard_repn = dont_call_gsr model.write(lp_file) finally: ampl_.generate_standard_repn = gsr self.assertEqual(len(model._repn), 2) self.assertIn(model.obj, model._repn) self.assertIn(model.c, model._repn) self.assertIs(obj_repn, model._repn[model.obj]) self.assertIs(c_repn, model._repn[model.c]) with open(lp_file) as FILE: lp_test = FILE.read() self.assertEqual(lp_ref, lp_test)
def test_save_load(): keras_surrogate = create_keras_model(name='PT_data_2_10_10_2_sigmoid', return_keras_model_only=False) new_keras_surrogate = None dname = None with TempfileManager.new_context() as tf: dname = tf.mkdtemp() keras_surrogate.save_to_folder(dname) assert os.path.isdir(dname) assert os.path.isfile(os.path.join(dname, 'idaes_info.json')) new_keras_surrogate = KerasSurrogate.load_from_folder(dname) # Check for clean up assert not os.path.isdir(dname) # check surrogate data members assert new_keras_surrogate._input_labels == [ 'Temperature_K', 'Pressure_Pa' ] assert new_keras_surrogate._output_labels == ['EnthMol', 'VapFrac'] assert sorted(new_keras_surrogate._input_bounds.keys()) == [ 'Pressure_Pa', 'Temperature_K' ] assert new_keras_surrogate._input_bounds['Temperature_K'][ 0] == pytest.approx(360.0) assert new_keras_surrogate._input_bounds['Temperature_K'][ 1] == pytest.approx(380.0) assert new_keras_surrogate._input_bounds['Pressure_Pa'][ 0] == pytest.approx(101325.0) assert new_keras_surrogate._input_bounds['Pressure_Pa'][ 1] == pytest.approx(1.2 * 101325.0) # check input scaler expected_columns = ['Temperature_K', 'Pressure_Pa'] offset_series = pd.Series({ 'Temperature_K': 369.983611, 'Pressure_Pa': 111421.319811 }) factor_series = pd.Series({ 'Temperature_K': 5.836047, 'Pressure_Pa': 5917.954504 }) scaler = new_keras_surrogate._input_scaler assert scaler._expected_columns == expected_columns pd.testing.assert_series_equal(scaler._offset, offset_series, rtol=rtol, atol=atol) pd.testing.assert_series_equal(scaler._factor, factor_series, rtol=rtol, atol=atol) # check output scaler expected_columns = ['EnthMol', 'VapFrac'] offset_series = pd.Series({'EnthMol': 54599.629980, 'VapFrac': 0.403307}) factor_series = pd.Series({'EnthMol': 14654.226615, 'VapFrac': 0.430181}) scaler = new_keras_surrogate._output_scaler assert scaler._expected_columns == expected_columns pd.testing.assert_series_equal(scaler._offset, offset_series, rtol=rtol, atol=atol) pd.testing.assert_series_equal(scaler._factor, factor_series, rtol=rtol, atol=atol) # check evaluation x_test = pd.DataFrame({ 'Temperature_K': [360, 370, 380], 'Pressure_Pa': [1.05 * 101325, 1.10 * 101325, 1.15 * 101325] }) y_test = keras_surrogate.evaluate_surrogate(x_test) expected_y = pd.DataFrame({ 'EnthMol': [40194.5586954288, 48660.288218426984, 75178.30324367314], 'VapFrac': [0.002291496299564877, 0.21942246438431742, 0.9996716243380308] }) pd.testing.assert_frame_equal(y_test, expected_y, rtol=rtol, atol=atol) # check solve with pyomo x_test = pd.DataFrame({ 'Temperature_K': [370], 'Pressure_Pa': [1.1 * 101325] }) y_test = keras_surrogate.evaluate_surrogate(x_test) m = ConcreteModel() m.obj = Objective(expr=1) m.surrogate = SurrogateBlock() m.surrogate.build_model(surrogate_object=keras_surrogate, formulation=KerasSurrogate.Formulation.FULL_SPACE) m.surrogate.inputs['Temperature_K'].fix(370) m.surrogate.inputs['Pressure_Pa'].fix(1.1 * 101325) solver = SolverFactory('ipopt') status = solver.solve(m, tee=True) assert_optimal_termination(status) y_test_pyomo = pd.DataFrame({ 'EnthMol': [value(m.surrogate.outputs['EnthMol'])], 'VapFrac': [value(m.surrogate.outputs['VapFrac'])] }) pd.testing.assert_frame_equal(y_test, y_test_pyomo, rtol=rtol, atol=atol)
def test_obj_con_cache(self): model = ConcreteModel() model.x = Var() model.c = Constraint(expr=model.x**2 >= 1) model.obj = Objective(expr=model.x**2) with TempfileManager.new_context() as TMP: nl_file = TMP.create_tempfile(suffix='.nl') model.write(nl_file, format='nl') self.assertFalse(hasattr(model, '_repn')) with open(nl_file) as FILE: nl_ref = FILE.read() nl_file = TMP.create_tempfile(suffix='.nl') model._gen_obj_repn = True model.write(nl_file) self.assertEqual(len(model._repn), 1) self.assertIn(model.obj, model._repn) obj_repn = model._repn[model.obj] with open(nl_file) as FILE: nl_test = FILE.read() self.assertEqual(nl_ref, nl_test) nl_file = TMP.create_tempfile(suffix='.nl') del model._repn model._gen_obj_repn = None model._gen_con_repn = True model.write(nl_file) self.assertEqual(len(model._repn), 1) self.assertIn(model.c, model._repn) c_repn = model._repn[model.c] with open(nl_file) as FILE: nl_test = FILE.read() self.assertEqual(nl_ref, nl_test) nl_file = TMP.create_tempfile(suffix='.nl') del model._repn model._gen_obj_repn = True model._gen_con_repn = True model.write(nl_file) self.assertEqual(len(model._repn), 2) self.assertIn(model.obj, model._repn) self.assertIn(model.c, model._repn) obj_repn = model._repn[model.obj] c_repn = model._repn[model.c] with open(nl_file) as FILE: nl_test = FILE.read() self.assertEqual(nl_ref, nl_test) nl_file = TMP.create_tempfile(suffix='.nl') model._gen_obj_repn = None model._gen_con_repn = None model.write(nl_file) self.assertEqual(len(model._repn), 2) self.assertIn(model.obj, model._repn) self.assertIn(model.c, model._repn) self.assertIs(obj_repn, model._repn[model.obj]) self.assertIs(c_repn, model._repn[model.c]) with open(nl_file) as FILE: nl_test = FILE.read() self.assertEqual(nl_ref, nl_test) nl_file = TMP.create_tempfile(suffix='.nl') model._gen_obj_repn = True model._gen_con_repn = True model.write(nl_file) self.assertEqual(len(model._repn), 2) self.assertIn(model.obj, model._repn) self.assertIn(model.c, model._repn) self.assertIsNot(obj_repn, model._repn[model.obj]) self.assertIsNot(c_repn, model._repn[model.c]) obj_repn = model._repn[model.obj] c_repn = model._repn[model.c] with open(nl_file) as FILE: nl_test = FILE.read() self.assertEqual(nl_ref, nl_test) nl_file = TMP.create_tempfile(suffix='.nl') model._gen_obj_repn = False model._gen_con_repn = False try: def dont_call_gsr(*args, **kwargs): self.fail("generate_standard_repn should not be called") ampl_.generate_standard_repn = dont_call_gsr model.write(nl_file) finally: ampl_.generate_standard_repn = gsr self.assertEqual(len(model._repn), 2) self.assertIn(model.obj, model._repn) self.assertIn(model.c, model._repn) self.assertIs(obj_repn, model._repn[model.obj]) self.assertIs(c_repn, model._repn[model.c]) with open(nl_file) as FILE: nl_test = FILE.read() self.assertEqual(nl_ref, nl_test) # Check that repns generated by the LP wrter will be # processed correctly model._repn[model.c] = c_repn = gsr(model.c.body, quadratic=True) model._repn[model.obj] = obj_repn = gsr(model.obj.expr, quadratic=True) nl_file = TMP.create_tempfile(suffix='.nl') try: def dont_call_gsr(*args, **kwargs): self.fail("generate_standard_repn should not be called") ampl_.generate_standard_repn = dont_call_gsr model.write(nl_file) finally: ampl_.generate_standard_repn = gsr self.assertEqual(len(model._repn), 2) self.assertIn(model.obj, model._repn) self.assertIn(model.c, model._repn) self.assertIs(obj_repn, model._repn[model.obj]) self.assertIs(c_repn, model._repn[model.c]) with open(nl_file) as FILE: nl_test = FILE.read() self.assertEqual(nl_ref, nl_test)