52 #include "Teuchos_Array.hpp" 53 #include "Teuchos_CommHelpers.hpp" 55 #include "Teuchos_RawParameterListHelpers.hpp" 92 #ifdef HAVE_MUELU_AVATAR 95 #include "avatar_api.h" 104 RCP<const ParameterList> AvatarInterface::GetValidParameterList()
const {
105 RCP<ParameterList> validParamList = rcp(
new ParameterList());
107 Teuchos::ParameterList pl_dummy;
108 Teuchos::Array<std::string> ar_dummy;
112 validParamList->set<Teuchos::Array<std::string> >(
"avatar: decision tree files",ar_dummy,
"Names of Avatar decision tree files");
115 validParamList->set<Teuchos::Array<std::string> >(
"avatar: names files",ar_dummy,
"Names of Avatar decision names files");
118 validParamList->set<Teuchos::Array<std::string> >(
"avatar: filestem",ar_dummy,
"Filestem for the files Avatar requires");
121 validParamList->set<Teuchos::ParameterList>(
"avatar: muelu parameter mapping",pl_dummy,
"Mapping of MueLu to Avatar Parameters");
124 validParamList->set<
int>(
"avatar: good class",int_dummy,
"Numeric code for class Avatar considers to be good");
127 validParamList->set<
int>(
"avatar: heuristic",int_dummy,
"Numeric code for which heurisitc we want to use");
130 validParamList->set<Teuchos::Array<std::string> >(
"avatar: bounds file",ar_dummy,
"Bounds file for Avatar extrapolation risk");
132 return validParamList;
137 Teuchos::ArrayRCP<std::string> AvatarInterface::ReadFromFiles(
const char * paramName)
const {
139 Teuchos::Array<std::string> & tf = params_.get<Teuchos::Array<std::string> >(paramName);
140 Teuchos::ArrayRCP<std::string> treelist;
142 if (comm_->getRank() == 0) {
143 treelist.resize(tf.size());
144 for(Teuchos_Ordinal i=0; i<tf.size(); i++) {
146 std::stringstream ss;
149 treelist[i] = ss.str();
159 void AvatarInterface::Setup() {
161 if(comm_.is_null())
throw std::runtime_error(
"MueLu::AvatarInterface::Setup(): Communicator cannot be null");
164 avatarStrings_ = ReadFromFiles(
"avatar: decision tree files");
165 namesStrings_ = ReadFromFiles(
"avatar: names files");
166 boundsString_ = ReadFromFiles(
"avatar: bounds file");
167 filestem_ = params_.get<Teuchos::Array<std::string>>(
"avatar: filestem");
170 if(comm_->getRank() == 0) {
173 const int namesfile_is_a_string = 1;
174 const int treesfile_is_a_string = 1;
175 avatarHandle_ = avatar_load(const_cast<char*>(filestem_[0].c_str()),const_cast<char*>(namesStrings_[0].c_str()),namesfile_is_a_string,const_cast<char*>(avatarStrings_[0].c_str()),treesfile_is_a_string);
180 avatarGoodClass_ = params_.get<
int>(
"avatar: good class");
182 heuristicToUse_ = params_.get<
int>(
"avatar: heuristic");
185 UnpackMueLuMapping();
190 void AvatarInterface::Cleanup() {
191 avatar_cleanup(avatarHandle_);
197 void AvatarInterface::GenerateFeatureString(
const Teuchos::ParameterList & problemFeatures, std::string & featureString)
const {
199 std::stringstream ss;
200 for(Teuchos::ParameterList::ConstIterator i=problemFeatures.begin(); i != problemFeatures.end(); i++) {
202 const Teuchos::ParameterEntry& entry = problemFeatures.entry(i);
203 if(i!=problemFeatures.begin()) ss<<
",";
204 entry.leftshift(ss,
false);
206 featureString = ss.str();
210 void AvatarInterface::UnpackMueLuMapping() {
211 const Teuchos::ParameterList & mapping = params_.get<Teuchos::ParameterList>(
"avatar: muelu parameter mapping");
216 int numParams = mapping.numParams();
218 mueluParameterName_.resize(numParams);
219 avatarParameterName_.resize(numParams);
220 mueluParameterValues_.resize(numParams);
221 avatarParameterValues_.resize(numParams);
224 std::stringstream ss;
225 ss <<
"param" << idx;
226 if(mapping.isSublist(ss.str())) {
227 const Teuchos::ParameterList & sublist = mapping.sublist(ss.str());
230 mueluParameterName_[idx] = sublist.get<std::string>(
"muelu parameter");
231 avatarParameterName_[idx] = sublist.get<std::string>(
"avatar parameter");
235 mueluParameterValues_[idx] = sublist.get<Teuchos::Array<double> >(
"muelu values");
236 avatarParameterValues_[idx] = sublist.get<Teuchos::Array<double> >(
"avatar values");
246 throw std::runtime_error(
"MueLu::AvatarInterface::UnpackMueLuMapping(): 'avatar: muelu parameter mapping' has unknown fields");
249 std::string AvatarInterface::ParamsToString(
const std::vector<int> & indices)
const {
250 std::stringstream ss;
251 for(Teuchos_Ordinal i=0; i<avatarParameterValues_.size(); i++) {
252 ss <<
"," << avatarParameterValues_[i][indices[i]];
258 void AvatarInterface::SetIndices(
int id,std::vector<int> & indices)
const {
260 int numParams = (int)avatarParameterValues_.size();
262 for(
int i=0; i<numParams; i++) {
263 int div = avatarParameterValues_[i].size();
264 int mod = curr_id % div;
266 curr_id = (curr_id - mod)/div;
273 void AvatarInterface::GenerateMueLuParametersFromIndex(
int id,Teuchos::ParameterList & pl)
const {
275 int numParams = (int)avatarParameterValues_.size();
277 for(
int i=0; i<numParams; i++) {
278 int div = avatarParameterValues_[i].size();
279 int mod = curr_id % div;
280 pl.set(mueluParameterName_[i],mueluParameterValues_[i][mod]);
281 curr_id = (curr_id - mod)/div;
287 void AvatarInterface::SetMueLuParameters(
const Teuchos::ParameterList & problemFeatures, Teuchos::ParameterList & mueluParams,
bool overwrite)
const {
288 Teuchos::ParameterList avatarParams;
289 std::string paramString;
291 if (comm_->getRank() == 0) {
293 if(!avatarHandle_)
throw std::runtime_error(
"MueLu::AvatarInterface::SetMueLuParameters(): Setup has not been run");
296 std::string trialString;
297 GenerateFeatureString(problemFeatures,trialString);
300 int numParams = (int)avatarParameterValues_.size();
301 std::vector<int> indices(numParams);
302 std::vector<int> sizes(numParams);
304 for(
int i=0; i<numParams; i++) {
305 sizes[i] = avatarParameterValues_[i].size();
306 num_combos *= avatarParameterValues_[i].size();
308 GetOStream(
Runtime0)<<
"MueLu::AvatarInterface: Testing "<< num_combos <<
" option combinations"<<std::endl;
313 int* predictions = (
int*)malloc(8 *
sizeof(
int));
314 float* probabilities = (
float*)malloc(3 * 8 *
sizeof(
float));
316 std::string testString;
317 for(
int i=0; i<num_combos; i++) {
318 SetIndices(i,indices);
320 testString += trialString + ParamsToString(indices) +
",0\n";
323 std::cout<<
"** Avatar TestString ***\n"<<testString<<std::endl;
325 int bound_check = checkBounds(testString, boundsString_);
329 const int test_data_is_a_string = 1;
330 avatar_test(avatarHandle_,const_cast<char*>(testString.c_str()),test_data_is_a_string,predictions,probabilities);
333 std::vector<int> acceptableCombos; acceptableCombos.reserve(100);
334 for(
int i=0; i<num_combos; i++) {
335 if(predictions[i] == avatarGoodClass_) acceptableCombos.push_back(i);
337 GetOStream(
Runtime0)<<
"MueLu::AvatarInterface: "<< acceptableCombos.size() <<
" acceptable option combinations found"<<std::endl;
340 int chosen_option_id = 0;
341 if(acceptableCombos.size() == 0) {
342 GetOStream(
Runtime0) <<
"WARNING: MueLu::AvatarInterface: found *no* combinations of options which it believes will perform well on this problem" <<std::endl
343 <<
" An arbitrary set of options will be chosen instead"<<std::endl;
349 if(acceptableCombos.size() == 1){
350 chosen_option_id = acceptableCombos[0];
353 switch (heuristicToUse_){
355 chosen_option_id = hybrid(probabilities, acceptableCombos);
358 chosen_option_id = highProb(probabilities, acceptableCombos);
364 chosen_option_id = acceptableCombos[0];
367 chosen_option_id = lowCrash(probabilities, acceptableCombos);
370 chosen_option_id = weighted(probabilities, acceptableCombos);
379 if (bound_check == 0){
380 GetOStream(
Runtime0) <<
"WARNING: Extrapolation risk detected, setting drop tolerance to 0" <<std::endl;
381 GenerateMueLuParametersFromIndex(0,avatarParams);
383 GenerateMueLuParametersFromIndex(chosen_option_id,avatarParams);
391 Teuchos::updateParametersAndBroadcast(outArg(avatarParams),outArg(mueluParams),*comm_,0,overwrite);
396 int AvatarInterface::checkBounds(std::string trialString, Teuchos::ArrayRCP<std::string> boundsString_)
const {
397 std::stringstream ss(trialString);
398 std::vector<float> vect;
400 int useNewFeatures = 0;
408 if (ss.peek() ==
',')
412 std::string bounds =
const_cast<char*
>(boundsString_[0].c_str());
414 std::stringstream ssBounds(bounds);
415 std::vector<float> boundsVect;
419 while (ssBounds >> b)
421 boundsVect.push_back(b);
423 if (ssBounds.peek() ==
',')
427 if (vect.at(3) > boundsVect.at(0) || vect.at(3) < boundsVect.at(1))
430 if (vect.at(4) > boundsVect.at(2) || vect.at(4) < boundsVect.at(3))
433 if (vect.at(5) > boundsVect.at(4) || vect.at(5) < boundsVect.at(5))
436 if (vect.at(6) > boundsVect.at(6) || vect.at(6) < boundsVect.at(7))
439 if (useNewFeatures == 1){
440 if (vect.at(8) > boundsVect.at(8) || vect.at(8) < boundsVect.at(9))
443 if (vect.at(9) > boundsVect.at(10) || vect.at(9) < boundsVect.at(11))
450 int AvatarInterface::hybrid(
float * probabilities, std::vector<int> acceptableCombos)
const{
451 float low_crash = probabilities[0];
452 float best_prob = probabilities[2];
455 int chosen_option_id = acceptableCombos[0];
456 for(
int x=0; x<acceptableCombos.size(); x++){
457 this_combo = acceptableCombos[x] * 3;
458 diff = probabilities[this_combo] - low_crash;
463 low_crash = probabilities[this_combo];
464 best_prob = probabilities[this_combo + 2];
465 chosen_option_id = acceptableCombos[x];
470 else if(diff <= 0 && probabilities[this_combo + 2] > best_prob){
471 low_crash = probabilities[this_combo];
472 best_prob = probabilities[this_combo + 2];
473 chosen_option_id = acceptableCombos[x];
476 return chosen_option_id;
479 int AvatarInterface::highProb(
float * probabilities, std::vector<int> acceptableCombos)
const{
480 float high_prob = probabilities[2];
482 int chosen_option_id = acceptableCombos[0];
483 for(
int x=0; x<acceptableCombos.size(); x++){
484 this_combo = acceptableCombos[x] * 3;
487 if(probabilities[this_combo + 2] > high_prob){
488 high_prob = probabilities[this_combo + 2];
489 chosen_option_id = acceptableCombos[x];
492 return chosen_option_id;
495 int AvatarInterface::lowCrash(
float * probabilities, std::vector<int> acceptableCombos)
const{
496 float low_crash = probabilities[0];
498 int chosen_option_id = acceptableCombos[0];
499 for(
int x=0; x<acceptableCombos.size(); x++){
500 this_combo = acceptableCombos[x] * 3;
503 if(probabilities[this_combo] < low_crash){
504 low_crash = probabilities[this_combo];
505 chosen_option_id = acceptableCombos[x];
508 return chosen_option_id;
511 int AvatarInterface::weighted(
float * probabilities, std::vector<int> acceptableCombos)
const{
512 float low_crash = probabilities[0];
513 float best_prob = probabilities[2];
516 int chosen_option_id = acceptableCombos[0];
517 for(
int x=0; x<acceptableCombos.size(); x++){
518 this_combo = acceptableCombos[x] * 3;
519 diff = probabilities[this_combo] - low_crash;
524 low_crash = probabilities[this_combo];
525 best_prob = probabilities[this_combo + 2];
526 chosen_option_id = acceptableCombos[x];
531 else if(diff <= .1 && probabilities[this_combo + 2] > best_prob){
532 low_crash = probabilities[this_combo];
533 best_prob = probabilities[this_combo + 2];
534 chosen_option_id = acceptableCombos[x];
537 return chosen_option_id;
543 #endif// HAVE_MUELU_AVATAR
One-liner description of what is happening.
Namespace for MueLu classes and methods.