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]")
