from collections.abc import Sequence
from typing import Optional, Union
from warnings import warn
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import MaxNLocator
from ..result import Result
from .clust_color import assign_colors
from .misc import process_result_list
from .reference_points import ReferencePoint, create_references
[docs]
def profiles(
results: Union[Result, Sequence[Result]],
ax=None,
profile_indices: Sequence[int] = None,
size: tuple[float, float] = (18.5, 6.5),
reference: Union[ReferencePoint, Sequence[ReferencePoint]] = None,
colors=None,
legends: Sequence[str] = None,
x_labels: Sequence[str] = None,
profile_list_ids: Union[int, Sequence[int]] = 0,
ratio_min: float = 0.0,
show_bounds: bool = False,
) -> plt.Axes:
"""
Plot classical 1D profile plot.
Using the posterior, e.g. Gaussian like profile.
Parameters
----------
results:
List of or single `pypesto.Result` after profiling.
ax:
List of axes objects to use.
profile_indices:
List of integer values specifying which profiles should be plotted.
size:
Figure size (width, height) in inches. Is only applied when no ax
object is specified.
reference:
List of reference points for optimization results, containing at
least a function value fval.
colors:
List of colors, or single color.
legends:
Labels for line plots, one label per result object.
x_labels:
Labels for parameter value axes (e.g. parameter names).
profile_list_ids:
Index or list of indices of the profile lists to visualize.
ratio_min:
Minimum ratio below which to cut off.
show_bounds:
Whether to show, and extend the plot to, the lower and upper bounds.
Returns
-------
ax:
The plot axes.
"""
# parse input
results, profile_list_ids, colors, legends = process_result_list_profiles(
results, profile_list_ids, colors, legends
)
# get the parameter ids to be plotted
profile_indices = process_profile_indices(
results, profile_indices, profile_list_ids
)
# loop over results
for i_result, result in enumerate(results):
for i_profile_list, profile_list_id in enumerate(profile_list_ids):
fvals = handle_inputs(
result,
profile_indices=profile_indices,
profile_list=profile_list_id,
ratio_min=ratio_min,
)
# add x_labels for parameters
if x_labels is None:
x_labels = [
name
for name, fval in zip(result.problem.x_names, fvals)
if fval is not None
]
# plot multiple results or profile runs into one figure?
if len(results) == 1 and len(profile_list_ids) > 1:
# multiple profile runs per axes object
color_ind = i_profile_list
else:
# multiple results per axes object
color_ind = i_result
# call lowlevel routine
ax = profiles_lowlevel(
fvals=fvals,
ax=ax,
size=size,
color=colors[color_ind],
legend_text=legends[color_ind],
x_labels=x_labels,
show_bounds=show_bounds,
lb_full=result.problem.lb_full,
ub_full=result.problem.ub_full,
)
# parse and apply plotting options
ref = create_references(references=reference)
# plot reference points
ax = handle_reference_points(ref, ax, profile_indices)
plt.tight_layout()
return ax
[docs]
def profiles_lowlevel(
fvals: Union[float, Sequence[float]],
ax: Optional[Sequence[plt.Axes]] = None,
size: tuple[float, float] = (18.5, 6.5),
color=None,
legend_text: str = None,
x_labels=None,
show_bounds: bool = False,
lb_full: Sequence[float] = None,
ub_full: Sequence[float] = None,
) -> list[plt.Axes]:
"""
Lowlevel routine for profile plotting.
Working with a list of arrays only, opening different axes objects in case.
Parameters
----------
fvals:
Values to plot.
ax:
List of axes object to use.
size:
Figure size (width, height) in inches. Is only applied when no ax
object is specified.
color: RGBA, optional
Color for profiles in plot.
legend_text:
Label for line plots.
show_bounds:
Whether to show, and extend the plot to, the lower and upper bounds.
lb_full:
Lower bound.
ub_full:
Upper bound.
Returns
-------
The plot axes.
"""
# axes
if ax is None:
ax = []
fig = plt.figure()
fig.set_size_inches(*size)
create_new_ax = True
else:
plt.axes(ax[0])
fig = plt.gcf()
create_new_ax = False
# count number of necessary axes
if isinstance(fvals, Sequence):
n_fvals = len(fvals)
else:
n_fvals = 1
fvals = [fvals]
# number of non-trivial profiles
n_profiles = sum(fval is not None for fval in fvals)
# if axes already exists, we have to match profiles to axes
if not create_new_ax:
if n_fvals != len(ax) and n_profiles != len(ax):
raise ValueError(
"Number of axes does not match number of profiles. Stopping."
)
elif n_fvals == len(ax) and n_profiles != len(ax):
# we may have some empty profiles, which we have to skip
n_plots = n_fvals
else:
# n_profiles == len(ax):, we have exactly as many profiles as axes
n_plots = n_profiles
else:
n_plots = n_profiles
if lb_full is None:
lb_full = [None] * len(fvals)
if ub_full is None:
ub_full = [None] * len(fvals)
# compute number of columns and rows
columns = np.ceil(np.sqrt(n_plots))
if n_plots > columns * (columns - 1):
rows = columns
else:
rows = columns - 1
counter = 0
for i_plot, (fval, lb, ub) in enumerate(zip(fvals, lb_full, ub_full)):
# if we have empty profiles and more axes than profiles: skip
if n_plots != n_fvals and fval is None:
continue
# handle legend
if i_plot == 0:
tmp_legend = legend_text
else:
tmp_legend = None
# create or choose an axes object
if create_new_ax:
ax.append(fig.add_subplot(int(rows), int(columns), counter + 1))
else:
plt.axes(ax[counter])
# plot if data
if fval is not None:
# run lowlevel routine for one profile
ax[counter] = profile_lowlevel(
fval,
ax[counter],
size=size,
color=color,
legend_text=tmp_legend,
show_bounds=show_bounds,
lb=lb,
ub=ub,
)
# labels
if x_labels is None:
ax[counter].set_xlabel(f"Parameter {i_plot}")
else:
ax[counter].set_xlabel(x_labels[counter])
if counter % columns == 0:
ax[counter].set_ylabel("Log-posterior ratio")
else:
# fix pyPESTO/pyPESTO/pypesto/visualize/profiles.py:228:
# UserWarning: FixedFormatter should only be used
# together with FixedLocator. Fix from matplotlib #18848.
ax[counter].set_yticks(ax[counter].get_yticks())
ax[counter].set_yticklabels(["" for _ in ax[counter].get_yticks()])
# increase counter and cleanup legend
counter += 1
return ax
[docs]
def profile_lowlevel(
fvals: Sequence[float],
ax: Optional[plt.Axes] = None,
size: tuple[float, float] = (18.5, 6.5),
color=None,
legend_text: str = None,
show_bounds: bool = False,
lb: float = None,
ub: float = None,
) -> plt.Axes:
"""
Lowlevel routine for plotting one profile, working with a numpy array only.
Parameters
----------
fvals:
Values to plot.
ax:
Axes object to use.
size:
Figure size (width, height) in inches. Is only applied when no ax
object is specified.
color: RGBA, optional
Color for profiles in plot.
legend_text:
Label for line plots.
show_bounds:
Whether to show, and extend the plot to, the lower and upper bounds.
lb:
Lower bound.
ub:
Upper bound.
Returns
-------
The plot axes.
"""
# parse input
fvals = np.asarray(fvals)
# get colors
color = assign_colors([1.0], color)
# axes
if ax is None:
ax = plt.subplots()[1]
ax.set_xlabel("Parameter value")
ax.set_ylabel("Log-posterior ratio")
fig = plt.gcf()
fig.set_size_inches(*size)
# plot
if fvals.size != 0:
ax.xaxis.set_major_locator(MaxNLocator(integer=True))
ax.plot(fvals[0, :], fvals[1, :], color=color[0], label=legend_text)
if legend_text is not None:
ax.legend()
if show_bounds:
ax.set_xlim([lb, ub])
return ax
def handle_reference_points(ref, ax, profile_indices):
"""
Handle reference points.
Parameters
----------
ref: list, optional
List of reference points for optimization results, containing et
least a function value fval
ax: matplotlib.Axes, optional
Axes object to use.
profile_indices: list of integer values
List of integer values specifying which profiles should be plotted.
"""
if len(ref) > 0:
# loop over axes objects
for i_par, i_ax in enumerate(ax):
for i_ref in ref:
current_x = i_ref["x"][profile_indices[i_par]]
i_ax.plot(
[current_x, current_x],
[0.0, 1.0],
color=i_ref.color,
label=i_ref.legend,
)
# create legend for reference points
if i_ref.legend is not None:
i_ax.legend()
return ax
def handle_inputs(
result: Result,
profile_indices: Sequence[int],
profile_list: int,
ratio_min: float,
) -> list[np.array]:
"""
Retrieve the values of the profiles to be plotted.
Parameters
----------
result:
Profile result obtained by 'profile.py'.
profile_indices:
Sequence of integer values specifying which profiles should be plotted.
profile_list:
Index of the profile list to be used for profiling.
ratio_min:
Exclude values where profile likelihood ratio is smaller than
ratio_min.
Returns
-------
List of parameter values and ratios that need to be plotted.
"""
# extract ratio values from result
fvals = []
for i_par in range(0, len(result.profile_result.list[profile_list])):
if (
i_par in profile_indices
and result.profile_result.list[profile_list][i_par] is not None
):
xs = result.profile_result.list[profile_list][i_par].x_path[
i_par, :
]
ratios = result.profile_result.list[profile_list][
i_par
].ratio_path[:]
# constrain
indices = np.where(ratios > ratio_min)
xs = xs[indices]
ratios = ratios[indices]
fvals_for_par = np.array([xs, ratios])
else:
fvals_for_par = None
fvals.append(fvals_for_par)
return fvals
def process_result_list_profiles(
results: Result,
profile_list_ids: Sequence[int],
colors: Sequence[np.array],
legends: Union[str, list],
) -> Sequence[int]:
"""
Assign colors and legends to a list of results.
Takes also care of the special cases for profile plotting.
Parameters
----------
results: list or pypesto.Result
List of or single `pypesto.Result` after profiling.
profile_list_ids: int or list of ints, optional
Index or list of indices of the profile lists to be used for profiling.
colors: list of RGBA colors for plotting.
legends: list of str
Legends for plotting
Returns
-------
profile_indices: list of integer values
corrected list of integer values specifying which profiles should be
plotted.
"""
# ensure list of ids
if isinstance(profile_list_ids, int):
profile_list_ids = [profile_list_ids]
# check if we have a single result
if isinstance(results, list):
if len(results) != 1:
# if we have no single result, then use the standard api
results, colors, legends = process_result_list(
results, colors, legends
)
return results, profile_list_ids, colors, legends
else:
# a single results was provided, so make a list out of it
results = [results]
# If we have a single result, we may still have multiple profile_list_ids
# which should be plotted separately: use profile_list_ids as results dummy
_, colors, legends = process_result_list(profile_list_ids, colors, legends)
return results, profile_list_ids, colors, legends
def process_profile_indices(
results: Sequence[Result],
profile_indices: Sequence[int],
profile_list_ids: Union[int, Sequence[int]],
):
"""
Clean up profile_indices to be plotted.
Retrieve the indices of the parameter for which profiles should be
plotted later from a list of pypesto.ProfileResult objects.
"""
# get all parameter indices, for which profiles were computed
plottable_indices = set()
for result in results:
for profile_list_id in profile_list_ids:
# get parameter indices, for which profiles were computed
if profile_list_id < len(result.profile_result.list):
tmp_indices = [
par_id
for par_id, prof in enumerate(
result.profile_result.list[profile_list_id]
)
if prof is not None
]
# profile_indices should contain all parameter indices,
# for which in at least one of the results a profile exists
plottable_indices.update(tmp_indices)
plottable_indices = sorted(plottable_indices)
# get the profiles, which should be plotted and sanitize, if not plottable
if profile_indices is None:
profile_indices_ret = list(plottable_indices)
else:
profile_indices_ret = list(profile_indices)
for ind in profile_indices:
if ind not in plottable_indices:
profile_indices_ret.remove(ind)
warn(
f"Requested to plot profile for parameter index {ind}, "
"but profile has not been computed.",
stacklevel=2,
)
return profile_indices_ret