def plot_surrogate_1D(
ax: plt.Axes,
surrogate: Surrogate,
bound: Bound,
n_points: int = 100,
) -> None:
"""Plot a 1D surrogate model.
Parameters
----------
ax: plt.Axes
matplotlib axes object on which to plot the graph.
surrogate: Surrogate
A trained surrogate model.
bound: Bound
The bound on which to plot the graph. NB: doesn't have to be the
same as the optimization bound.
n_points: int
The number of points with with to plot the graph, by default 100.
"""
x = np.linspace(bound.lower, bound.upper, n_points).reshape(-1, 1)
y_pred, sigma = surrogate.predict(x)
std = np.sqrt(np.diag(sigma))
lower = y_pred - 2 * std
upper = y_pred + 2 * std
ax.plot(x.flatten(), y_pred, label="mean")
ax.fill_between(x.flatten(),
lower,
upper,
alpha=0.5,
label="confidence interval")
ax.plot(surrogate.x.flatten(), surrogate.y, "k+", label="training data")
def plot_throughput(df: pd.DataFrame, ax: plt.Axes) -> None:
def outlier_throughput(g: pd.DataFrame) -> float:
cutoff = 0.5 * g['throughput'].max()
return g[g['throughput'] >= cutoff]['throughput'].mean() / 100000
def outlier_throughput_std(g: pd.DataFrame) -> float:
cutoff = 0.5 * g['throughput'].max()
return g[g['throughput'] >= cutoff]['throughput'].std() / 100000
# Draw throughput.
variables = ('flexible', 'num_acceptor_groups', 'num_acceptors_per_group',
'num_replicas')
grouped = df.groupby(variables)
for (name, group) in grouped:
(_, num_acceptor_groups, num_acceptors_per_group, num_replicas) = name
label = (f'{num_acceptor_groups}x{num_acceptors_per_group} ' +
f'acceptors, {num_replicas} replicas')
by_num_proxy_leaders = group.groupby('num_proxy_leaders')
throughput = by_num_proxy_leaders.apply(outlier_throughput).sort_index()
std = by_num_proxy_leaders.apply(outlier_throughput_std).sort_index()
line = ax.plot(throughput.index, throughput,
'-', marker = next(MARKERS), label=label,
linewidth=1.5)[0]
# Draw error bars.
ax.fill_between(throughput.index,
throughput - std,
throughput + std,
color=line.get_color(),
alpha=0.3)
def roc_curve(y_true: list,
y_score: list,
ax: Axes,
label: str,
colour: str,
plot_ci: bool = False):
roc_metrics = [
metrics.roc_curve(x.reshape(-1, 1), y)
for x, y in zip(y_true, y_score)
]
fpr = [x[0] for x in roc_metrics]
tpr = [x[1] for x in roc_metrics]
base_fpr = np.linspace(0, 1, 101)
tprs = list()
for fpr_, tpr_ in zip(fpr, tpr):
tpr = np.interp(base_fpr, fpr_, tpr_)
tpr[0] = 0.0
tprs.append(tpr)
tprs = np.array(tprs)
mean_tprs = tprs.mean(axis=0)
std = tprs.std(axis=0)
tprs_upper = np.minimum(mean_tprs + std, 1)
tprs_lower = mean_tprs - std
ax.plot(base_fpr, mean_tprs, c=colour, label=label)
ax.plot([0, 1], [0, 1], color='black', lw=1, linestyle='--')
if plot_ci:
ax.fill_between(base_fpr,
tprs_lower,
tprs_upper,
color=colour,
alpha=0.3)
return ax
def plot_throughput(df: pd.DataFrame, ax: plt.Axes) -> None:
def outlier_throughput(g: pd.DataFrame) -> float:
cutoff = 0.5 * g['throughput'].max()
return g[g['throughput'] >= cutoff]['throughput'].mean() / 100000
def outlier_throughput_std(g: pd.DataFrame) -> float:
cutoff = 0.5 * g['throughput'].max()
return g[g['throughput'] >= cutoff]['throughput'].std() / 100000
# Draw throughput.
grouped = df.groupby(
('leader_options.flush_phase2as_every_n', 'num_replicas'))
for (name, group) in grouped:
print(f'## {name}')
print(group[['throughput', 'latency']])
by_num_proxy_leaders = group.groupby('num_proxy_leaders')
throughput = by_num_proxy_leaders.apply(
outlier_throughput).sort_index()
std = by_num_proxy_leaders.apply(outlier_throughput_std).sort_index()
print(f'throughput = {throughput}')
print(f'std = {std}')
print()
line = ax.plot(throughput.index,
throughput,
'-',
marker=next(MARKERS),
label=name,
linewidth=1.5)[0]
# Draw error bars.
ax.fill_between(throughput.index,
throughput - std,
throughput + std,
color=line.get_color(),
alpha=0.3)
def plot_latency(ax: plt.Axes, n: int, before: pd.Series, after: pd.Series,
sample_every: int, marker: str) -> None:
median_before = before.rolling('1000ms').median()
p95_before = before.rolling('1000ms').quantile(0.95)
line = ax.plot_date(before.index[::sample_every],
median_before[::sample_every],
label='_nolegend_',
fmt='-',
marker=marker,
markevery=0.1)[0]
ax.fill_between(before.index[::sample_every],
median_before[::sample_every],
p95_before[::sample_every],
color=line.get_color(), alpha=0.25)
median_after = after.rolling('1000ms').median()
p95_after = after.rolling('1000ms').quantile(0.95)
label = '1 client' if n == 1 else f'{n} clients'
ax.plot_date(after.index[::sample_every],
median_after[::sample_every],
label=label,
color = line.get_color(),
fmt='-',
marker=marker,
markevery=0.1)
ax.fill_between(after.index[::sample_every],
median_after[::sample_every],
p95_after[::sample_every],
color=line.get_color(), alpha=0.25)
def plot_throughput(df: pd.DataFrame, ax: plt.Axes, label: str) -> None:
def outlier_throughput(g: pd.DataFrame) -> float:
cutoff = 0.5 * g['throughput'].max()
return g[g['throughput'] >= cutoff]['throughput'].mean() / 100000
def outlier_throughput_std(g: pd.DataFrame) -> float:
cutoff = 0.5 * g['throughput'].max()
return g[g['throughput'] >= cutoff]['throughput'].std() / 100000
# Draw throughput.
grouped = df.groupby('workload_label')
vprint(f'# {label}')
for (name, group) in grouped:
vprint(f'## {name}')
vprint(group[['throughput', 'latency']])
throughput = grouped.apply(outlier_throughput).sort_index()
std = grouped.apply(outlier_throughput_std).sort_index()
vprint(f'throughput = {throughput}')
vprint(f'std = {std}')
vprint()
line = ax.plot(throughput.index,
throughput,
'-',
marker=next(MARKERS),
label=label,
linewidth=1.5)[0]
# Draw error bars.
ax.fill_between(throughput.index,
throughput - std,
throughput + std,
color=line.get_color(),
alpha=0.3)
def plot_1d_data(
X_train: NDArray,
y_train: NDArray,
X_test: NDArray,
y_test: NDArray,
y_sigma: float,
y_pred: NDArray,
y_pred_low: NDArray,
y_pred_up: NDArray,
ax: plt.Axes,
title: str,
) -> None:
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_xlim([-10, 10])
ax.set_ylim([np.min(y_test) * 1.3, np.max(y_test) * 1.3])
ax.fill_between(X_test, y_pred_low, y_pred_up, alpha=0.3)
ax.scatter(X_train, y_train, color="red", alpha=0.3, label="Training data")
ax.plot(X_test, y_test, color="gray", label="True confidence intervals")
ax.plot(X_test, y_test - y_sigma, color="gray", ls="--")
ax.plot(X_test, y_test + y_sigma, color="gray", ls="--")
ax.plot(X_test, y_pred, color="b", alpha=0.5, label="Prediction intervals")
if title is not None:
ax.set_title(title)
ax.legend()
def plot_total_mass(
replicates: List[RawData],
ax: plt.Axes,
label: str = '',
color: str = 'black',
fontsize: float = 36,
) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
'''Plot total mass data on an existing set of axes.
Plots the median surrounded by a translucent band indicating the
IQR. The median and IQR are computed over the replicates.
Args:
replicates: A list of the raw data dictionary for each
replicate.
ax: The axes to plot on.
label: Label to associate with the curve showing the median
total mass.
color: Color of median curve and IQR band.
fontsize: Size of all text in figure.
Returns:
A tuple of a numpy array for each quartile.
'''
times = sorted(replicates[0].keys())
mass_timeseries = []
for replicate in replicates:
assert sorted(replicate.keys()) == times
replicate_timeseries = get_total_mass_timeseries(replicate)
mass_timeseries.append(replicate_timeseries)
mass_matrix = np.array(mass_timeseries)
median = np.median(mass_matrix, axis=0)
q25, q75 = np.percentile(mass_matrix, [25, 75], axis=0)
times_hours = tuple(time / 60 / 60 for time in times)
if label:
ax.semilogy( # type: ignore
times_hours, median, label=label, color=color)
ax.fill_between( # type: ignore
times_hours,
q25,
q75,
color=color,
alpha=0.2,
edgecolor='none')
ax.legend( # type: ignore
prop={'size': fontsize}, frameon=False)
else:
ax.semilogy( # type: ignore
times_hours, mass_timeseries, color=color)
ax.fill_between( # type: ignore
times_hours,
q25,
q75,
color=color,
alpha=0.2,
edgecolor='none')
for tick_type in ('major', 'minor'):
ax.tick_params( # type: ignore
axis='both', which=tick_type, labelsize=fontsize)
return cast(np.ndarray, q25), median, cast(np.ndarray, q75)
def plot_throughput(df: pd.DataFrame, ax: plt.Axes) -> None:
def outlier_throughput(g: pd.DataFrame) -> float:
cutoff = 0.5 * g['throughput'].max()
return g[g['throughput'] >= cutoff]['throughput'].mean() / 100000
def outlier_throughput_std(g: pd.DataFrame) -> float:
cutoff = 0.5 * g['throughput'].max()
return g[g['throughput'] >= cutoff]['throughput'].std() / 100000
# Draw throughput.
grouped = df.groupby('batcher_options.batch_size')
for (name, group) in grouped:
by_num_proxy_leaders = group.groupby('num_proxy_replicas')
throughput = by_num_proxy_leaders.apply(
outlier_throughput).sort_index()
std = by_num_proxy_leaders.apply(outlier_throughput_std).sort_index()
line = ax.plot(throughput.index,
throughput,
'-',
marker=next(MARKERS),
label=name,
linewidth=1.5)[0]
# Draw error bars.
ax.fill_between(throughput.index,
throughput - std,
throughput + std,
color=line.get_color(),
alpha=0.3)
def draw_uncertainty_bands(
uncertainty: tdub.root.TGraphAsymmErrors,
total_mc: tdub.root.TH1,
ax: plt.Axes,
axr: plt.Axes,
label: str = "Uncertainty",
edgecolor: str | int = "mediumblue",
zero_threshold: float = 0.25,
) -> None:
"""Draw uncertainty bands on both axes in stack plot with a ratio.
Parameters
----------
uncertainty : tdub.root.TGraphAsymmErrors
ROOT TGraphAsymmErrors with full systematic uncertainty.
total_mc : tdub.root.TH1
ROOT TH1 providing the full Monte Carlo prediction.
ax : matplotlib.axes.Axes
Main axis (where histogram stack is painted)
axr : matplotlib.axes.Axes
Ratio axis
label : str
Legend label for the uncertainty.
zero_threshold : float
When total MC events are below threshold, zero contents and error.
"""
lo = np.hstack([uncertainty.ylo, uncertainty.ylo[-1]])
hi = np.hstack([uncertainty.yhi, uncertainty.yhi[-1]])
mc = np.hstack([total_mc.counts, total_mc.counts[-1]])
ratio_y1 = 1 - (lo / mc)
ratio_y2 = 1 + (hi / mc)
set_to_zero = mc < zero_threshold
lo[set_to_zero] = 0.0
hi[set_to_zero] = 0.0
mc[set_to_zero] = 0.0
ratio_y1[set_to_zero] = 0.0
ratio_y2[set_to_zero] = 0.0
ax.fill_between(
x=total_mc.edges,
y1=(mc - lo),
y2=(mc + hi),
step="post",
facecolor="none",
hatch="////",
edgecolor=edgecolor,
linewidth=0.0,
label=label,
zorder=50,
)
axr.fill_between(
x=total_mc.edges,
y1=ratio_y1,
y2=ratio_y2,
step="post",
facecolor=(0, 0, 0, 0.33),
linewidth=0.0,
label=label,
zorder=50,
)
def render_mean_std(
ax: plt.Axes,
x_grid: np.ndarray,
mean: np.ndarray,
std: np.ndarray,
x_label: str,
y_label: str,
curve_label: str,
num_stds: int = 1,
alpha: float = 0.3,
color: chr = None,
show_legend: bool = True,
show_legend_std: bool = False,
title: str = None,
) -> plt.Figure:
"""
Plot the given mean and the standard deviation over given x-axis data. The plot is neither shown nor saved.
.. note::
If you want to have a tight layout, it is best to pass axes of a figure with `tight_layout=True` or
`constrained_layout=True`.
:param ax: axis of the figure to plot on
:param x_grid: data to plot on the x-axis
:param mean: mean values to plot on the y-axis
:param std: standard deviation values to plot on the y-axis
:param x_label: label for the x-axis
:param y_label: label for the y-axis
:param curve_label: label for the mean curve
:param num_stds: number of standard deviations to plot around the mean
:param alpha: transparency (alpha-value) for the std area
:param color: color (e.g. 'k'), None invokes the default behavior
:param show_legend: flag if the legend entry should be printed, set to True when using multiple subplots
:param show_legend_std: flag if a legend entry for the std area should be printed
:param title: title displayed above the figure, set to None to suppress the title
:param tight_layout: if True, the x and y axes will have no space to the plotted curves
:return: handle to the resulting figure
"""
ax.plot(x_grid, mean, label=curve_label, color=color)
if show_legend_std:
ax.fill_between(x_grid,
mean - num_stds * std,
mean + num_stds * std,
alpha=alpha,
label=f'$\pm {num_stds}$ std')
else:
ax.fill_between(x_grid,
mean - num_stds * std,
mean + num_stds * std,
alpha=alpha)
ax.set_xlabel(x_label)
ax.set_ylabel(y_label)
if show_legend:
ax.legend()
if title is not None:
ax.set_title(title)
return plt.gcf()
def fillDiffToCompare(ax: plt.Axes, analysisResult: List[float], compareValue: List[float]):
"""
Fill the difference between analysisResults and compareValue in the plot.
Call only after first plot into the figure has been done.
:param ax: The ax to plot the difference to
:param analysisResult: The first list of values of an analysis result
:param compareValue: The second list of values of another analysis result
"""
ax.fill_between(range(len(analysisResult)), analysisResult, compareValue, color='b', alpha=.4)
def plot_expression_survival_boundary(ax: plt.Axes,
boundary_x: Sequence[float],
boundary_y: Sequence[float],
boundary_error: Sequence[float],
finals: Sequence[float],
scaling: float = 1,
boundary_color: str = 'black') -> None:
'''Plot the life-death boundary on an expression-survival plot.
Args:
ax: Axes to plot on.
boundary_x: X-values of the boundary identified
numerically from the antibiotic model.
boundary_y: Y-values of the boundary identified
numerically from the antibiotic model.
boundary_error: Precision of the Y-value
predictions. This is the distance along the y axis between
the known dead point and known live point closest to the
prediction. The predicted y-value will be in the middle of
this range, so an error band can be drawn of width
boundary_error centered at boundary_y.
finals: All final cell concentrations plotted on
the figure. This is used to ensure the boundary line spans
the figure.
scaling: Coefficient to multiply all data by. This is
intended to be used for changing the units plotted.
boundary_color: Color of boundary.
'''
boundary_x_arr = np.array(boundary_x)
boundary_y_arr = np.array(boundary_y)
boundary_error_arr = np.array(boundary_error)
mask = ((min(finals) <= boundary_x_arr) & (boundary_x_arr <= max(finals)))
true_indices = np.where(mask)[0]
if len(true_indices) > 0:
min_true_idx = min(true_indices)
max_true_idx = max(true_indices)
# Make sure boundary spans entire figure
if min_true_idx > 0:
mask[min_true_idx - 1] = True
if max_true_idx < len(mask) - 1:
mask[max_true_idx + 1] = True
boundary_x_arr = boundary_x_arr[mask]
boundary_y_arr = boundary_y_arr[mask]
ax.plot( # type: ignore
boundary_x_arr * scaling,
boundary_y_arr * scaling,
c=boundary_color,
label='Boundary Predicted by Antibiotics Model')
ax.fill_between( # type: ignore
boundary_x_arr * scaling,
boundary_y_arr * scaling - boundary_error_arr * scaling / 2,
boundary_y_arr * scaling + boundary_error_arr * scaling / 2,
color=boundary_color,
alpha=0.2)
def plot_latency(ax: plt.Axes, label: str, color: str,
s: pd.Series, sample_every: int) -> None:
median = s.rolling('500ms').median()
max_latency = s.rolling('500ms').max()
# ax.set_yscale('log')
line = ax.plot_date(s.index[::sample_every], median[::sample_every],
fmt='-', color=color, markevery=0.2, label=label)[0]
# ax.plot_date(s.index[::sample_every], max_latency[::sample_every],
# fmt='--', color=color, label='_nolegend_')
ax.fill_between(s.index[::sample_every], median[::sample_every],
max_latency[::sample_every], color=line.get_color())
def plot_latency(ax: plt.Axes, s: pd.Series, sample_every: int) -> None:
median = s.rolling('1000ms').median()
p95 = s.rolling('1000ms').quantile(0.95)
line = ax.plot_date(s.index[::sample_every],
median[::sample_every],
label='100 clients',
fmt='-')[0]
ax.fill_between(s.index[::sample_every],
median[::sample_every],
p95[::sample_every],
color=line.get_color(),
alpha=0.25)
def format_trace_plot(plot: plt.Axes, trace_forward: np.ndarray,
trace_reverse: np.ndarray):
x = np.arange(n_trace + 1)[1:] * trace_spacing * 100
plot.errorbar(x,
trace_forward[:, 0],
yerr=2 * trace_forward[:, 1],
ecolor='b',
elinewidth=0,
mec='none',
mew=0,
linestyle='None',
zorder=10)
plot.plot(
x,
trace_forward[:, 0],
'b-',
marker='o',
mec='b',
mfc='w',
label='Forward',
zorder=20,
)
plot.errorbar(x,
trace_reverse[:, 0],
yerr=2 * trace_reverse[:, 1],
ecolor='r',
elinewidth=0,
mec='none',
mew=0,
linestyle='None',
zorder=10)
plot.plot(x,
trace_reverse[:, 0],
'r-',
marker='o',
mec='r',
mfc='w',
label='Reverse',
zorder=20)
y_fill_upper = [trace_forward[-1, 0] + 2 * trace_forward[-1, 1]
] * 2
y_fill_lower = [trace_forward[-1, 0] - 2 * trace_forward[-1, 1]
] * 2
xlim = [0, 100]
plot.fill_between(xlim,
y_fill_lower,
y_fill_upper,
color='orchid',
zorder=5)
plot.set_xlim(xlim)
plot.legend()
plot.set_xlabel("% Samples Analyzed", fontsize=20)
plot.set_ylabel(r"$\Delta G$ in kcal/mol", fontsize=20)
def _add_sd_area(self, element: str, ax: plt.Axes):
"""
Draw red area around the fitting line to show confidence intervals
:param element: Which variable is being plotted
:param ax: axes on which to draw the area before returning to mother function
"""
y1 = self.simulated_data_low_ci[element].to_numpy()
y2 = self.simulated_data_high_ci[element].to_numpy()
x = self.simulated_data.index
ax.fill_between(x, y1, y2, alpha=.3, linewidth=0, color="red")
return ax
def render_lo_up_avg(
ax: plt.Axes,
x_grid: np.ndarray,
lower: np.ndarray,
upper: np.ndarray,
average: np.ndarray,
x_label: str,
y_label: str,
curve_label: str,
alpha: float = 0.3,
color: chr = None,
show_legend: bool = True,
area_label: [str, None] = r'min \& max',
title: str = None,
):
"""
Plot the given average, minimum, and maximum values over given x-axis data. The plot is neither shown nor saved.
.. note::
If you want to have a tight layout, it is best to pass axes of a figure with `tight_layout=True` or
`constrained_layout=True`.
:param ax: axis of the figure to plot on
:param x_grid: data to plot on the x-axis
:param lower: minimum values to plot on the y-axis
:param upper: maximum values to plot on the y-axis
:param average: average values to plot on the y-axis
:param x_label: label for the x-axis
:param y_label: label for the y-axis
:param curve_label: label for the average curve
:param alpha: transparency (alpha-value) for the std area
:param color: color (e.g. 'k'), None invokes the default behavior
:param show_legend: flag if the legend entry should be printed, set to True when using multiple subplots
:param area_label: label for the shaded area, pass None to omit the label
:param title: title displayed above the figure, set to None to suppress the title
:param tight_layout: if True, the x and y axes will have no space to the plotted curves
:return: handle to the resulting figure
"""
if area_label is not None:
ax.fill_between(x_grid, lower, upper, alpha=alpha, label=area_label)
else:
ax.fill_between(x_grid, lower, upper, alpha=alpha)
ax.plot(x_grid, average, label=curve_label, color=color)
ax.set_xlabel(x_label)
ax.set_ylabel(y_label)
if show_legend:
ax.legend()
if title is not None:
ax.set_title(title)
return plt.gcf()
def plot_1d_data(
X_train: NDArray,
y_train: NDArray,
X_test: NDArray,
y_test: NDArray,
y_test_sigma: float,
y_pred: NDArray,
y_pred_low: NDArray,
y_pred_up: NDArray,
ax: plt.Axes,
title: str,
) -> None:
"""
Generate a figure showing the training data and estimated
prediction intervals on test data.
Parameters
----------
X_train : NDArray
Training data.
y_train : NDArray
Training labels.
X_test : NDArray
Test data.
y_test : NDArray
True function values on test data.
y_test_sigma : float
True standard deviation.
y_pred : NDArray
Predictions on test data.
y_pred_low : NDArray
Predicted lower bounds on test data.
y_pred_up : NDArray
Predicted upper bounds on test data.
ax : plt.Axes
Axis to plot.
title : str
Title of the figure.
"""
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_xlim([0, 1])
ax.set_ylim([0, 1])
ax.scatter(X_train, y_train, color="red", alpha=0.3, label="training")
ax.plot(X_test, y_test, color="gray", label="True confidence intervals")
ax.plot(X_test, y_test - y_test_sigma, color="gray", ls="--")
ax.plot(X_test, y_test + y_test_sigma, color="gray", ls="--")
ax.plot(X_test, y_pred, label="Prediction intervals")
ax.fill_between(X_test, y_pred_low, y_pred_up, alpha=0.3)
ax.set_title(title)
ax.legend()
def plot_learning_curve(data: pd.DataFrame,
features: list,
label: str,
ax: Axes,
n_folds: int = 5,
n_jobs: int = -1,
scoring: str = "balanced_accuracy",
train_sizes: np.array = np.linspace(0.3, 1.0, 10)):
logreg = SMLogitWrapper()
skf = StratifiedKFold(n_splits=n_folds, shuffle=False)
train_sizes, train_scores, test_scores = \
learning_curve(logreg,
data[features],
data[label],
cv=skf,
n_jobs=n_jobs,
scoring=scoring,
train_sizes=train_sizes,
return_times=False)
train_scores_mean = np.mean(train_scores, axis=1)
train_scores_std = np.std(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)
test_scores_std = np.std(test_scores, axis=1)
ax.plot(train_sizes,
train_scores_mean,
'o-',
color='r',
label='Training score')
ax.fill_between(train_sizes,
train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std,
alpha=0.1,
color="r")
ax.plot(train_sizes,
test_scores_mean,
'o-',
color='g',
label='Cross-validation score')
ax.fill_between(train_sizes,
test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std,
alpha=0.1,
color="g")
ax.legend(loc="best")
ax.set_xlabel("Training examples")
ax.set_ylabel(scoring.replace("_", "").title())
ax.set_ylim(0, 1)
return ax
def plot_latency(ax: plt.Axes, n: int, s: pd.Series, sample_every: int,
marker: str) -> None:
median = s.rolling('1000ms').median()
p95 = s.rolling('1000ms').quantile(0.95)
label = '1 client' if n == 1 else f'{n} clients'
line = ax.plot_date(s.index[::sample_every],
median[::sample_every],
label=label,
fmt='-',
marker=marker,
markevery=0.1)[0]
ax.fill_between(s.index[::sample_every],
median[::sample_every],
p95[::sample_every],
color=line.get_color(),
alpha=0.25)
def _plot_smoothed_proportion(
self,
ax: plt.Axes,
clusters: Sequence[Any],
y_offset: Mapping[Any, float],
alpha: float = 0.8,
) -> Tuple[Mapping[Any, np.ndarray], Mapping[Any, PolyCollection]]:
start_t, end_t = self._cmat.columns.min(), self._cmat.columns.max()
x = np.array(self._cmat.columns) # fitting
# extrapolation
e = np.linspace(start_t, end_t, int(1 + (end_t - start_t) * 100))
smoothed_proportion, handles = {}, {}
for clust in clusters:
y = self._cmat.loc[clust]
f = interp1d(x, y)
fe = f(e)
lo = lowess(fe, e, frac=0.3, is_sorted=True, return_sorted=False)
smoothed_proportion[clust] = lo
handles[clust] = ax.fill_between(
e,
y_offset[clust] + lo,
y_offset[clust] - lo,
color=self.cmap[clust],
label=clust,
alpha=alpha,
edgecolor=None,
)
return smoothed_proportion, handles
def graph_frame(hist: history.DB, db_res_case: int,
contour_key: history.ContourKey, ax: plt.Axes):
row_skeleton = history.ColumnResult._all_nones()._replace(
result_case_num=db_res_case)
column_data = list(hist.get_all_matching(row_skeleton))
col_data_graph = [
cd for cd in column_data if cd.contour_key == contour_key
]
ax.clear()
graphed_something = False
for yielded, base_col in (
(False, 'tab:blue'),
(True, 'tab:orange'),
):
# Fall back to NaNs, only override with the real data.
x_to_cd = {
cd.x: history.ColumnResult._nans_at(cd.x)
for cd in col_data_graph
}
# Override with the real thing
for cd in col_data_graph:
if cd.yielded == yielded:
x_to_cd[cd.x] = cd
graphed_something = True
res_to_plot = [cd for x, cd in sorted(x_to_cd.items())]
x = [cd.x for cd in res_to_plot]
y_min = [cd.minimum for cd in res_to_plot]
y_mean = [cd.mean for cd in res_to_plot]
y_max = [cd.maximum for cd in res_to_plot]
ax.fill_between(x, y_min, y_max, color=base_col, alpha=0.2)
yield_text = "Dilated" if yielded else "Undilated"
ax.plot(x,
y_mean,
color=base_col,
label=f"{contour_key.name} ({yield_text})")
ax.legend()
return graphed_something
def format_trace_plot(plot: plt.Axes, trace_forward: np.ndarray, trace_reverse: np.ndarray):
x = np.arange(n_trace + 1)[1:] * trace_spacing * 100
plot.errorbar(x, trace_forward[:, 0], yerr=2 * trace_forward[:, 1], ecolor='b',
elinewidth=0, mec='none', mew=0, linestyle='None',
zorder=10)
plot.plot(x, trace_forward[:, 0], 'b-', marker='o', mec='b', mfc='w', label='Forward', zorder=20,)
plot.errorbar(x, trace_reverse[:, 0], yerr=2 * trace_reverse[:, 1], ecolor='r',
elinewidth=0, mec='none', mew=0, linestyle='None',
zorder=10)
plot.plot(x, trace_reverse[:, 0], 'r-', marker='o', mec='r', mfc='w', label='Reverse', zorder=20)
y_fill_upper = [trace_forward[-1, 0] + 2 * trace_forward[-1, 1]] * 2
y_fill_lower = [trace_forward[-1, 0] - 2 * trace_forward[-1, 1]] * 2
xlim = [0, 100]
plot.fill_between(xlim, y_fill_lower, y_fill_upper, color='orchid', zorder=5)
plot.set_xlim(xlim)
plot.legend()
plot.set_xlabel("% Samples Analyzed", fontsize=20)
plot.set_ylabel(r"$\Delta G$ in kcal/mol", fontsize=20)
def plot_throughput(df: pd.DataFrame, ax: plt.Axes,
grouping_columns: Tuple[str, ...], x_column: str,
y_columns: List[str]) -> None:
def outlier_mean(c: str):
def f(g: pd.DataFrame) -> float:
cutoff = 0.5 * g[c].max()
return g[g[c] >= cutoff][c].mean() / 100000
return f
def outlier_std(c: str):
def f(g: pd.DataFrame):
cutoff = 0.5 * g[c].max()
return g[g[c] >= cutoff][c].std() / 100000
return f
# Draw throughput.
grouped = df.groupby(grouping_columns)
for (name, group) in grouped:
name = [name] if len(grouping_columns) == 1 else name
label = ','.join(f'{f}={x}' for (f, x) in zip(grouping_columns, name))
by_acceptors = group.groupby(x_column)
for c in y_columns:
throughput = by_acceptors.apply(outlier_mean(c)).sort_index()
std = by_acceptors.apply(outlier_std(c)).sort_index()
line = ax.plot(throughput.index,
throughput,
'-',
marker=next(MARKERS),
label=f'{c} {label}',
linewidth=1.5)[0]
# Draw error bars.
ax.fill_between(throughput.index,
throughput - std,
throughput + std,
color=line.get_color(),
alpha=0.3)
ax.set_xlabel(x_column)
ax.set_ylabel('Throughput\n(100,000 commands per second)')
ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))
ax.grid()
def plot_1d_data(X_train: np.ndarray, y_train: np.ndarray, X_test: np.ndarray,
y_test: np.ndarray, y_test_sigma: float, y_pred: np.ndarray,
y_pred_low: np.ndarray, y_pred_up: np.ndarray, ax: plt.Axes,
title: str) -> None:
"""
Generate a figure showing the training data and estimated
prediction intervals on test data.
Parameters
----------
X_train : np.ndarray
Training data.
y_train : np.ndarray
Training labels.
X_test : np.ndarray
Test data.
y_test : np.ndarray
True function values on test data.
y_test_sigma : float
True standard deviation.
y_pred : np.ndarray
Predictions on test data.
y_pred_low : np.ndarray
Predicted lower bounds on test data.
y_pred_up : np.ndarray
Predicted upper bounds on test data.
ax : plt.Axes
Axis to plot.
title : str
Title of the figure.
"""
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_xlim([0, 1.1])
ax.set_ylim([0, 1])
ax.scatter(X_train, y_train, color='red', alpha=0.3, label='training')
ax.plot(X_test, y_test, color='gray', label='True confidence intervals')
ax.plot(X_test, y_test - y_test_sigma, color='gray', ls='--')
ax.plot(X_test, y_test + y_test_sigma, color='gray', ls='--')
ax.plot(X_test, y_pred, label='Prediction intervals')
ax.fill_between(X_test, y_pred_low, y_pred_up, alpha=0.3)
ax.set_title(title)
ax.legend()
def show(self, ax: Axes, plot: "plt.Plot"):
xvalues = self.xvalues
yvalues = self.yvalues
ax.plot(xvalues,
yvalues,
self.fmt if self.fmt else "-",
color=self.color,
label=self.label,
**self.plot_kwargs)
yerr = self.yerr
if yerr.size > 0 and plot.plot_settings[lit.ERROR_BAR]:
max_vals = yvalues + yerr
min_vals = yvalues - yerr
ax.fill_between(xvalues,
min_vals,
max_vals,
edgecolor='none',
color=self.color,
alpha=0.3,
interpolate=True,
zorder=0)
def plot_throughput(df: pd.DataFrame, ax: plt.Axes, n: int, label: str) -> None:
def outlier_throughput(g: pd.DataFrame) -> float:
cutoff = 0.5 * g['throughput'].max()
return g[g['throughput'] >= cutoff]['throughput'].mean() / 100000
def outlier_throughput_std(g: pd.DataFrame) -> float:
cutoff = 0.5 * g['throughput'].max()
return g[g['throughput'] >= cutoff]['throughput'].std() / 100000
# Draw throughput.
grouped = df.groupby('workload_label')
vprint(f'# {label}')
for (name, group) in grouped:
vprint(f'## {name}')
vprint(group[['throughput', 'latency']])
throughput = grouped.apply(outlier_throughput).sort_index()
std = grouped.apply(outlier_throughput_std).sort_index()
vprint(f'throughput = {throughput}')
vprint(f'std = {std}')
vprint()
line = ax.plot(throughput.index, throughput,
'-', marker = next(MARKERS), label=label, linewidth=1.5)[0]
# Draw ideal throughput.
# frs = throughput.index.to_series()
# ideal = n * ALPHA / ((n * (1 - frs)) + (frs * 1))
# ax.plot(frs,
# ideal,
# '--',
# linewidth=1.5,
# color=line.get_color(),
# alpha = 0.75,
# label='_nolegend_')
# Draw error bars.
ax.fill_between(throughput.index,
throughput - std,
throughput + std,
color=line.get_color(),
alpha=0.3)
def subplot_result(ax: plt.Axes, name: str, minimize: bool,
opt_settings: OptimizerSettings) -> None:
results = opt_settings.results
if len(results.shape) != 2:
"""
The shape of results must be (n_trials, n_iterations).
results[i][j] := the performance metric at
the j-th iteration of the i-th trial
"""
raise ValueError(
"The shape of results must be (n_trials, n_iterations). "
f"But got the shape {results.shape}.")
if not isinstance(results, np.ndarray):
raise ValueError("results must be np.ndarray. "
f"But got {type(results)}.")
iterations = np.arange(1, results.shape[1] + 1)
if minimize:
cumulative = np.minimum.accumulate(results, axis=-1)
else:
cumulative = np.maximum.accumulate(results, axis=-1)
mean = cumulative.mean(axis=0)
std = cumulative.std(axis=0)
ax.plot(iterations,
mean,
color=opt_settings.color,
marker=opt_settings.marker,
label=f"{opt_settings.name}: $\\mu \\pm \\sigma$")
ax.fill_between(iterations,
mean - std,
mean + std,
color=opt_settings.color,
alpha=0.2)
def plot(self,
x_label: str = '1 - Specificity',
y_label: str = 'Sensitivity',
title: str = 'ROC Curve',
label: Optional[str] = None,
color: str = 'blue',
bootstrap: bool = False,
num_bootstraps: int = 1000,
num_bootstrap_jobs: int = 1,
seed: Optional[int] = None,
p_value: float = 0.05,
mean_roc: bool = False,
show_min_max: bool = False,
plot_roc_curve: bool = True,
ax: plt.Axes = None) -> plt.Axes:
"""Plot ROC curve.
Parameters
----------
x_label
Label for x-axis in ROC curve plot.
y_label
Label for y-axis in ROC curve plot.
title
Title for ROC curve plot.
label
If set, this will be the label displayed in the legend.
color
Color of the ROC curve and the confidence interval, if required.
bootstrap
If set to True the ROC curve will be plotted with a confidence
interval using bootstrapping.
num_bootstraps
Number of bootstraps to apply on the ROC curve. The larger the
value the more accurate the confidence interval. But larger values
for num_bootstrap will lead to longer computation time and memory
usage.
num_bootstrap_jobs
Number of jobs used to compute the bootstraps for the ROC curve in
parallel. If n_jobs is set negative all available cpu threads will
be used.
seed
Seed used for bootstrapping the ROC curve. If no seed is set the
seed will be set randomly, generating non-deterministic output.
p_value
Value between 0 and 1. This value shows the confidence area of the
ROC curve.
mean_roc
If set to True all bootstrapped ROC curves are used to create an
averaged ROC curve. Usually this ROC curve looks more smooth than
the original ROC curve, and therefore can be used for smoothing the
original ROC curve.
show_min_max
If set to True the ROC curve will be plotted with the smallest and
largest true positive rate values obtained from bootstrapping. This
parameter is mainly used for debug purposes.
plot_roc_curve
If set to False the ROC curve will not be plotted. But the
confidence interval, obtained with bootstrapping, and averaged ROC
curve will be plotted. This option could be usefull for plotting
the average ROC curve without the original ROC curve.
ax
If ax is given the ROC plot will be plotted into this Matplotlib
axis.
Raises
------
RuntimeError
If mean_roc is set to True, but bootstrap is set to False.
Returns
-------
ax
Matplotlib axis plot with the ROC curve plot, optionally with
confidence interval.
"""
if not ax:
ax = plt.gca()
if bootstrap:
bsp = self.bootstrap_confidence(
num_bootstraps=num_bootstraps,
seed=seed,
num_bootstrap_jobs=num_bootstrap_jobs,
show_min_max=show_min_max,
mean_roc=mean_roc,
p_value=p_value)
ax.fill_between(bsp.xrange,
bsp.min_quantile,
bsp.max_quantile,
alpha=0.2,
color=color)
if show_min_max:
ax.fill_between(bsp.xrange,
bsp.min,
bsp.max,
alpha=0.1,
color=color)
ax.plot(bsp.xrange, bsp.min_quantile, color=color, alpha=0.3)
ax.plot(bsp.xrange, bsp.max_quantile, color=color, alpha=0.3)
if mean_roc:
if not bootstrap:
raise RuntimeError(
'Cannot plot mean ROC curve without bootstrapping.')
if label:
ax.plot(bsp.xrange, bsp.mean, label=label, color=color)
else:
ax.plot(bsp.xrange, bsp.mean, color=color)
elif plot_roc_curve:
fps, tps, _ = self.roc()
if label:
ax.plot(fps, tps, label=label, color=color)
else:
ax.plot(fps, tps, color=color)
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
ax.set_title(title)
ax.set_xlabel(x_label)
ax.set_ylabel(y_label)
return ax
def plot_equilibrium(eq: pleque.Equilibrium,
ax: plt.Axes = None,
colorbar=False,
**kwargs):
if ax is None:
ax = plt.gca()
if eq._first_wall is not None and len(eq._first_wall) > 2:
ax.fill_between(eq._first_wall[:, 0],
eq._first_wall[:, 1],
color='lightgrey')
ax.plot(eq._first_wall[:, 0],
eq._first_wall[:, 1],
color='k',
lw=2,
label='First wall')
sep = eq.separatrix
in_fw = eq.in_first_wall(sep)
ax.plot(sep.R[in_fw], sep.Z[in_fw], color='C3', lw=2, alpha=0.5)
# separatrix
ax.plot(eq.lcfs.R, eq.lcfs.Z, color='C1', lw=2, ls='--')
coords = eq.grid((400, 600), 'size')
rs, zs = coords.mesh()
psi = eq.psi(coords)
mask_inlcfs = eq.in_lcfs(coords)
mask_inlimiter = eq.in_first_wall(coords)
mask_insol = mask_inlcfs ^ mask_inlimiter
psi_in = np.ma.masked_array(psi, np.logical_not(mask_inlcfs))
psi_out = np.ma.masked_array(psi, mask_inlcfs)
# ax.pcolormesh(coords.R, coords.Z, psi_in, shading='gouraud')
contour_out = eq.coordinates(r=eq.lcfs.r_mid[0] + 2e-3 * np.arange(1, 11),
theta=np.zeros(10),
grid=False)
cl = ax.contour(coords.R, coords.Z, psi_in, 20, **kwargs)
plt.colorbar(cl, ax=ax)
# todo: psi should be 1-d (!) resolve this
ax.contour(coords.R,
coords.Z,
psi,
np.sort(np.squeeze(contour_out.psi)),
colors='C0')
# contact = eq.strike_points
# ax.plot(contact.R, contact.Z, "C3+")
op = eq.magnetic_axis
ax.plot(op.R, op.Z, "C0o")
psi_lcfs = eq._psi_lcfs
z0 = eq._mg_axis[1]
# ax.pcolormesh(coords.R, coords.Z, mask_in)
# ax.pcolormesh(rs, zs, mask_inlimiter)
# ax.pcolormesh(coords.R, coords.Z, mask_insol)
ax.set_xlabel('R [m]')
ax.set_ylabel('Z [m]')
if len(eq._first_wall) > 2:
rlim = [np.min(eq.first_wall.R), np.max(eq.first_wall.R)]
zlim = [np.min(eq.first_wall.Z), np.max(eq.first_wall.Z)]
size = rlim[1] - rlim[0]
rlim[0] -= size / 12
rlim[1] += size / 12
size = zlim[1] - zlim[0]
zlim[0] -= size / 12
zlim[1] += size / 12
ax.set_xlim(*rlim)
ax.set_ylim(*zlim)
ax.set_aspect('equal')
return ax
def plot_calibration_weight_traces(
dataset: Union[netCDF4.Dataset, List[netCDF4.Dataset]],
ax: plt.Axes = None,
bar: bool = True,
error: str = "stdev",
num_bootstrap_samples: int = 1000,
zerobased: bool = False,
):
"""Plot the results of a calibration netCDF dataset.
Parameters
----------
dataset - netCDF4 dataset with `Protons` data
ax - matplotlib axes object, if None creates a new figure and axes
bar - bool, plot BAR estimates
error - str, if bar is True 'stdev' will plot the BAR error as 2 times standard deviation returned from BAR, 'bootstrap' will plot standard error from bootstrap.
num_bootstrap_samples - Used if 'bootstrap' is used as error method. Number of bootstrap samples to draw.
zerobased - if True, label states in zero based fashion in the plots. Defaults to 1-based
Returns
-------
plt.Axes containing the plot
"""
if ax is None:
ax = plt.gca()
# Two methods of calculating the error
if error == "stdev":
# Use 2 * standard deviation, as returned by bar
bootstrap = False
err_multiply = 2
err_label = r"BAR estimate $\pm$ $2\sigma$, State {}"
elif error == "bootstrap":
# Use the standard error from bootstrap sampling of reverse and forward trajectories
bootstrap = True
err_multiply = 1
err_label = r"BAR estimate $\pm$ SEM, State {}"
else:
raise ValueError("Unsupported error method: {}.".format(error))
if zerobased:
label_offset = 0
else:
label_offset = 1
# Make the y-axis label, ticks and tick labels match the line color.
ax.set_xlabel("Update", fontsize=18)
ax.set_ylabel(r"$g_k/RT$ (unitless) relative to state 1", fontsize=18)
if type(dataset) == netCDF4.Dataset:
n_states, gk = calibration_dataset_to_arrays(dataset)[-2:]
elif type(dataset) == list:
n_states, gk = stitch_calibrations(dataset)[-2:]
cp = sns.color_palette("husl", n_states)
if bar:
bar_data = bar_all_states(
dataset, bootstrap=bootstrap, num_bootstrap_samples=num_bootstrap_samples
)
else:
bar_data = None
xaxis_points = list(range(gk.shape[0]))
for state in range(1, n_states):
state_color = cp[state]
ax.plot(
gk[:, state],
label="State {}".format(state + label_offset),
color=state_color,
)
if bar:
estimate, err = bar_data["0->{}".format(state)]
err *= err_multiply
ax.fill_between(
xaxis_points,
-estimate - err,
-estimate + err,
alpha=0.3,
color=state_color,
label=err_label.format(state + label_offset),
)
sns.despine(ax=ax)
return ax
