def __init__(self, squeeze=True, page_size='a4', **kwargs):
"""
Generate a report similar to the ones used for IPC 2008 and 2011.
If *squeeze* is True (default) use small fonts to fit in more data.
*page_size* sets the Latex page size.
"""
PlanningReport.__init__(self, **kwargs)
assert len(self.attributes) == 1, self.attributes
self.attribute = self.attributes[0]
assert self.attribute in SCORES
assert page_size in ['a2', 'a3', 'a4']
self.attribute_name = self.attribute
self.squeeze = squeeze
self.page_size = page_size
self.score = 'score_' + self.attribute
if self.attribute == 'coverage':
self.attribute = 'cost'
self.score = 'coverage'
elif self.attribute == 'quality':
self.attribute = 'cost'
self.score = 'quality'
self.normalize = True
self.best_value_column = True
def __init__(self,
show_missing=True,
get_category=None,
title=None,
xscale=None,
yscale=None,
xlabel='',
ylabel='',
matplotlib_options=None,
**kwargs):
"""
"""
kwargs.setdefault('format', 'png')
PlanningReport.__init__(self, **kwargs)
if len(self.attributes) != 1:
logging.critical('ScatterPlotReport needs exactly one attribute')
self.attribute = self.attributes[0]
# By default all values are in the same category "None".
self.get_category = get_category or (lambda run1, run2: None)
self.show_missing = show_missing
if self.output_format == 'tex':
self.writer = ScatterPgfplots
else:
self.writer = MyMatplotlib
self.title = title if title is not None else (self.attribute or '')
self._set_scales(xscale, yscale)
self.xlabel = xlabel
self.ylabel = ylabel
# If the size has not been set explicitly, make it a square.
self.matplotlib_options = matplotlib_options or {
'figure.figsize': [8, 8]
}
if 'legend.loc' in self.matplotlib_options:
logging.warning('The "legend.loc" parameter is ignored.')
def __init__(self, revision_nicks, config_nicks,
regression_attribute="coverage", **kwargs):
PlanningReport.__init__(self, **kwargs)
assert revision_nicks
self.revision_nicks = revision_nicks
assert config_nicks
self.config_nicks = config_nicks
self.regression_attribute = regression_attribute
def __init__(self,
revision_nicks,
config_nicks,
regression_attribute="coverage",
**kwargs):
PlanningReport.__init__(self, **kwargs)
assert revision_nicks
self.revision_nicks = revision_nicks
assert config_nicks
self.config_nicks = config_nicks
self.regression_attribute = regression_attribute
def __init__(self, nbest=5, total=False, **kwargs):
if "format" not in kwargs:
kwargs["format"] = "tex"
elif kwargs["format"] != "tex":
raise ValueError("unsupported format: {}".format(kwargs["format"]))
PlanningReport.__init__(self, **kwargs)
if len(self.attributes) != 1:
raise ValueError("Report needs exactly one attribute")
self.attribute = self.attributes[0]
self.nbest = nbest
self.total = total
def __init__(self, timeouts, *args, **kwargs):
"""
For all runs in the experiment, simulate the timeouts in *timeouts* and
write a new properties file at *outfile*.
*timeouts* must be a list of integer timeouts in seconds. ::
exp.add_report(TimeoutReport([60, 180, 300, 900, 1800]),
name='report-timeouts',
outfile='timeout-eval/properties')
"""
PlanningReport.__init__(self, *args, **kwargs)
self.timeouts = timeouts
def __init__(self, timeouts, *args, **kwargs):
"""
For all runs in the experiment, simulate the timeouts in *timeouts* and
write a new properties file at *outfile*.
*timeouts* must be a list of integer timeouts in seconds. ::
exp.add_report(TimeoutReport([60, 180, 300, 900, 1800]),
name='report-timeouts',
outfile='timeout-eval/properties')
"""
PlanningReport.__init__(self, *args, **kwargs)
self.timeouts = timeouts
def __init__(self, algorithms, evaluator, min_group_size=1, **kwargs):
PlanningReport.__init__(self, **kwargs)
if len(set(self.attributes)) != len(self.attributes):
raise ValueError("Attributes may not appear multiple times")
if len(algorithms) < 1:
raise ValueError("Report needs at least one algorithm")
if len(set(algorithms)) != len(algorithms):
raise ValueError("Algorithms may not appear multiple times")
self.algorithm_names = algorithms
self.algorithm_idx = {alg: i for i, alg in enumerate(algorithms)}
self.evaluator = evaluator
# values less than one imply no bound
self.min_group_size = min_group_size
evaluator.setReport(self)
def __init__(self, comparison, min_improvement=0, quantile=0.5, **kwargs):
kwargs["format"] = "tex"
PlanningReport.__init__(self, **kwargs)
if len(self.attributes) != 1:
raise ValueError("Report needs exactly one attribute")
if len(comparison) == 0:
raise ValueError("Report needs at least one comparison")
self.comparison = {
id(comp): comp
for comp in map(_make_comparison_map, comparison)
}
self.attribute = self.attributes[0]
self.min_improvement = min_improvement
self.quantile = quantile
def __init__(self, resolution='combined', colored=True, **kwargs):
"""
*resolution* must be one of "domain" or "problem" or "combined" (default).
If *colored* is True, the values of each row will be given colors from a
colormap. Only HTML reports can be colored currently.
"""
PlanningReport.__init__(self, **kwargs)
assert resolution in ['domain', 'problem', 'combined']
self.resolution = resolution
if colored and 'html' not in self.output_format:
logging.info('Only HTML reports can be colored. Setting colored=False.')
colored = False
self.colored = colored
self.toc = False
def __init__(self, resolution="combined", colored=True, **kwargs):
"""
*resolution* must be one of "domain" or "problem" or "combined" (default).
If *colored* is True, the values of each row will be given colors from a
colormap. Only HTML reports can be colored currently.
"""
PlanningReport.__init__(self, **kwargs)
assert resolution in ["domain", "problem", "combined"]
self.resolution = resolution
if colored and "html" not in self.output_format:
logging.info("Only HTML reports can be colored. Setting colored=False.")
colored = False
self.colored = colored
self.toc = False
def __init__(self, sort=False, **kwargs):
"""
If *sort* is True, sort algorithms from "weakest" to
"strongest". The "strength" of an algorithm A is the number of
other algorithms against which A "wins" in a per-domain
comparison.
"""
PlanningReport.__init__(self, **kwargs)
if len(self.attributes) != 1:
raise ValueError("Report needs exactly one attribute")
self.attribute = self.attributes[0]
self.sort = sort
if self.attribute.min_wins is None:
raise ValueError(
"Report needs an Attribute object with min_wins={True,False}")
def __init__(self, count=100, min=None, max=None, **kwargs):
if "format" not in kwargs:
kwargs["format"] = "txt"
elif kwargs["format"] != "txt":
raise ValueError("unsupported format: {}".format(kwargs["format"]))
if min is not None and max is not None and min >= max:
raise ValueError("min must be below max: {} >= {}".format(
min, max))
PlanningReport.__init__(self, **kwargs)
self.attributes = kwargs["attributes"]
if len(self.attributes) != 1:
raise ValueError("Report needs exactly one attribute")
self.attribute = self.attributes[0]
self.count = int(count)
self.min = min
self.max = max
def __init__(self,
algorithm,
n_best=1,
n_worst=0,
eval_attrib="expansions_until_last_jump",
**kwargs):
if "format" not in kwargs:
kwargs["format"] = "txt"
elif kwargs["format"] != "txt":
raise ValueError("unsupported format: {}".format(kwargs["format"]))
kwargs["attributes"] = ["h_split_statistics"]
PlanningReport.__init__(self, **kwargs)
self.attribute = self.attributes[0]
self.algorithm = algorithm
if n_best <= 0 and n_worst <= 0:
raise ValueError("Report must select at least one run")
self.n_best = n_best
self.n_worst = n_worst
self.eval_attrib = eval_attrib
self.min_wins = getattr(eval_attrib, "min_wins", True)
def __init__(self,
show_missing=True,
get_category=None,
title=None,
xscale=None,
yscale=None,
xlabel='',
ylabel='',
search_param=None,
matplotlib_options=None,
time_limit=1800,
**kwargs):
kwargs.setdefault('format', 'png')
PlanningReport.__init__(self, **kwargs)
self.time_limit = time_limit
self.search_param = search_param
if len(self.attributes) != 1:
logging.critical('CactusPlotReport needs exactly one attribute')
self.attribute = self.attributes[0]
# By default all values are in the same category "None".
self.show_missing = show_missing
if self.output_format == 'tex':
self.writer = ScatterPgfplots #TODO
else:
self.writer = CactusMatplotlib #TODO
self.title = title if title is not None else (
"Instances solved over time" or '')
self._set_scales(xscale, yscale)
self.xlabel = fill(xlabel, 25)
self.ylabel = fill(ylabel, 25)
# If the size has not been set explicitly, make it a square.
self.matplotlib_options = matplotlib_options or {
'figure.figsize': [8, 8]
}
if 'legend.loc' in self.matplotlib_options:
logging.warning('The "legend.loc" parameter is ignored.')
def __init__(self,
relative=False,
show_missing=True,
get_category=None,
title=None,
scale=None,
xlabel='',
ylabel='',
matplotlib_options=None,
**kwargs):
"""
If *relative* is False, create a "standard" scatter plot with a
diagonal line. If *relative* is True, create a relative scatter
plot where each point *(x, y)* corresponds to a task for which
the first algorithm yields a value of *x* and the second
algorithm yields *x * y*. Relative scatter plots are less common
in the literature, but often show small differences between
algorithms better than "standard" scatter plots.
The keyword argument *attributes* must contain exactly one
attribute.
Use the *filter_algorithm* keyword argument to select exactly
two algorithms (see example below).
If *show_missing* is False, we only draw a point for an
algorithm pair if both algorithms have a value.
*get_category* can be a function that takes **two** runs
(dictionaries of properties) and returns a category name. This
name is used to group the points in the plot. If there is more
than one group, a legend is automatically added. Runs for which
this function returns None are shown in a default category and
are not contained in the legend. For example, to group by
domain:
>>> def domain_as_category(run1, run2):
... # run2['domain'] has the same value, because we always
... # compare two runs of the same problem.
... return run1['domain']
Example grouping by difficulty:
>>> def improvement(run1, run2):
... time1 = run1.get('search_time', 1800)
... time2 = run2.get('search_time', 1800)
... if time1 > time2:
... return 'better'
... if time1 == time2:
... return 'equal'
... return 'worse'
>>> from downward.experiment import FastDownwardExperiment
>>> exp = FastDownwardExperiment()
>>> exp.add_report(ScatterPlotReport(
... attributes=['search_time'],
... get_category=improvement))
Example comparing the number of expanded states for two
algorithms:
>>> exp.add_report(ScatterPlotReport(
... attributes=["expansions_until_last_jump"],
... filter_algorithm=["algorithm-1", "algorithm-2"],
... get_category=domain_as_category,
... format="png", # Use "tex" for pgfplots output.
... ),
... name="scatterplot-expansions")
The inherited *format* parameter can be set to 'png' (default),
'eps', 'pdf', 'pgf' (needs matplotlib 1.2) or 'tex'. For the
latter a pgfplots plot is created.
If *title* is given it will be used for the name of the plot.
Otherwise, the only given attribute will be the title. If none
is given, there will be no title.
*scale* can have the values 'linear', 'log' or 'symlog'. If
omitted, a sensible default will be used for some standard
attributes and 'log' otherwise. Relative scatter plots always
use a logarithmic scaling for the *y* axis.
*xlabel* and *ylabel* are the axis labels.
*matplotlib_options* may be a dictionary of matplotlib rc
parameters (see http://matplotlib.org/users/customizing.html):
>>> from downward.reports.scatter import ScatterPlotReport
>>> matplotlib_options = {
... 'font.family': 'serif',
... 'font.weight': 'normal',
... # Used if more specific sizes not set.
... 'font.size': 20,
... 'axes.labelsize': 20,
... 'axes.titlesize': 30,
... 'legend.fontsize': 22,
... 'xtick.labelsize': 10,
... 'ytick.labelsize': 10,
... 'lines.markersize': 10,
... 'lines.markeredgewidth': 0.25,
... 'lines.linewidth': 1,
... # Width and height in inches.
... 'figure.figsize': [8, 8],
... 'savefig.dpi': 100,
... }
>>> report = ScatterPlotReport(
... attributes=['initial_h_value'],
... matplotlib_options=matplotlib_options)
You can see the full list of matplotlib options and their
defaults by executing ::
import matplotlib
print(matplotlib.rcParamsDefault)
"""
kwargs.setdefault('format', 'png')
# Backwards compatibility.
xscale = kwargs.pop('xscale', None)
yscale = kwargs.pop('yscale', None)
if xscale or yscale:
logging.warning(
'Use "scale" parameter instead of "xscale" and "yscale".')
scale = scale or xscale or yscale
PlanningReport.__init__(self, **kwargs)
self.relative = relative
if len(self.attributes) != 1:
logging.critical('ScatterPlotReport needs exactly one attribute')
self.attribute = self.attributes[0]
# By default all values are in the same category "None".
self.get_category = get_category or (lambda run1, run2: None)
self.show_missing = show_missing
if self.output_format == 'tex':
self.writer = ScatterPgfplots
else:
self.writer = ScatterMatplotlib
self.title = title if title is not None else (self.attribute or '')
self._set_scales(scale)
self.xlabel = xlabel
self.ylabel = ylabel
# If the size has not been set explicitly, make it a square.
self.matplotlib_options = matplotlib_options or {
'figure.figsize': [8, 8]
}
if 'legend.loc' in self.matplotlib_options:
logging.warning('The "legend.loc" parameter is ignored.')
def __init__(self, **kwargs):
kwargs.setdefault('format', 'py')
PlanningReport.__init__(self, **kwargs)
def __init__(self, **kwargs):
PlanningReport.__init__(self, **kwargs)
self.colored = 'html' in self.output_format
self.use_domain_links = 'html' in self.output_format
self.toc = False
def __init__(self,
title=None,
xscale=None,
yscale=None,
xlabel='',
ylabel='',
matplotlib_options=None,
**kwargs):
"""
The inherited *format* parameter can be set to 'png' (default),
'eps', 'pdf', 'pgf' (needs matplotlib 1.2) or 'tex'. For the
latter a pgfplots plot is created.
If *title* is given it will be used for the name of the plot.
Otherwise, the only given attribute will be the title. If none
is given, there will be no title.
*xscale* and *yscale* can have the values 'linear', 'log' or
'symlog'. If omitted sensible defaults will be used.
*xlabel* and *ylabel* are the axis labels.
*matplotlib_options* may be a dictionary of matplotlib rc
parameters (see http://matplotlib.org/users/customizing.html):
>>> from downward.reports.scatter import ScatterPlotReport
>>> matplotlib_options = {
... 'font.family': 'serif',
... 'font.weight': 'normal',
... # Used if more specific sizes not set.
... 'font.size': 20,
... 'axes.labelsize': 20,
... 'axes.titlesize': 30,
... 'legend.fontsize': 22,
... 'xtick.labelsize': 10,
... 'ytick.labelsize': 10,
... 'lines.markersize': 10,
... 'lines.markeredgewidth': 0.25,
... 'lines.linewidth': 1,
... # Width and height in inches.
... 'figure.figsize': [8, 8],
... 'savefig.dpi': 100,
... }
>>> report = ScatterPlotReport(
... attributes=['initial_h_value'],
... matplotlib_options=matplotlib_options)
You can see the full list of matplotlib options and their
defaults by executing ::
import matplotlib
print matplotlib.rcParamsDefault
"""
kwargs.setdefault('format', 'png')
PlanningReport.__init__(self, **kwargs)
assert len(self.attributes) <= 1, self.attributes
self.attribute = None
if self.attributes:
self.attribute = self.attributes[0]
self.title = title if title is not None else (self.attribute or '')
self.category_styles = {}
self._set_scales(xscale, yscale)
self.xlabel = xlabel
self.ylabel = ylabel
self.xlim_left = None
self.xlim_right = None
self.ylim_bottom = None
self.ylim_top = None
self.matplotlib_options = matplotlib_options or {}
if 'legend.loc' in self.matplotlib_options:
logging.warning('The "legend.loc" parameter is ignored.')
if self.output_format == 'tex':
self.writer = PgfPlots
else:
self.writer = Matplotlib
def __init__(self, **kwargs):
PlanningReport.__init__(self, **kwargs)
def __init__(self, title=None, xscale=None, yscale=None, xlabel='', ylabel='',
xlim_left=None, xlim_right=None, ylim_bottom=None, ylim_top=None,
legend_location='upper right', category_styles=None, params=None,
**kwargs):
"""
The inherited *format* parameter can be set to 'png' (default), 'eps',
'pdf', 'pgf' (needs matplotlib 1.2) or 'tex'. For the latter a pgfplots
plot is created.
If *title* is given it will be used for the name of the plot.
Otherwise, the only given attribute will be the title. If none is given,
there will be no title.
*xscale* and *yscale* can have the values 'linear', 'log' or 'symlog'.
If omitted sensible defaults will be used.
*legend_location* must be a (x, y) pair or one of the following:
'upper right', 'upper left', 'lower left', 'lower right', 'right',
'center left', 'center right', 'lower center', 'upper center',
'center'. If *legend_location* is None, no legend will be added. ::
# Some example positions.
legend_location='lower left' # Lower left corner *inside* the plot
legend_location=(1.1, 0.5) # Right of the plot
legend_location=(0.5, 1.1) # Above the plot
legend_location=(0.5, -0.1) # Below the plot
Subclasses may group the data points into categories. These categories
are separated visually by drawing them with different styles. You can
set the styles manually by providing a dictionary *category_styles* that
maps category names to dictionaries of matplotlib drawing parameters
(see http://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes.plot).
For example to change the default style to blue stars use::
ScatterPlotReport(attributes=['expansions'],
category_styles={None: {'marker': '*', 'c': 'b'}})
*params* may be a dictionary of matplotlib rc parameters
(see http://matplotlib.org/users/customizing.html)::
params = {
'font.family': 'serif',
'font.weight': 'normal',
'font.size': 20, # Used if the more specific sizes are not set.
'axes.labelsize': 20,
'axes.titlesize': 30,
'legend.fontsize': 22,
'xtick.labelsize': 10,
'ytick.labelsize': 10,
'lines.markersize': 10,
'lines.markeredgewidth': 0.25,
'lines.linewidth': 1,
'figure.figsize': [8, 8], # Width and height in inches.
'savefig.dpi': 100,
}
ScatterPlotReport(attributes=['initial_h_value'], params=params)
"""
kwargs.setdefault('format', 'png')
PlanningReport.__init__(self, **kwargs)
assert len(self.attributes) <= 1, self.attributes
self.attribute = None
if self.attributes:
self.attribute = self.attributes[0]
self.title = title if title is not None else (self.attribute or '')
self.legend_location = legend_location
# Convert the old (marker, color) tuples to the new dict format.
category_styles = category_styles or {}
used_old_format = False
for cat, style in category_styles.items():
if not isinstance(style, dict):
assert isinstance(style, (tuple, list)), style
used_old_format = True
marker, color = style
category_styles[cat] = {'marker': marker, 'c': color}
logging.info('Converted %s to %s' % (style, category_styles[cat]))
if used_old_format:
logging.warning('The old category_styles tuple format has been '
'deprecated. You should use a dictionary mapping '
'category names to dictionaries of matplotlib params '
'instead: %s' % category_styles[cat])
self.category_styles = category_styles
self._set_scales(xscale, yscale)
self.xlabel = xlabel
self.ylabel = ylabel
self.xlim_left = 0.7
self.xlim_right = 2.8
self.ylim_bottom = 0
self.ylim_top = 110
self.params = params or {}
if self.output_format == 'tex':
self.writer = PgfPlots
else:
self.writer = Matplotlib
def __init__(self,
title=None,
xscale=None,
yscale=None,
xlabel='',
ylabel='',
xlim_left=None,
xlim_right=None,
ylim_bottom=None,
ylim_top=None,
legend_location='upper right',
category_styles=None,
params=None,
**kwargs):
"""
The inherited *format* parameter can be set to 'png' (default), 'eps',
'pdf', 'pgf' (needs matplotlib 1.2) or 'tex'. For the latter a pgfplots
plot is created.
If *title* is given it will be used for the name of the plot.
Otherwise, the only given attribute will be the title. If none is given,
there will be no title.
*xscale* and *yscale* can have the values 'linear', 'log' or 'symlog'.
If omitted sensible defaults will be used.
*legend_location* must be a (x, y) pair or one of the following:
'upper right', 'upper left', 'lower left', 'lower right', 'right',
'center left', 'center right', 'lower center', 'upper center',
'center'. If *legend_location* is None, no legend will be added. ::
# Some example positions.
legend_location='lower left' # Lower left corner *inside* the plot
legend_location=(1.1, 0.5) # Right of the plot
legend_location=(0.5, 1.1) # Above the plot
legend_location=(0.5, -0.1) # Below the plot
Subclasses may group the data points into categories. These categories
are separated visually by drawing them with different styles. You can
set the styles manually by providing a dictionary *category_styles* that
maps category names to dictionaries of matplotlib drawing parameters
(see http://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes.plot).
For example to change the default style to blue stars use::
ScatterPlotReport(attributes=['expansions'],
category_styles={None: {'marker': '*', 'c': 'b'}})
*params* may be a dictionary of matplotlib rc parameters
(see http://matplotlib.org/users/customizing.html)::
params = {
'font.family': 'serif',
'font.weight': 'normal',
'font.size': 20, # Used if the more specific sizes are not set.
'axes.labelsize': 20,
'axes.titlesize': 30,
'legend.fontsize': 22,
'xtick.labelsize': 10,
'ytick.labelsize': 10,
'lines.markersize': 10,
'lines.markeredgewidth': 0.25,
'lines.linewidth': 1,
'figure.figsize': [8, 8], # Width and height in inches.
'savefig.dpi': 100,
}
ScatterPlotReport(attributes=['initial_h_value'], params=params)
"""
kwargs.setdefault('format', 'png')
PlanningReport.__init__(self, **kwargs)
assert len(self.attributes) <= 1, self.attributes
self.attribute = None
if self.attributes:
self.attribute = self.attributes[0]
self.title = title if title is not None else (self.attribute or '')
self.legend_location = legend_location
# Convert the old (marker, color) tuples to the new dict format.
category_styles = category_styles or {}
used_old_format = False
for cat, style in category_styles.items():
if not isinstance(style, dict):
assert isinstance(style, (tuple, list)), style
used_old_format = True
marker, color = style
category_styles[cat] = {'marker': marker, 'c': color}
logging.info('Converted %s to %s' %
(style, category_styles[cat]))
if used_old_format:
logging.warning(
'The old category_styles tuple format has been '
'deprecated. You should use a dictionary mapping '
'category names to dictionaries of matplotlib params '
'instead: %s' % category_styles[cat])
self.category_styles = category_styles
self._set_scales(xscale, yscale)
self.xlabel = xlabel
self.ylabel = ylabel
self.xlim_left = xlim_left
self.xlim_right = xlim_right
self.ylim_bottom = ylim_bottom
self.ylim_top = ylim_top
self.params = params or {}
if self.output_format == 'tex':
self.writer = PgfPlots
else:
self.writer = Matplotlib
def __init__(self, sort_spec, **kwargs):
PlanningReport.__init__(self, **kwargs)
self._sort_spec = sort_spec
