def configure(self): comp = self.add('comp', Comp()) doe = self.add('doe', NeighborhoodDOEdriver()) doe.DOEgenerator = FullFactorial() doe.alpha = .1 doe.add_parameter('comp.x') doe.add_response('comp.y') doe.workflow.add('comp') meta = self.add('meta', MetaModel(params=('x', ), responses=('y', ))) meta.default_surrogate = ResponseSurface() self.connect('doe.case_inputs.comp.x', 'meta.params.x') self.connect('doe.case_outputs.comp.y', 'meta.responses.y') opt = self.add('opt', SLSQPdriver()) opt.add_parameter('meta.x', high=10., low=-10.) opt.add_objective('meta.y') opt.workflow.add('meta') drv = self.add('driver', FixedPointIterator()) drv.max_iteration = 2 drv.add_parameter('y') drv.add_constraint('y=meta.y') drv.workflow.add(['doe', 'opt'])
def configure(self): driver = self.add('driver', FixedPointIterator()) adapt = self.add('adapt', AdaptiveSampleDriver()) ei_opt = self.add('ei_opt', Genetic()) branin = self.add('branin', BraninComponent()) kwargs = {'params': ("x", "y"), 'responses': ('f_xy', )} meta = self.add('meta', MetaModel(**kwargs)) meta.default_surrogate = KrigingSurrogate() pareto = self.add('pareto', ParetoFilter(**kwargs)) ei = self.add('ei', ExpectedImprovement()) #initial training DOE adapt.DOEgenerator = OptLatinHypercube(num_samples=15) #adapt.DOEgenerator = Uniform(100) adapt.add_parameter('branin.x', low=-5, high=10) adapt.add_parameter('branin.y', low=0, high=15) adapt.add_response('branin.f_xy') #pass training data from sampler to metamodel and pareto filter self.connect('adapt.all_case_inputs.branin.x', ['meta.params.x', 'pareto.params.x']) self.connect('adapt.all_case_inputs.branin.y', ['meta.params.y', 'pareto.params.y']) self.connect('adapt.all_case_outputs.branin.f_xy', ['meta.responses.f_xy', 'pareto.responses.f_xy']) #connect meta and pareto to ei self.connect('meta.f_xy', 'ei.current') #this passes a normal distribution variable self.connect( 'pareto.pareto_outputs[0, 0]', 'ei.target' ) #for single objective, frontier is just a scalar value that is the minimum of the set #EI optimization to find next point ei_opt.opt_type = "maximize" ei_opt.population_size = 100 ei_opt.generations = 10 ei_opt.add_parameter('meta.x', low=-5, high=10) ei_opt.add_parameter('meta.y', low=0, high=15) ei_opt.add_objective('ei.PI') #could use ei.EI too #Iterative sampling process driver.add_parameter('adapt.adaptive_inputs.branin.x[0]') driver.add_parameter('adapt.adaptive_inputs.branin.y[0]') driver.add_constraint('adapt.adaptive_inputs.branin.x[0] = meta.x') driver.add_constraint('adapt.adaptive_inputs.branin.y[0] = meta.y') driver.max_iterations = 30 #Iteration Heirarchy driver.workflow.add(['adapt', 'pareto', 'ei_opt']) adapt.workflow.add(['branin']) ei_opt.workflow.add(['meta', 'ei']) #FPI now support stop conditions driver.add_stop_condition('ei.EI <= .0001')
def configure(self): # Components self.add("sin_meta_model", MetaModel()) self.sin_meta_model.model = Sin() self.sin_meta_model.default_surrogate = FloatKrigingSurrogate() # Training the MetaModel self.add("DOE_Trainer", DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() self.DOE_Trainer.DOEgenerator.num_levels = 25 self.DOE_Trainer.add_parameter("sin_meta_model.x", low=0, high=20) self.DOE_Trainer.case_outputs = ["sin_meta_model.f_x"] self.DOE_Trainer.add_event("sin_meta_model.train_next") self.DOE_Trainer.recorders = [DBCaseRecorder()] # MetaModel Validation self.add("sin_calc", Sin()) self.add("DOE_Validate", DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 200 self.DOE_Validate.add_parameter(("sin_meta_model.x", "sin_calc.x"), low=0, high=20) self.DOE_Validate.case_outputs = ["sin_calc.f_x", "sin_meta_model.f_x"] self.DOE_Validate.recorders = [DBCaseRecorder()] # Iteration Hierarchy self.driver.workflow = SequentialWorkflow() self.driver.workflow.add(['DOE_Trainer', 'DOE_Validate']) self.DOE_Trainer.workflow.add('sin_meta_model') self.DOE_Validate.workflow.add('sin_meta_model') self.DOE_Validate.workflow.add('sin_calc')
def __init__(self): super(Simulation,self).__init__() #Components self.add("sin_meta_model",MetaModel()) self.sin_meta_model.surrogate = {"default":KrigingSurrogate()} self.sin_meta_model.model = Sin() self.sin_meta_model.recorder = DBCaseRecorder() #Training the MetaModel self.add("DOE_Trainer",DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() self.DOE_Trainer.DOEgenerator.num_levels = 25 self.DOE_Trainer.add_parameter("sin_meta_model.x",low=0,high=20) self.DOE_Trainer.case_outputs = ["sin_meta_model.f_x"] self.DOE_Trainer.add_event("sin_meta_model.train_next") self.DOE_Trainer.recorders = [DBCaseRecorder()] self.DOE_Trainer.force_execute = True #MetaModel Validation self.add("sin_calc",Sin()) self.add("DOE_Validate",DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 100 self.DOE_Validate.add_parameter(("sin_meta_model.x","sin_calc.x"),low=0,high=20) self.DOE_Validate.case_outputs = ["sin_calc.f_x","sin_meta_model.f_x"] self.DOE_Validate.recorders = [DBCaseRecorder()] self.DOE_Validate.force_execute = True #Iteration Hierarchy self.driver.workflow = SequentialWorkflow() self.driver.workflow.add(['DOE_Trainer','DOE_Validate']) self.DOE_Trainer.workflow.add('sin_meta_model') self.DOE_Validate.workflow.add('sin_meta_model') self.DOE_Validate.workflow.add('sin_calc')
def configure(self): driver = self.add('driver', FixedPointIterator()) adapt = self.add('adapt', AdaptiveSampleDriver()) MOEI_opt = self.add('MOEI_opt', Genetic()) self.add('spiral', SpiralComponent()) kwargs = {'params': ("x", "y"), 'responses': ('f1_xy', 'f2_xy')} meta = self.add('meta', MetaModel(**kwargs)) meta.default_surrogate = KrigingSurrogate() self.add('pareto', ParetoFilter(**kwargs)) self.add('MOEI', MultiObjExpectedImprovement()) # initial training DOE adapt.DOEgenerator = OptLatinHypercube(num_samples=25) adapt.add_parameter('spiral.x') adapt.add_parameter('spiral.y') adapt.add_response('spiral.f1_xy') adapt.add_response('spiral.f2_xy') # pass training data from sampler to metamodel and pareto filter self.connect('adapt.all_case_inputs.spiral.x', ['meta.params.x', 'pareto.params.x']) self.connect('adapt.all_case_inputs.spiral.y', ['meta.params.y', 'pareto.params.y']) self.connect('adapt.all_case_outputs.spiral.f1_xy', ['meta.responses.f1_xy', 'pareto.responses.f1_xy']) self.connect('adapt.all_case_outputs.spiral.f2_xy', ['meta.responses.f2_xy', 'pareto.responses.f2_xy']) # connect meta and pareto to ei self.connect('[meta.f1_xy, meta.f2_xy]', 'MOEI.current') self.connect('pareto.pareto_outputs', 'MOEI.target') # MOEI optimization to find next point MOEI_opt.opt_type = "maximize" MOEI_opt.population_size = 100 MOEI_opt.generations = 10 # MOEI_opt.selection_method = "tournament" MOEI_opt.add_parameter("meta.x", low=0.75, high=5. * pi) MOEI_opt.add_parameter("meta.y", low=0.75, high=5. * pi) MOEI_opt.add_objective("MOEI.PI") # Iterative sampling process driver.add_parameter('adapt.adaptive_inputs.spiral.x[0]') driver.add_parameter('adapt.adaptive_inputs.spiral.y[0]') driver.add_constraint('adapt.adaptive_inputs.spiral.x[0] = meta.x') driver.add_constraint('adapt.adaptive_inputs.spiral.y[0] = meta.y') driver.max_iterations = 30 # Iteration Heirarchy driver.workflow.add(['adapt', 'pareto', 'MOEI_opt']) adapt.workflow.add(['spiral']) MOEI_opt.workflow.add(['meta', 'MOEI']) # FPI now support stop conditions driver.add_stop_condition('MOEI.PI <= .0001')
def configure(self): # Our component to be meta-modeled self.add("trig_calc", Trig()) # Create meta_model for two responsese self.add("trig_meta_model", MetaModel(params=('x', ), responses=('f_x_sin', 'f_x_cos'))) # Use Kriging for the f_x output self.trig_meta_model.surrogates['f_x_sin'] = LogisticRegression() self.trig_meta_model.surrogates['f_x_cos'] = FloatKrigingSurrogate() # Training the MetaModel self.add("DOE_Trainer", DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() self.DOE_Trainer.DOEgenerator.num_levels = 20 self.DOE_Trainer.add_parameter("trig_calc.x", low=0, high=20) self.DOE_Trainer.add_response('trig_calc.f_x_sin') self.DOE_Trainer.add_response('trig_calc.f_x_cos') # Pass training data to the meta model. self.connect('DOE_Trainer.case_inputs.trig_calc.x', 'trig_meta_model.params.x') self.connect('DOE_Trainer.case_outputs.trig_calc.f_x_sin', 'trig_meta_model.responses.f_x_sin') self.connect('DOE_Trainer.case_outputs.trig_calc.f_x_cos', 'trig_meta_model.responses.f_x_cos') #MetaModel Validation self.add("DOE_Validate", DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 20 self.DOE_Validate.add_parameter(("trig_meta_model.x", "trig_calc.x"), low=0, high=20) self.DOE_Validate.add_response("trig_calc.f_x_sin") self.DOE_Validate.add_response("trig_calc.f_x_cos") self.DOE_Validate.add_response("trig_meta_model.f_x_sin") self.DOE_Validate.add_response("trig_meta_model.f_x_cos") #Iteration Hierarchy self.driver.workflow.add(['DOE_Trainer', 'DOE_Validate']) self.DOE_Trainer.workflow.add('trig_calc') self.DOE_Validate.workflow.add(['trig_calc', 'trig_meta_model'])
def configure(self): # Our component to be meta-modeled self.add("sin_calc", Sin()) # Another instance of our component for head-to-head comparison with # the metamodel. self.add("sin_verify", Sin()) # Create meta_model for f_x as the response self.add("sin_meta_model", MetaModel(params=('x', ), responses=('f_x', ))) # Use Kriging for the f_x output self.sin_meta_model.default_surrogate = FloatKrigingSurrogate() # Training the MetaModel self.add("DOE_Trainer", DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() self.DOE_Trainer.DOEgenerator.num_levels = 25 self.DOE_Trainer.add_parameter("sin_calc.x", low=0, high=20) self.DOE_Trainer.add_response('sin_calc.f_x') # Pass training data to the meta model. self.connect('DOE_Trainer.case_inputs.sin_calc.x', 'sin_meta_model.params.x') self.connect('DOE_Trainer.case_outputs.sin_calc.f_x', 'sin_meta_model.responses.f_x') # Cross-validate the metamodel using random data self.add("DOE_Validate", DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 100 self.DOE_Validate.add_parameter(("sin_meta_model.x", "sin_verify.x"), low=0, high=20) # , name="combined_input" self.DOE_Validate.add_response("sin_verify.f_x") self.DOE_Validate.add_response("sin_meta_model.f_x") #Iteration Hierarchy self.driver.workflow.add(['DOE_Trainer', 'DOE_Validate']) self.DOE_Trainer.workflow.add('sin_calc') self.DOE_Validate.workflow.add(['sin_verify', 'sin_meta_model'])
def configure(self): #Components self.add("trig_meta_model", MetaModel()) self.trig_meta_model.surrogate = { "f_x_sin": LogisticRegression(), "f_x_cos": KrigingSurrogate() } self.trig_meta_model.model = Trig() self.trig_meta_model.recorder = DBCaseRecorder() #Training the MetaModel self.add("DOE_Trainer", DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() self.DOE_Trainer.DOEgenerator.num_levels = 20 self.DOE_Trainer.add_parameter("trig_meta_model.x", low=0, high=20) self.DOE_Trainer.case_outputs = [ "trig_meta_model.f_x_sin", "trig_meta_model.f_x_cos" ] self.DOE_Trainer.add_event("trig_meta_model.train_next") self.DOE_Trainer.recorders = [DBCaseRecorder()] #MetaModel Validation self.add("trig_calc", Trig()) self.add("DOE_Validate", DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 20 self.DOE_Validate.add_parameter(("trig_meta_model.x", "trig_calc.x"), low=0, high=20) self.DOE_Validate.case_outputs = [ "trig_calc.f_x_sin", "trig_calc.f_x_cos", "trig_meta_model.f_x_sin", "trig_meta_model.f_x_cos" ] self.DOE_Validate.recorders = [DBCaseRecorder()] #Iteration Hierarchy self.driver.workflow = SequentialWorkflow() self.driver.workflow.add(['DOE_Trainer', 'DOE_Validate']) self.DOE_Trainer.workflow.add('trig_meta_model') self.DOE_Validate.workflow.add('trig_meta_model') self.DOE_Validate.workflow.add('trig_calc')
def __init__(self, *args, **kwargs): super(Analysis, self).__init__(self, *args, **kwargs) self._tdir = mkdtemp() #Components self.add("A", MetaModel()) self.A.surrogate = {'default': KrigingSurrogate()} self.A.model = ConceptA() self.A.recorder = DBCaseRecorder(':memory:') self.add('DOE_maker', DOE_Maker()) self.DOE_maker.cases = [10] * 3 #self.DOE_maker.force_execute = True #Drivers self.add("trainA", DOEdriver()) self.trainA.sequential = True self.trainA.add_parameter("A.x") self.trainA.add_parameter("A.y") self.trainA.add_parameter("A.z") self.trainA.add_event("A.train_next") self.trainA.case_outputs = ['A.f1', 'A.f2'] self.trainA.recorder = DBCaseRecorder(os.path.join(self._tdir, 'A.db')) self.add('driver', Iterator()) self.driver.add_stop_condition('len(DOE_maker.cases)==0') self.driver.add_event('A.reset_training_data') self.add('res', Res()) self.res.force_execute = True #Iteration Hierarchy self.driver.workflow.add(['DOE_maker', 'trainA', 'res']) #self.driver.workflow.add(['DOE_maker','trainA']) self.trainA.workflow.add('A') #Data Connections self.connect('DOE_maker.DOEgen', 'trainA.DOEgenerator')
def __init__(self): super(Simulation, self).__init__() #Components self.add("sin_calc", Sin()) self.add("sin_verify", Sin()) self.add("sin_meta_model", MetaModel(params=('x',), responses=('f_x',))) self.sin_meta_model.default_surrogate = NeuralNet(n_hidden_nodes=5) #Training the MetaModel self.add("DOE_Trainer", DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() # Seems to need a lot of training data for decent prediction of sin(x), # at least with default 'cg' method. self.DOE_Trainer.DOEgenerator.num_levels = 2500 self.DOE_Trainer.add_parameter("sin_calc.x", low=0, high=20) self.DOE_Trainer.add_response("sin_calc.f_x") self.connect('DOE_Trainer.case_inputs.sin_calc.x', 'sin_meta_model.params.x') self.connect('DOE_Trainer.case_outputs.sin_calc.f_x', 'sin_meta_model.responses.f_x') #MetaModel Validation self.add("DOE_Validate", DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 100 self.DOE_Validate.add_parameter(("sin_meta_model.x", "sin_verify.x"), low=0, high=20) self.DOE_Validate.add_response("sin_verify.f_x") self.DOE_Validate.add_response("sin_meta_model.f_x") #Iteration Hierarchy self.driver.workflow.add(['DOE_Trainer', 'DOE_Validate']) self.DOE_Trainer.workflow.add('sin_calc') self.DOE_Validate.workflow.add(('sin_verify', 'sin_meta_model'))
def configure(self): """ Creates a new Assembly with this problem Optimal Design at (1.9776, 0, 0) Optimal Objective = 3.18339""" #objective = '(dis1.x1)**2 + dis1.z2 + dis1.y1 + exp(-dis2.y2)' #constraint1 = 'dis1.y1 > 3.16' #constraint2 = 'dis2.y2 < 24.0' # Metamodel for sellar discipline 1 self.add("meta_model_dis1", MetaModel()) self.meta_model_dis1.surrogates = {"y1": ResponseSurface()} self.meta_model_dis1.model = SellarDiscipline1() self.meta_model_dis1.recorder = DBCaseRecorder() self.meta_model_dis1.force_execute = True # Metamodel for sellar discipline 2 self.add("meta_model_dis2", MetaModel()) self.meta_model_dis2.surrogates = {"y2": ResponseSurface()} self.meta_model_dis2.model = SellarDiscipline2() self.meta_model_dis2.recorder = DBCaseRecorder() self.meta_model_dis2.force_execute = True #training metalmodel for disc1 # self.add("DOE_Trainer_dis2",NeighborhoodDOEdriver()) # self.DOE_Trainer_dis2.DOEgenerator = CentralComposite() # self.DOE_Trainer_dis2.alpha = .1 # self.DOE_Trainer_dis2.add_parameter("meta_model_dis2.z1",low=-10,high=10,start=5.0) # self.DOE_Trainer_dis2.add_parameter("meta_model_dis2.z2",low=0,high=10,start=2.0) # self.DOE_Trainer_dis2.add_parameter("meta_model_dis2.y1",low=0,high=20) # self.DOE_Trainer_dis2.add_event("meta_model_dis2.train_next") # self.DOE_Trainer_dis2.force_execute = True #optimization of global objective function self.add('sysopt', SLSQPdriver()) self.sysopt.add_objective( '(meta_model_dis1.x1)**2 + meta_model_dis1.z2 + meta_model_dis1.y1 + math.exp(-meta_model_dis2.y2)' ) self.sysopt.add_parameter(['meta_model_dis1.z1', 'meta_model_dis2.z1'], low=-10, high=10.0, start=5.0) self.sysopt.add_parameter(['meta_model_dis1.z2', 'meta_model_dis2.z2'], low=0, high=10.0, start=2.0) self.sysopt.add_parameter('meta_model_dis1.y2', low=-1e99, high=1e99) self.sysopt.add_parameter('meta_model_dis2.y1', low=-1e99, high=1e99) #feasibility constraints self.sysopt.add_constraint('meta_model_dis1.y2 <= meta_model_dis2.y2') self.sysopt.add_constraint('meta_model_dis1.y2 >= meta_model_dis2.y2') self.sysopt.add_constraint('meta_model_dis2.y1 <= meta_model_dis1.y1') self.sysopt.add_constraint('meta_model_dis2.y1 >= meta_model_dis1.y1') self.sysopt.add_constraint('3.16 < meta_model_dis1.y1') self.sysopt.add_constraint('meta_model_dis2.y2 < 24.0') self.sysopt.force_execute = True #optimization of discipline 1 (discipline 2 of the sellar problem has no local variables) self.add('local_opt_dis1', SLSQPdriver()) self.local_opt_dis1.add_objective('meta_model_dis1.y1') self.local_opt_dis1.add_parameter('meta_model_dis1.x1', low=0, high=10.0) self.local_opt_dis1.add_constraint('3.16 < meta_model_dis1.y1') self.local_opt_dis1.add_event('meta_model_dis1.train_next') self.local_opt_dis1.force_execute = True self.local_opt_dis1.workflow.add(['meta_model_dis1']) #training metalmodel for disc1 self.add("DOE_Trainer_dis1", NeighborhoodDOEdriver()) self.DOE_Trainer_dis1.DOEgenerator = CentralComposite() self.DOE_Trainer_dis1.alpha = .1 self.DOE_Trainer_dis1.add_parameter("meta_model_dis1.z1", low=-10, high=10, start=5.0) self.DOE_Trainer_dis1.add_parameter("meta_model_dis1.z2", low=0, high=10, start=2.0) self.DOE_Trainer_dis1.add_parameter("meta_model_dis1.y2", low=-100, high=100) self.DOE_Trainer_dis1.add_event("meta_model_dis1.train_next") self.DOE_Trainer_dis1.force_execute = True self.DOE_Trainer_dis1.workflow.add("local_opt_dis1") self.add('reset_train', Driver()) self.reset_train.add_event('meta_model_dis1.reset_training_data') self.reset_train.add_event('meta_model_dis2.reset_training_data') self.reset_train.workflow.add(['meta_model_dis1', 'meta_model_dis2']) self.reset_train.force_execute = True #build workflow for bliss2000 self.add('driver', FixedPointIterator()) #self.add('main_driver', IterateUntil()) #self.main_driver.max_iterations = 1 self.driver.tolerance = .0001 # self.driver.workflow.add(['local_opt_dis1','reset_train','DOE_Trainer_dis1','DOE_Trainer_dis2','sysopt']) self.driver.workflow.add(['sysopt']) self.driver.add_parameter('x1_store', low=0, high=10.0) self.driver.add_constraint('meta_model_dis1.x1 = x1_store') self.driver.add_parameter('z1_store', low=0, high=10.0) self.driver.add_constraint('meta_model_dis1.z1 = z1_store') self.driver.add_parameter('z2_store', low=0, high=10.0) self.driver.add_constraint('meta_model_dis1.z2 = z2_store')
def configure(self): self._tdir = mkdtemp() #Components self.add("branin_meta_model", MetaModel()) self.branin_meta_model.default_surrogate = KrigingSurrogate() self.branin_meta_model.model = BraninComponent() self.branin_meta_model.recorder = DBCaseRecorder(':memory:') self.branin_meta_model.force_execute = True self.add("EI", ExpectedImprovement()) self.EI.criteria = "branin_meta_model.f_xy" self.add("filter", ParetoFilter()) self.filter.criteria = ['branin_meta_model.f_xy'] self.filter.case_sets = [ self.branin_meta_model.recorder.get_iterator(), ] self.filter.force_execute = True #Driver Configuration self.add("DOE_trainer", DOEdriver()) self.DOE_trainer.sequential = True self.DOE_trainer.DOEgenerator = OptLatinHypercube(num_samples=15) #self.DOE_trainer.DOEgenerator = FullFactorial(num_levels=5) self.DOE_trainer.add_parameter("branin_meta_model.x", low=-5., high=10.) self.DOE_trainer.add_parameter("branin_meta_model.y", low=0., high=15.) self.DOE_trainer.add_event("branin_meta_model.train_next") self.DOE_trainer.case_outputs = ["branin_meta_model.f_xy"] self.DOE_trainer.recorders = [ DBCaseRecorder(os.path.join(self._tdir, 'trainer.db')) ] self.add("EI_opt", Genetic()) self.EI_opt.opt_type = "maximize" self.EI_opt.population_size = 100 self.EI_opt.generations = 10 #self.EI_opt.selection_method = "tournament" self.EI_opt.add_parameter("branin_meta_model.x", low=-5., high=10.) self.EI_opt.add_parameter("branin_meta_model.y", low=0., high=15.) self.EI_opt.add_objective("EI.PI") self.add("retrain", MyDriver()) self.retrain.add_event("branin_meta_model.train_next") self.retrain.recorders = [ DBCaseRecorder(os.path.join(self._tdir, 'retrain.db')) ] self.add("iter", IterateUntil()) self.iter.max_iterations = 30 self.iter.add_stop_condition('EI.EI <= .0001') #Iteration Heirarchy self.driver.workflow.add(['DOE_trainer', 'iter']) self.DOE_trainer.workflow.add('branin_meta_model') self.iter.workflow = SequentialWorkflow() self.iter.workflow.add(['filter', 'EI_opt', 'retrain']) self.EI_opt.workflow.add(['branin_meta_model', 'EI']) self.retrain.workflow.add('branin_meta_model') #Data Connections self.connect("filter.pareto_set", "EI.best_case") self.connect("branin_meta_model.f_xy", "EI.predicted_value")
def configure(self): self._tdir = mkdtemp() self.comp_name = None #check to make sure no more than one component is being referenced compnames = set() for param in self.parent.get_parameters().values(): compnames.update(param.get_referenced_compnames()) if len(compnames) > 1: self.parent.raise_exception('The EGO architecture can only be used on one' 'component at a time, but parameters from %s ' 'were added to the problem formulation.' %compnames, ValueError) self.comp_name = compnames.pop() #change name of component to add '_model' to it. # lets me name the metamodel as the old name self.comp= getattr(self.parent,self.comp_name) self.comp.name = "%s_model"%self.comp_name #add in the metamodel meta_model = self.parent.add(self.comp_name,MetaModel()) #metamodel now replaces old component with same name meta_model.default_surrogate = KrigingSurrogate() meta_model.model = self.comp meta_model_recorder = DBCaseRecorder(os.path.join(self._tdir,'trainer.db')) meta_model.recorder = meta_model_recorder EI = self.parent.add("EI",ExpectedImprovement()) self.objective = self.parent.get_objectives().keys()[0] EI.criteria = self.objective pfilter = self.parent.add("filter",ParetoFilter()) pfilter.criteria = [self.objective] pfilter.case_sets = [meta_model_recorder.get_iterator(),] #Driver Configuration DOE_trainer = self.parent.add("DOE_trainer",DOEdriver()) DOE_trainer.sequential = True DOE_trainer.DOEgenerator = OptLatinHypercube(num_samples=self.initial_DOE_size) for name,param in self.parent.get_parameters().iteritems(): DOE_trainer.add_parameter(param) DOE_trainer.add_event("%s.train_next"%self.comp_name) DOE_trainer.case_outputs = [self.objective] DOE_trainer.recorders = [DBCaseRecorder(':memory:')] EI_opt = self.parent.add("EI_opt",Genetic()) EI_opt.opt_type = "maximize" EI_opt.population_size = 100 EI_opt.generations = 10 #EI_opt.selection_method = "tournament" for name,param in self.parent.get_parameters().iteritems(): EI_opt.add_parameter(param) EI_opt.add_objective("EI.%s"%self.EI_PI) retrain = self.parent.add("retrain",Driver()) retrain.recorders = self.data_recorders retrain.add_event("%s.train_next"%self.comp_name) iter = self.parent.add("iter",IterateUntil()) iter.max_iterations = self.sample_iterations iter.add_stop_condition('EI.PI <= %s'%self.min_ei_pi) #Data Connections self.parent.connect("filter.pareto_set","EI.best_case") self.parent.connect(self.objective,"EI.predicted_value") #Iteration Heirarchy self.parent.driver.workflow.add(['DOE_trainer', 'iter']) #DOE_trainer.workflow.add(self.comp_name) iter.workflow = SequentialWorkflow() iter.workflow.add(['filter', 'EI_opt', 'retrain']) #EI_opt.workflow.add([self.comp_name,'EI']) retrain.workflow.add(self.comp_name)
def configure(self): """Setup a BLISS2000 architecture inside this assembly. """ global_dvs = self.parent.get_global_des_vars() des_vars=self.parent.get_des_vars_by_comp() local_dvs_by_comp = self.parent.get_local_des_vars_by_comp() global_dvs_by_comp = self.parent.get_global_des_vars_by_comp() locals=self.parent.get_local_des_vars() objective = self.parent.get_objectives().items()[0] comp_constraints = self.parent.get_constraints_by_comp() coupling = self.parent.list_coupling_vars() couple_deps = self.parent.get_coupling_deps_by_comp() couple_indeps = self.parent.get_coupling_indeps_by_comp() driver=self.parent.add("driver",FixedPointIterator()) driver.workflow = SequentialWorkflow() driver.max_iteration=15 #should be enough to converge driver.tolerance = .005 meta_models = {} self.sub_system_opts = {} system_var_map = {} for comp in des_vars: mm_name = "meta_model_%s"%comp meta_model = self.parent.add(mm_name,MetaModel()) #metamodel now replaces old component with same name driver.add_event("%s.reset_training_data"%mm_name) meta_models[comp] = meta_model meta_model.default_surrogate = ResponseSurface() #if there are locals, you need to make a SubSystemOpt assembly comp_obj = self.parent.get(comp) sso = self.parent.add('sub_system_opt_%s'%comp, SubSystemOpt(comp_obj, global_dvs_by_comp.get(comp), local_dvs_by_comp.get(comp), couple_deps.get(comp), couple_indeps.get(comp), comp_constraints.get(comp))) self.sub_system_opts[comp] = sso meta_model.model = sso for name,mapped_name in sso.var_map.iteritems(): system_var_map[name] = "%s.%s"%(mm_name,mapped_name) meta_model.recorder = DBCaseRecorder() #add a doe trainer for each metamodel dis_doe=self.parent.add("DOE_Trainer_%s"%comp,NeighborhoodDOEdriver()) for couple in couple_indeps[comp] : mapped_name = system_var_map[couple.indep.target] dis_doe.add_parameter(mapped_name,low=-1e99,high=1e99) #change to -1e99/1e99 for dv in global_dvs_by_comp[comp]: dis_doe.add_parameter(system_var_map[dv.target],low=dv.low, high=dv.high,start=dv.start) if local_dvs_by_comp.get(comp): #add weights if they are there for w in meta_model.model.weights: dis_doe.add_parameter("meta_model_%s.%s"%(comp,w),low=-3,high=3) num_params = len(dis_doe.get_parameters()) dis_doe.DOEgenerator = LatinHypercube((num_params**2+3*num_params+2)/2) dis_doe.alpha= .1 dis_doe.beta = .01 dis_doe.add_event("meta_model_%s.train_next"%comp) dis_doe.force_execute = True driver.workflow.add(dis_doe.name) #run all doe training before system optimziation #optimization of system objective function using the discipline meta models sysopt=self.parent.add('sysopt', SLSQPdriver()) sysopt.recorders = self.data_recorders sysopt.iprint = 0 sysopt.differentiator = FiniteDifference() obj2= objective[1].text #for comp in objective[1].get_referenced_compnames(): # obj2=obj2.replace(comp,"meta_model_%s"%comp) for var_name, mapped_name in system_var_map.iteritems(): obj2=obj2.replace(var_name,mapped_name) sysopt.add_objective(obj2) #add global design variables as parameters for param,group in global_dvs: plist=[system_var_map[t] for t in group.targets] sysopt.add_parameter(plist, low=group.low, high=group.high,start=group.start) #add the subsytem weights to the system optimization for comp,sso in self.sub_system_opts.iteritems(): mm_name = "meta_model_%s"%comp for w in sso.weights: sysopt.add_parameter("%s.%s"%(mm_name,w),low=-3,high=3) for key,couple in coupling.iteritems(): s=couple.indep.target mapped_name = system_var_map[s] sysopt.add_parameter(mapped_name, low=-1e99, high=1e99) #feasibility constraints, referenced to metamodels s1,s2= system_var_map[couple.dep.target], system_var_map[couple.indep.target] sysopt.add_constraint('(%s-%s)**2<=0.0001'%(s2,s1)) #sysopt.add_constraint('%s>=%s'%(s2,s1)) #add constraints, referenced to metamodels for comp,constraints in comp_constraints.iteritems(): for c in constraints: new_c = str(c) for var,mapped_name in system_var_map.iteritems(): new_c = new_c.replace(var,mapped_name) sysopt.add_constraint(new_c) driver.workflow.add('sysopt') #setup paramter for fixedpointiterator comp=des_vars.keys()[0] mm='meta_model_%s'%comp #create some placeholder variables for the fixed point iteration for l in locals: s=system_var_map[l[0]].replace(".","_") s2='%s_store'%s self.parent.add(s2,Float(0.0)) driver.add_parameter(s2 , low=l[1].low, high=l[1].high) driver.add_constraint('%s = %s'%(system_var_map[l[1].target],s2)) for i,g in enumerate(global_dvs): s2='global%d_store'%i self.parent.add(s2,Float(0.0)) driver.add_parameter(s2 , low=g[1].low, high=g[1].high) driver.add_constraint('%s = %s'%(system_var_map[g[1].target],s2))
def configure(self): self._tdir = mkdtemp() #Components self.add("spiral_meta_model", MetaModel()) self.spiral_meta_model.surrogate = {'default': KrigingSurrogate()} self.spiral_meta_model.model = SpiralComponent() self.spiral_meta_model.recorder = DBCaseRecorder(':memory:') self.spiral_meta_model.force_execute = True self.add("MOEI", MultiObjExpectedImprovement()) self.MOEI.criteria = [ 'spiral_meta_model.f1_xy', 'spiral_meta_model.f2_xy' ] self.add("filter", ParetoFilter()) self.filter.criteria = [ 'spiral_meta_model.f1_xy', 'spiral_meta_model.f2_xy' ] self.filter.case_sets = [ self.spiral_meta_model.recorder.get_iterator() ] self.filter.force_execute = True #Driver Configuration self.add("DOE_trainer", DOEdriver()) self.DOE_trainer.sequential = True self.DOE_trainer.DOEgenerator = OptLatinHypercube(num_samples=25) self.DOE_trainer.add_parameter("spiral_meta_model.x") self.DOE_trainer.add_parameter("spiral_meta_model.y") self.DOE_trainer.add_event("spiral_meta_model.train_next") self.DOE_trainer.case_outputs = [ 'spiral_meta_model.f1_xy', 'spiral_meta_model.f2_xy' ] self.DOE_trainer.recorders = [ DBCaseRecorder(os.path.join(self._tdir, 'trainer.db')) ] self.add("MOEI_opt", Genetic()) self.MOEI_opt.opt_type = "maximize" self.MOEI_opt.population_size = 100 self.MOEI_opt.generations = 10 #self.MOEI_opt.selection_method = "tournament" self.MOEI_opt.add_parameter("spiral_meta_model.x") self.MOEI_opt.add_parameter("spiral_meta_model.y") self.MOEI_opt.add_objective("MOEI.PI") self.add("retrain", MyDriver()) self.retrain.add_event("spiral_meta_model.train_next") self.retrain.recorders = [ DBCaseRecorder(os.path.join(self._tdir, 'retrain.db')) ] self.add("iter", IterateUntil()) self.iter.iterations = 30 self.iter.add_stop_condition('MOEI.PI <= .0001') #Iteration Heirarchy self.driver.workflow.add(['DOE_trainer', 'iter']) self.DOE_trainer.workflow.add('spiral_meta_model') self.iter.workflow = SequentialWorkflow() self.iter.workflow.add(['filter', 'MOEI_opt', 'retrain']) self.MOEI_opt.workflow.add(['spiral_meta_model', 'MOEI']) self.retrain.workflow.add('spiral_meta_model') #Data Connections self.connect("filter.pareto_set", "MOEI.best_cases") self.connect("spiral_meta_model.f1_xy", "MOEI.predicted_values[0]") self.connect("spiral_meta_model.f2_xy", "MOEI.predicted_values[1]")