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):
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):
self.add('driver', DOEdriver())
self.add('driven', ArrayComponent())
self.driver.workflow.add('driven')
self.driver.DOEgenerator = OptLatinHypercube(num_samples=10)
self.driver.add_response('driven.rosen_suzuki')
self.driver.add_parameter('driven.x', low=-10., high=10.,
scaler=20., adder=10.)
def configure(self):
self.add('driver', DOEdriver())
self.add('driven', DrivenComponent())
self.driver.workflow.add('driven')
self.driver.DOEgenerator = OptLatinHypercube(num_samples=10)
self.driver.case_outputs = ['driven.rosen_suzuki']
self.driver.add_parameter(('driven.x0', 'driven.y0'),
low=-10., high=10., scaler=20., adder=10.)
for name in ['x1', 'x2', 'x3']:
self.driver.add_parameter("driven.%s" % name,
low=-10., high=10., scaler=20., adder=10.)
def __init__(self):
super(Analysis, self).__init__()
# --------------------------------------------------------------------------- #
# --- Instantiate LHC DOE Driver
# --------------------------------------------------------------------------- #
self.add('doe_driver', DOEdriver())
self.doe_driver.DOEgenerator = OptLatinHypercube(num_samples=10)
self.doe_driver.workflow = SequentialWorkflow()
# --------------------------------------------------------------------------- #
# --- Instantiate LHC Adapter Component
# --- Modifies LHC to convert continuous design variable to discrete
# --------------------------------------------------------------------------- #
self.add('adapter', AdapterComp())
# --------------------------------------------------------------------------- #
# --- Instantiate Geometry Component
# --------------------------------------------------------------------------- #
self.add('geometry', GeometryComp())
# 1--- Top Level Workflow
self.driver.workflow.add(['doe_driver'])
self.doe_driver.workflow.add(['adapter', 'geometry'])
# --------------------------------------------------------------------------- #
# --- Add parameters to DOE driver
# --------------------------------------------------------------------------- #
self.doe_driver.add_parameter('adapter.vane_num')
self.doe_driver.add_parameter('adapter.injector_loc')
self.doe_driver.add_parameter('adapter.injector_dia')
self.doe_driver.add_parameter('geometry.vane_pitch')
self.doe_driver.add_parameter('geometry.venturi_angle')
# --------------------------------------------------------------------------- #
# Specify DBcaseRecorder for DOE
# --------------------------------------------------------------------------- #
self.doe_driver.case_outputs = [
'adapter.vane_num_out', 'adapter.injector_loc_out',
'adapter.injector_dia_out', 'geometry.vane_num',
'geometry.injector_loc', 'geometry.injector_dia'
]
self.doe_driver.recorder = DBCaseRecorder(DOE_OUT_DB)
#self.add('DOE_restart', DBCaseIterator(DOE_OUT_DB))
# --------------------------------------------------------------------------- #
# --- Specify Non-NPSS Data Connections
# --------------------------------------------------------------------------- #
self.connect('adapter.vane_num_out', 'geometry.vane_num')
self.connect('adapter.injector_loc_out', 'geometry.injector_loc')
self.connect('adapter.injector_dia_out', 'geometry.injector_dia')
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):
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]")
