def test_single_input_parameter(self): # Model interp = om.MetaModelUnStructuredComp() # Training Data x_train = np.linspace(0, 10, 20) y_train = np.linspace(0, 20, 20) # Inputs interp.add_input('simple_x', 0., training_data=x_train) #Outputs interp.add_output('cos_x', 0., training_data=.5 * np.cos(y_train)) # Surrogate Model interp.options['default_surrogate'] = om.ResponseSurface() prob = om.Problem() prob.model.add_subsystem('interp', interp) prob.setup() with self.assertRaises(Exception) as context: viz = MetaModelVisualization(interp) msg = 'Must have more than one input value' self.assertTrue(msg in str(context.exception))
def test_response_surface(self): import numpy as np import openmdao.api as om prob = om.Problem() prob.model.add_subsystem('p', om.IndepVarComp('x', 2.1)) sin_mm = om.MetaModelUnStructuredComp() sin_mm.add_input('x', 0.) sin_mm.add_output('f_x', 0., surrogate=om.ResponseSurface()) prob.model.add_subsystem('sin_mm', sin_mm) prob.model.connect('p.x', 'sin_mm.x') prob.setup(check=True) # train the surrogate and check predicted value sin_mm.options['train:x'] = np.linspace(0, 3.14, 20) sin_mm.options['train:f_x'] = .5 * np.sin(sin_mm.options['train:x']) prob['sin_mm.x'] = 2.1 prob.run_model() assert_near_equal(prob['sin_mm.f_x'], .5 * np.sin(prob['sin_mm.x']), 2e-3)
def test_missing_training_data_in_parameter(self): # Model interp = om.MetaModelUnStructuredComp() # Training Data x_train = np.linspace(0,10,20) y_train = np.linspace(0,20,20) # Inputs interp.add_input('simple_x', 0., training_data=x_train) interp.add_input('sin_x', 0.) #Outputs interp.add_output('cos_x', 0., training_data=.5*np.cos(y_train)) # Surrogate Model interp.options['default_surrogate'] = om.ResponseSurface() prob = om.Problem() prob.model.add_subsystem('interp', interp) prob.setup() with self.assertRaises(Exception) as context: viz = UnstructuredMetaModelVisualization(prob, interp) msg = "No training data present for one or more parameters" self.assertTrue(msg in str(context.exception))
def test_not_top_level_prob(self): # Model interp = om.MetaModelUnStructuredComp() # Training Data x_train1 = np.linspace(0, 10, 20) x_train2 = np.linspace(0, 20, 20) x_train3 = np.linspace(0, 30, 20) x_train4 = np.linspace(0, 40, 20) y_train = np.linspace(10, 20, 20) # Inputs interp.add_input('input_1', 0., training_data=x_train1) interp.add_input('input_2', 0., training_data=x_train2) interp.add_input('input_3', 0., training_data=x_train3) interp.add_input('input_4', 0., training_data=x_train4) # Outputs interp.add_output('output_1', 0., training_data=.5 * np.cos(y_train)) interp.add_output('output_2', 0., training_data=.5 * np.sin(y_train)) # Surrogate Model interp.options['default_surrogate'] = om.ResponseSurface() prob = om.Problem(model=interp) prob.setup() prob.final_setup()
def test_make_predictions(self): # Model interp = om.MetaModelUnStructuredComp() # Training Data x_train = np.linspace(0, 10, 20) y_train = np.linspace(10, 20, 20) # Inputs interp.add_input('simple_x', 0., training_data=x_train) interp.add_input('sin_x', 0., training_data=x_train) #Outputs interp.add_output('cos_x', 0., training_data=.5 * np.cos(y_train)) # Surrogate Model interp.options['default_surrogate'] = om.ResponseSurface() prob = om.Problem() prob.model.add_subsystem('interp', interp) prob.setup() viz = MetaModelVisualization(interp) resolution = 50 data = dict({ 'simple_x': np.array([np.random.rand(resolution**2, 1)]), 'sin_x': np.array([np.random.rand(resolution**2, 1)]) }) pred_array = viz._make_predictions(data) self.assertTrue(pred_array.shape == (resolution**2, 1))
def test_training_point_array_for_nan_values(self): # Model interp = om.MetaModelUnStructuredComp() # Training Data x_train = np.linspace(0, 10, 20) y_train = np.linspace(0, 20, 20) # Inputs interp.add_input('x', 0., training_data=x_train) interp.add_input('y', 0., training_data=x_train) #Outputs interp.add_output('cos_x', 0., training_data=.5 * np.cos(y_train)) # Surrogate Model interp.options['default_surrogate'] = om.ResponseSurface() prob = om.Problem() prob.model.add_subsystem('interp', interp) prob.setup() viz = MetaModelVisualization(interp) training_points_output = viz._unstructured_training_points() for i in range(0, 2): self.assertFalse(np.any(np.isnan(training_points_output[:, i])))
def test_training_point_array_width(self): # Model interp = om.MetaModelUnStructuredComp() # Training Data x_train = np.linspace(0, 10, 20) y_train = np.linspace(0, 20, 20) # Inputs interp.add_input('x', 0., training_data=x_train) interp.add_input('y', 0., training_data=x_train) #Outputs interp.add_output('cos_x', 0., training_data=.5 * np.cos(y_train)) # Surrogate Model interp.options['default_surrogate'] = om.ResponseSurface() prob = om.Problem() prob.model.add_subsystem('interp', interp) prob.setup() viz = MetaModelVisualization(interp) training_points_output = viz._unstructured_training_points() self.assertTrue(training_points_output.shape[1] == 2)
def test_basics(self): # create a metamodel component mm = om.MetaModelUnStructuredComp() mm.add_input('x1', 0.) mm.add_input('x2', 0.) mm.add_output('y1', 0.) mm.add_output('y2', 0., surrogate=om.KrigingSurrogate()) mm.options['default_surrogate'] = om.ResponseSurface() # add metamodel to a problem prob = om.Problem() prob.model.add_subsystem('mm', mm) prob.setup() # check that surrogates were properly assigned surrogate = mm._metadata('y1').get('surrogate') self.assertTrue(isinstance(surrogate, om.ResponseSurface)) surrogate = mm._metadata('y2').get('surrogate') self.assertTrue(isinstance(surrogate, om.KrigingSurrogate)) # populate training data mm.options['train:x1'] = [1.0, 2.0, 3.0] mm.options['train:x2'] = [1.0, 3.0, 4.0] mm.options['train:y1'] = [3.0, 2.0, 1.0] mm.options['train:y2'] = [1.0, 4.0, 7.0] # run problem for provided data point and check prediction prob['mm.x1'] = 2.0 prob['mm.x2'] = 3.0 self.assertTrue(mm.train) # training will occur before 1st run prob.run_model() assert_near_equal(prob['mm.y1'], 2.0, .00001) assert_near_equal(prob['mm.y2'], 4.0, .00001) # run problem for interpolated data point and check prediction prob['mm.x1'] = 2.5 prob['mm.x2'] = 3.5 self.assertFalse(mm.train) # training will not occur before 2nd run prob.run_model() assert_near_equal(prob['mm.y1'], 1.5934, .001) # change default surrogate, re-setup and check that metamodel re-trains mm.options['default_surrogate'] = om.KrigingSurrogate() prob.setup() surrogate = mm._metadata('y1').get('surrogate') self.assertTrue(isinstance(surrogate, om.KrigingSurrogate)) self.assertTrue(mm.train) # training will occur after re-setup
def setup(self): # Training Data x_train = np.linspace(0, 10, 20) y_train = np.linspace(0, 20, 20) # Inputs self.add_input('simple_x', 0., training_data=x_train) self.add_input('sin_x', 0., training_data=x_train) # Outputs self.add_output('cos_x', 0., training_data=.5*np.cos(y_train)) # Surrogate Model self.options['default_surrogate'] = om.ResponseSurface()
def test_warning_bug(self): # Make sure we don't warn that we are doing FD when the surrogate has analytic derivs. x_train = np.arange(0., 10.) y_train = np.arange(10., 20.) z_train = x_train**2 + y_train**2 p = om.Problem() p.model = m = om.Group() params = om.IndepVarComp() params.add_output('x', val=0.) params.add_output('y', val=0.) m.add_subsystem('params', params, promotes=['*']) sm = om.MetaModelUnStructuredComp( default_surrogate=om.ResponseSurface()) sm.add_input('x', val=0.) sm.add_input('y', val=0.) sm.add_output('z', val=0.) sm.options['train:x'] = x_train sm.options['train:y'] = y_train sm.options['train:z'] = z_train # With or without the line below does not matter # Only when method is set to fd, then RuntimeWarning disappears sm.declare_partials('*', '*', method='exact') m.add_subsystem('sm', sm, promotes=['*']) m.add_design_var('x', lower=0., upper=10.) m.add_design_var('y', lower=0., upper=10.) m.add_objective('z') p.setup(check=True) stderr = sys.stderr str_err = StringIO() sys.stderr = str_err try: p.final_setup() finally: sys.stderr = stderr output = str_err.getvalue() self.assertTrue('finite difference' not in output)
def test_setup_message(self): x_train = np.arange(0., 10.) y_train = np.arange(10., 20.) z_train = x_train**2 + y_train**2 p = om.Problem() p.model = model = om.Group() params = om.IndepVarComp() params.add_output('x', val=0.) params.add_output('y', val=0.) model.add_subsystem('params', params, promotes=['*']) sm = om.MetaModelUnStructuredComp( default_surrogate=om.ResponseSurface()) sm.add_input('x', val=0.) sm.add_input('y', val=0.) sm.add_output('z', val=0.) sm.options['train_x'] = x_train sm.options['train_y'] = y_train sm.options['train_z'] = z_train # With or without the line below does not matter # Only when method is set to fd, then RuntimeWarning disappears sm.declare_partials('*', '*', method='exact') model.add_subsystem('sm', sm, promotes=['*']) model.add_design_var('x', lower=0., upper=10.) model.add_design_var('y', lower=0., upper=10.) model.add_objective('z') p.setup() with self.assertRaises(RuntimeError) as cm: p.driver.scaling_report() msg = "Either 'run_model' or 'final_setup' must be called before the scaling report can be generated." self.assertEqual(str(cm.exception), msg) # Now, make sure it runs run_model automatically as long as we final_setup. p.final_setup() p.driver.scaling_report(show_browser=False)
def test_response_surface(self): prob = om.Problem() sin_mm = om.MetaModelUnStructuredComp() sin_mm.add_input('x', 2.1) sin_mm.add_output('f_x', 0., surrogate=om.ResponseSurface()) prob.model.add_subsystem('sin_mm', sin_mm) prob.setup(check=True) # train the surrogate and check predicted value sin_mm.options['train:x'] = np.linspace(0, 3.14, 20) sin_mm.options['train:f_x'] = .5*np.sin(sin_mm.options['train:x']) prob.set_val('sin_mm.x', 2.1) prob.run_model() assert_near_equal(prob.get_val('sin_mm.f_x'), .5*np.sin(prob.get_val('sin_mm.x')), 2e-3)
# Altitude in column 1 of xt xt[:, 1] = tmp[:, 1] / 1e3 # Trottle in column 2 of xt xt[:, 2] = tmp[:, 2] # Thrust in column 0 of yt yt[:, 0] = tmp[:, 3] / 1e5 # tsfc in column 1 of yt yt[:, 1] = tmp[:, 6] / 3600. # Set the limits of x xlimits = np.array([[0.0, 0.9], [0., 43.], [0, 1]]) # Initial surrogate call #### CHANGE THIS TO KRIGING SURROGATE WHEN GENERAL PLOTS ARE WORKING interp = om.MetaModelUnStructuredComp(default_surrogate=om.ResponseSurface()) # Inputs interp.add_input('Mach', 0., training_data=xt[:, 0]) interp.add_input('Alt', 0., training_data=xt[:, 1]) interp.add_input('Throttle', 0., training_data=xt[:, 2]) # Outputs interp.add_output('Thrust', training_data=yt[:, 0]) interp.add_output('TSFC', training_data=yt[:, 1]) # Create the problem setup prob = om.Problem() prob.model.add_subsystem('interp', interp) prob.setup() ### Start of class ###
def create_model(name): # Setup training domain l = 1 nb_sp = 25 d1 = np.linspace(-l, l, nb_sp) d2 = d1 X, Y = np.meshgrid(d1, d2) Z = function(X, Y) # Setup prediction domain a = np.linspace(-l, l, 100) pd1 = a * np.sin(a**2) pd2 = a * np.cos(a**2) po = [] err = [] # Computing the surface coord = [] res = [] for i in d1: for j in d2: res.append(function(i, j)) coord.append([i, j]) # Create the training dataset xi = np.array(coord) yi = np.transpose(np.atleast_2d(res)) # Create and train the model if name == 'Kg': k = om.KrigingSurrogate() elif name == 'RS': k = om.ResponseSurface() print('train start') k.train(xi, yi) print('train stop') # Make a prediction for i in range(0, len(a)): pres = k.predict(np.array([pd1[i], pd2[i]])) if name == 'Kg': po.append(pres[-1][-1]) err.append(po[-1] - function(pd1[i], pd2[i])) elif name == 'RS': po.append(pres[-1]) err.append(po[-1] - function(pd1[i], pd2[i])) rms = np.sqrt(np.mean(np.array(err)**2)) print('Root mean-square error {} : {}'.format(name, rms)) # Plot the training set plt.figure() ax = plt.axes(projection='3d') # ax.plot_surface(X, Y, Z) ax.plot_wireframe(X, Y, Z) #Plot the predicted set ax.scatter(pd1, pd2, po, color='red') ax.plot(pd1, pd2, err, color='gray') ax.set_xlabel('x') ax.set_ylabel('y') ax.set_zlabel('z') # plt.show() return rms