def model_experiment(self, experiment):
# initialize model generator
model_generator = ModelGenerator(experiment, use_median=self.median, name="Default Model")
with ProgressWindow(self, 'Modeling') as pbar:
# create models from data
model_generator.model_all(pbar)
self.setExperiment(experiment)
def test_general(self):
experiment = read_text_file('data/text/one_parameter_6.txt')
# initialize model generator
model_generator = ModelGenerator(experiment, RefiningModeler())
# create models from data
model_generator.model_all()
models = experiment.modelers[0].models
cp0 = Callpath('met1'), Metric('')
self.assertIsInstance(models[cp0].hypothesis, ConstantHypothesis)
self.assertAlmostEqual(models[cp0].hypothesis.function.constant_coefficient, 4.068)
cp1 = Callpath('met2'), Metric('')
self.assertIsInstance(models[cp1].hypothesis, SingleParameterHypothesis)
self.assertEqual(len(models[cp1].hypothesis.function.compound_terms), 1)
self.assertEqual(len(models[cp1].hypothesis.function.compound_terms[0].simple_terms), 1)
self.assertEqual(models[cp1].hypothesis.function.compound_terms[0].simple_terms[0].term_type, 'polynomial')
self.assertAlmostEqual(models[cp1].hypothesis.function.compound_terms[0].simple_terms[0].exponent, 2.0)
cp2 = Callpath('met3'), Metric('')
self.assertIsInstance(models[cp2].hypothesis, SingleParameterHypothesis)
self.assertEqual(len(models[cp2].hypothesis.function.compound_terms), 1)
self.assertEqual(len(models[cp2].hypothesis.function.compound_terms[0].simple_terms), 1)
self.assertEqual(models[cp2].hypothesis.function.compound_terms[0].simple_terms[0].term_type, 'polynomial')
self.assertAlmostEqual(models[cp2].hypothesis.function.compound_terms[0].simple_terms[0].exponent, 2.0)
cp3 = Callpath('met4'), Metric('')
self.assertIsInstance(models[cp3].hypothesis, SingleParameterHypothesis)
self.assertEqual(len(models[cp3].hypothesis.function.compound_terms), 1)
self.assertEqual(len(models[cp3].hypothesis.function.compound_terms[0].simple_terms), 1)
self.assertEqual(models[cp3].hypothesis.function.compound_terms[0].simple_terms[0].term_type, 'polynomial')
self.assertAlmostEqual(models[cp3].hypothesis.function.compound_terms[0].simple_terms[0].exponent, 2.0)
def remodel(self):
# set the modeler options
if self.model_mean_radio.isChecked():
use_median = False
elif self.model_median_radio.isChecked():
use_median = True
# initialize model generator
experiment = self.main_widget.getExperiment()
if experiment is None:
return
model_generator = ModelGenerator(experiment, use_median=use_median, modeler=self._modeler)
model_generator.name = self.model_name_edit.text()
# print(QCoreApplication.hasPendingEvents())
with ProgressWindow(self.main_widget, 'Generating models') as pbar:
# create models from data
model_generator.model_all(pbar)
self.main_widget.selector_widget.updateModelList()
self.main_widget.selector_widget.selectLastModel()
self.main_widget.updateMinMaxValue()
# must happen before 'valuesChanged' to update the color boxes
self.main_widget.selector_widget.tree_model.valuesChanged()
self.main_widget.update()
def test_complete_matrix_2p(self):
experiment = read_jsonlines_file('data/jsonlines/complete_matrix_2p.jsonl')
modeler = MultiParameterModeler()
modeler.single_parameter_point_selection = 'all'
# initialize model generator
model_generator = ModelGenerator(experiment, modeler)
# create models from data
model_generator.model_all()
def test_default_multi_parameter_modeling(self):
import logging
logging.basicConfig(level=logging.DEBUG)
files = [
'data/text/two_parameter_1.txt', "data/text/three_parameter_1.txt",
"data/text/three_parameter_2.txt",
"data/text/three_parameter_3.txt"
]
for f in files:
experiment = read_text_file(f)
# initialize model generator
model_generator = ModelGenerator(experiment)
# create models from data
model_generator.model_all()
def test_two_parameter_modeling(self):
import logging
logging.basicConfig(level=logging.DEBUG)
experiment = read_text_file("data/text/two_parameter_3.txt")
# initialize model generator
model_generator = ModelGenerator(experiment)
# create models from data
model_generator.model_all()
first = next(iter(experiment.modelers[0].models.values()))
for model in experiment.modelers[0].models.values():
self.assertApproxFunction(first.hypothesis.function,
model.hypothesis.function)
self.assertEqual(first.hypothesis, model.hypothesis)
def deserialize_MultiParameterModelGenerator(exp, supports_sparse, ioHelper):
userName = ioHelper.readString()
# read the options
generate_strategy = ioHelper.readString()
use_median = False
# convert generate model options to enum
if generate_strategy == "GENERATE_MODEL_MEAN":
use_median = False
elif generate_strategy == "GENERATE_MODEL_MEDIAN":
use_median = True
else:
logging.error("Invalid ModelOptions found in File.")
with ioHelper.begin_transaction():
min_number_points = ioHelper.readInt()
single_strategy = ioHelper.readString()
add_points = ioHelper.readInt()
number_add_points = ioHelper.readInt()
multi_strategy = ioHelper.readString()
# convert ints to bool values
use_add_points = bool(add_points)
decode_strategy(multi_strategy, single_strategy, supports_sparse)
return ModelGenerator(exp, MultiParameterModeler(), userName, use_median)
def setUpClass(cls) -> None:
cls.experiment = read_text_file("data/text/one_parameter_1.txt")
ModelGenerator(cls.experiment).model_all()
schema = ExperimentSchema()
# print(json.dumps(schema.dump(cls.experiment), indent=1))
exp_str = schema.dumps(cls.experiment)
cls.reconstructed: Experiment = schema.loads(exp_str)
def test_matrix_3p(self):
experiment = read_jsonlines_file('data/jsonlines/matrix_3p.jsonl')
modeler = MultiParameterModeler()
modeler.single_parameter_point_selection = 'all'
# initialize model generator
model_generator = ModelGenerator(experiment, modeler)
# create models from data
self.assertWarns(UserWarning, model_generator.model_all)
def deserialize_SingleParameterModelGenerator(exp, supports_sparse, ioHelper):
userName = ioHelper.readString()
cvMethod = ioHelper.readString()
if cvMethod == "CROSSVALIDATION_NONE":
pass
elif cvMethod == "CROSSVALIDATION_LEAVE_ONE_OUT":
pass
elif cvMethod == "CROSSVALIDATION_LEAVE_P_OUT":
pass
elif cvMethod == "CROSSVALIDATION_K_FOLD":
pass
elif cvMethod == "CROSSVALIDATION_TWO_FOLD":
pass
else:
logging.error(
"Invalid Crossvalidation Method found in File. Defaulting to No crossvalidation."
)
eps = ioHelper.readValue()
# read the options
generate_strategy = ioHelper.readString()
# convert generate model options to enum
if generate_strategy == "GENERATE_MODEL_MEAN":
use_median = False
elif generate_strategy == "GENERATE_MODEL_MEDIAN":
use_median = True
else:
use_median = False
logging.error("Invalid ModelOptions found in File.")
with ioHelper.begin_transaction():
min_number_points = ioHelper.readInt()
single_strategy = ioHelper.readString()
add_points = ioHelper.readInt()
number_add_points = ioHelper.readInt()
multi_strategy = ioHelper.readString()
# convert ints to bool values
use_add_points = add_points
decode_strategy(multi_strategy, single_strategy, supports_sparse)
return ModelGenerator(exp, SingleParameterModeler(), userName, use_median)
def setUpClass(cls) -> None:
cls.experiment = read_text_file("data/text/two_parameter_3.txt")
ModelGenerator(cls.experiment).model_all()
with tempfile.TemporaryFile() as tmp:
write_experiment(cls.experiment, tmp)
cls.reconstructed = read_experiment(tmp)
def main(args=None, prog=None):
# argparse
modelers_list = list(set(k.lower() for k in
chain(single_parameter.all_modelers.keys(), multi_parameter.all_modelers.keys())))
parser = argparse.ArgumentParser(prog=prog, description=extrap.__description__, add_help=False)
positional_arguments = parser.add_argument_group("Positional arguments")
basic_arguments = parser.add_argument_group("Optional arguments")
basic_arguments.add_argument('-h', '--help', action='help', default=argparse.SUPPRESS,
help='Show this help message and exit')
basic_arguments.add_argument("--version", action="version", version=extrap.__title__ + " " + extrap.__version__,
help="Show program's version number and exit")
basic_arguments.add_argument("--log", action="store", dest="log_level", type=str.lower, default='warning',
choices=['debug', 'info', 'warning', 'error', 'critical'],
help="Set program's log level (default: warning)")
input_options = parser.add_argument_group("Input options")
group = input_options.add_mutually_exclusive_group(required=True)
group.add_argument("--cube", action="store_true", default=False, dest="cube", help="Load data from CUBE files")
group.add_argument("--text", action="store_true", default=False, dest="text", help="Load data from text files")
group.add_argument("--talpas", action="store_true", default=False, dest="talpas",
help="Load data from Talpas data format")
group.add_argument("--json", action="store_true", default=False, dest="json",
help="Load data from JSON or JSON Lines file")
group.add_argument("--extra-p-3", action="store_true", default=False, dest="extrap3",
help="Load data from Extra-P 3 experiment")
input_options.add_argument("--scaling", action="store", dest="scaling_type", default="weak", type=str.lower,
choices=["weak", "strong"],
help="Set weak or strong scaling when loading data from CUBE files (default: weak)")
modeling_options = parser.add_argument_group("Modeling options")
modeling_options.add_argument("--median", action="store_true", dest="median",
help="Use median values for computation instead of mean values")
modeling_options.add_argument("--modeler", action="store", dest="modeler", default='default', type=str.lower,
choices=modelers_list,
help="Selects the modeler for generating the performance models")
modeling_options.add_argument("--options", dest="modeler_options", default={}, nargs='+', metavar="KEY=VALUE",
action=ModelerOptionsAction,
help="Options for the selected modeler")
modeling_options.add_argument("--help-modeler", choices=modelers_list, type=str.lower,
help="Show help for modeler options and exit",
action=ModelerHelpAction)
output_options = parser.add_argument_group("Output options")
output_options.add_argument("--out", action="store", metavar="OUTPUT_PATH", dest="out",
help="Specify the output path for Extra-P results")
output_options.add_argument("--print", action="store", dest="print_type", default="all",
choices=["all", "callpaths", "metrics", "parameters", "functions"],
help="Set which information should be displayed after modeling "
"(default: all)")
output_options.add_argument("--save-experiment", action="store", metavar="EXPERIMENT_PATH", dest="save_experiment",
help="Saves the experiment including all models as Extra-P experiment "
"(if no extension is specified, '.extra-p' is appended)")
positional_arguments.add_argument("path", metavar="FILEPATH", type=str, action="store",
help="Specify a file path for Extra-P to work with")
arguments = parser.parse_args(args)
# set log level
loglevel = logging.getLevelName(arguments.log_level.upper())
# set output print type
printtype = arguments.print_type.upper()
# set log format location etc.
if loglevel == logging.DEBUG:
# import warnings
# warnings.simplefilter('always', DeprecationWarning)
# check if log file exists and create it if necessary
# if not os.path.exists("../temp/extrap.log"):
# log_file = open("../temp/extrap.log","w")
# log_file.close()
# logging.basicConfig(format="%(levelname)s - %(asctime)s - %(filename)s:%(lineno)s - %(funcName)10s():
# %(message)s", level=loglevel, datefmt="%m/%d/%Y %I:%M:%S %p", filename="../temp/extrap.log", filemode="w")
logging.basicConfig(
format="%(levelname)s - %(asctime)s - %(filename)s:%(lineno)s - %(funcName)10s(): %(message)s",
level=loglevel, datefmt="%m/%d/%Y %I:%M:%S %p")
else:
logging.basicConfig(
format="%(levelname)s: %(message)s", level=loglevel)
# check scaling type
scaling_type = arguments.scaling_type
# set use mean or median for computation
use_median = arguments.median
# save modeler output to file?
print_path = None
if arguments.out is not None:
print_output = True
print_path = arguments.out
else:
print_output = False
if arguments.path is not None:
with ProgressBar(desc='Loading file') as pbar:
if arguments.cube:
# load data from cube files
if os.path.isdir(arguments.path):
experiment = read_cube_file(arguments.path, scaling_type)
else:
logging.error("The given path is not valid. It must point to a directory.")
sys.exit(1)
elif os.path.isfile(arguments.path):
if arguments.text:
# load data from text files
experiment = read_text_file(arguments.path, pbar)
elif arguments.talpas:
# load data from talpas format
experiment = read_talpas_file(arguments.path, pbar)
elif arguments.json:
# load data from json file
experiment = read_json_file(arguments.path, pbar)
elif arguments.extrap3:
# load data from Extra-P 3 file
experiment = read_extrap3_experiment(arguments.path, pbar)
else:
logging.error("The file format specifier is missing.")
sys.exit(1)
else:
logging.error("The given file path is not valid.")
sys.exit(1)
experiment.debug()
# initialize model generator
model_generator = ModelGenerator(
experiment, modeler=arguments.modeler, use_median=use_median)
# apply modeler options
modeler = model_generator.modeler
if isinstance(modeler, MultiParameterModeler) and arguments.modeler_options:
# set single-parameter modeler of multi-parameter modeler
single_modeler = arguments.modeler_options[SINGLE_PARAMETER_MODELER_KEY]
if single_modeler is not None:
modeler.single_parameter_modeler = single_parameter.all_modelers[single_modeler]()
# apply options of single-parameter modeler
if modeler.single_parameter_modeler is not None:
for name, value in arguments.modeler_options[SINGLE_PARAMETER_OPTIONS_KEY].items():
if value is not None:
setattr(modeler.single_parameter_modeler, name, value)
for name, value in arguments.modeler_options.items():
if value is not None:
setattr(modeler, name, value)
with ProgressBar(desc='Generating models') as pbar:
# create models from data
model_generator.model_all(pbar)
if arguments.save_experiment:
try:
with ProgressBar(desc='Saving experiment') as pbar:
if not os.path.splitext(arguments.save_experiment)[1]:
arguments.save_experiment += '.extra-p'
experiment_io.write_experiment(experiment, arguments.save_experiment, pbar)
except RecoverableError as err:
logging.error('Saving experiment: ' + str(err))
sys.exit(1)
# format modeler output into text
text = format_output(experiment, printtype)
# print formatted output to command line
print(text)
# save formatted output to text file
if print_output:
save_output(text, print_path)
else:
logging.error("No file path given to load files.")
sys.exit(1)
def test_input_1(self):
experiment = read_jsonlines_file('data/jsonlines/input_1.jsonl')
# initialize model generator
model_generator = ModelGenerator(experiment)
# create models from data
model_generator.model_all()
def setUpClass(cls) -> None:
cls.experiment = read_text_file("data/text/two_parameter_3.txt")
ModelGenerator(cls.experiment).model_all()