def test_line_markers(self):
"""test high-level usage for simple example.
Test is successfull if generated tikz code saves correct amount of lines
"""
x = np.linspace(1, 100, 20)
y = np.linspace(1, 100, 20)
with plt.rc_context(rc=RC_PARAMS):
fig, ax = plt.subplots(1, 1, figsize=(5, 5))
ax.plot(x, y, linestyle="-", marker="*")
ax.set_ylim([20, 80])
ax.set_xlim([20, 80])
raw = get_tikz_code()
clean_figure(fig)
clean = get_tikz_code()
# Use number of lines to test if it worked.
# the baseline (raw) should have 20 points
# the clean version (clean) should have 2 points
# the difference in line numbers should therefore be 2
numLinesRaw = raw.count("\n")
numLinesClean = clean.count("\n")
assert numLinesRaw - numLinesClean == 6
plt.close("all")
def test_plot3d(self):
theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
z = np.linspace(-2, 2, 100)
r = z**2 + 1
x = r * np.sin(theta)
y = r * np.cos(theta)
with plt.rc_context(rc=RC_PARAMS):
fig = plt.figure()
ax = fig.add_subplot(111, projection="3d")
ax.plot(x, y, z)
ax.set_xlim([-2, 2])
ax.set_ylim([-2, 2])
ax.set_zlim([-2, 2])
ax.view_init(30, 30)
raw = get_tikz_code(fig)
clean_figure(fig)
clean = get_tikz_code()
# Use number of lines to test if it worked.
numLinesRaw = raw.count("\n")
numLinesClean = clean.count("\n")
assert numLinesRaw - numLinesClean == 14
plt.close("all")
def assert_equality(plot,
filename,
assert_compilation=True,
flavor="latex",
**extra_get_tikz_code_args):
plot()
code = tikzplotlib.get_tikz_code(
include_disclaimer=False,
float_format=".8g",
flavor=flavor,
**extra_get_tikz_code_args,
)
plt.close()
this_dir = os.path.dirname(os.path.abspath(__file__))
with open(os.path.join(this_dir, filename), encoding="utf-8") as f:
reference = f.read()
assert reference == code, filename + "\n" + _unidiff_output(
reference, code)
if assert_compilation:
plot()
code = tikzplotlib.get_tikz_code(
include_disclaimer=False,
standalone=True,
flavor=flavor,
**extra_get_tikz_code_args,
)
plt.close()
assert _compile(code, flavor) is not None, code
def test_subplot(self):
"""octave code
```octave
addpath ("../matlab2tikz/src")
x = linspace(1, 100, 20);
y1 = linspace(1, 100, 20);
figure
subplot(2, 2, 1)
plot(x, y1, "-")
subplot(2, 2, 2)
plot(x, y1, "-")
subplot(2, 2, 3)
plot(x, y1, "-")
subplot(2, 2, 4)
plot(x, y1, "-")
xlim([20, 80])
ylim([20, 80])
set(gcf,'Units','Inches');
set(gcf,'Position',[2.5 2.5 5 5])
cleanfigure;
```
"""
x = np.linspace(1, 100, 20)
y = np.linspace(1, 100, 20)
with plt.rc_context(rc=RC_PARAMS):
fig, axes = plt.subplots(2, 2, figsize=(5, 5))
plotstyles = [("-", "o"), ("-", "None"), ("None", "o"),
("--", "x")]
for ax, style in zip(axes.ravel(), plotstyles):
ax.plot(x, y, linestyle=style[0], marker=style[1])
ax.set_ylim([20, 80])
ax.set_xlim([20, 80])
raw = get_tikz_code()
clean_figure(fig)
clean = get_tikz_code()
# Use number of lines to test if it worked.
# the baseline (raw) should have 20 points
# the clean version (clean) should have 2 points
# the difference in line numbers should therefore be 2
numLinesRaw = raw.count("\n")
numLinesClean = clean.count("\n")
assert numLinesRaw - numLinesClean == 36
plt.close("all")
def _main():
parser = argparse.ArgumentParser(
description="Refresh all reference TeX files.")
parser.parse_args()
this_dir = pathlib.Path(__file__).resolve().parent
test_files = [
f for f in this_dir.iterdir()
if (this_dir /
f).is_file() and f.name[:5] == "test_" and f.name[-3:] == ".py"
]
test_modules = [f.name[:-3] for f in test_files]
# remove some edge cases
test_modules.remove("test_rotated_labels")
test_modules.remove("test_deterministic_output")
test_modules.remove("test_cleanfigure")
test_modules.remove("test_context")
test_modules.remove("test_readme")
for mod in test_modules:
module = importlib.import_module(mod)
module.plot()
code = tpl.get_tikz_code(include_disclaimer=False, float_format=".8g")
plt.close()
tex_filename = mod + "_reference.tex"
with open(this_dir / tex_filename, "w", encoding="utf8") as f:
f.write(code)
def assert_equality(plot, filename, **extra_get_tikz_code_args):
plot()
code = tikzplotlib.get_tikz_code(include_disclaimer=False,
**extra_get_tikz_code_args)
plt.close()
this_dir = os.path.dirname(os.path.abspath(__file__))
with open(os.path.join(this_dir, filename), "r", encoding="utf-8") as f:
reference = f.read()
assert reference == code, _unidiff_output(code, reference)
code = tikzplotlib.get_tikz_code(include_disclaimer=False,
standalone=True,
**extra_get_tikz_code_args)
assert _compile(code) is not None
return
def plot_quorum_enumeration(n_orgs_range, n_quorums, t_elapsed):
'''Plot number of quorums and timings'''
plt.rc('text', usetex=True)
plt.style.use("ggplot")
prop_cycle = list(plt.rcParams['axes.prop_cycle'])
plt.style.use("default")
def loground(number, direction='up'):
round_fun = math.ceil if direction == 'up' else math.floor
return 10**round_fun(math.log10(number))
_, ax1 = plt.subplots()
ax1.set_xlabel(r'Number of organizations $n$')
ax1.xaxis.set_major_locator(MaxNLocator(integer=True))
ax1.set_ylabel('Computation time (s)')
ax1.set_yscale('log')
ax1.set_ylim(loground(min(t_elapsed), direction='down'),
loground(max(t_elapsed), direction='up'))
ax1.plot(n_orgs_range, t_elapsed, 'o-', lw=2, color=prop_cycle[0]['color'])
ax2 = ax1.twinx()
ax2.set_ylabel('Number of quorums')
ax2.set_yscale('log')
ax2.set_ylim(loground(min(n_quorums), direction='down'),
loground(max(n_quorums), direction='up'))
ax2.plot(n_orgs_range, n_quorums, 'o:', lw=2, color=prop_cycle[1]['color'])
print(tikzplotlib.get_tikz_code())
def _main():
parser = argparse.ArgumentParser(
description="Refresh the reference TeX files.")
parser.add_argument("files", nargs="+", help="Files to refresh")
args = parser.parse_args()
this_dir = os.path.dirname(os.path.abspath(__file__))
exclude_list = ["test_rotated_labels.py", "test_deterministic_output.py"]
for filename in args.files:
if filename in exclude_list:
continue
if filename.startswith("test_") and filename.endswith(".py"):
spec = importlib.util.spec_from_file_location("plot", filename)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
module.plot()
code = m2t.get_tikz_code(include_disclaimer=False)
plt.close()
tex_filename = filename[:-3] + "_reference.tex"
with open(os.path.join(this_dir, tex_filename), "w") as f:
f.write(code)
return
def render(self, latexfile=None):
for ax in self.axes:
self._axes_legend(ax)
if latexfile is None:
if HEADLESS_MODE:
print("Warning: running in headless mode, won't show anything",
file=sys.stdout)
return
win = tk.Tk()
win.title('Figure')
canvas = FigureCanvasTkAgg(self, master=win)
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)
toolbar = NavigationToolbar2Tk(canvas, win)
toolbar.update()
canvas.mpl_connect(
'key_press_event',
lambda ev: key_press_handler(ev, canvas, toolbar))
canvas.draw()
tk.mainloop()
else:
tikzcode = tikzplotlib.get_tikz_code(
figure=self,
extra_axis_parameters=[
'scaled ticks=false',
'xticklabel style={/pgf/number format/.cd,fixed,precision=2}',
'yticklabel style={/pgf/number format/.cd,fixed,precision=2}'
],
axis_width=r'\figW',
float_format='.5g')
with open(latexfile, 'w') as f:
f.write(tikzcode)
def _main():
parser = argparse.ArgumentParser(
description="Refresh all reference TeX files.")
parser.parse_args()
this_dir = os.path.dirname(os.path.abspath(__file__))
test_files = [
f for f in os.listdir(this_dir)
if os.path.isfile(os.path.join(this_dir, f)) and f[:5] == "test_"
and f[-3:] == ".py"
]
test_modules = [f[:-3] for f in test_files]
# remove some edge cases
test_modules.remove("test_rotated_labels")
test_modules.remove("test_deterministic_output")
test_modules.remove("test_cleanfigure")
test_modules.remove("test_context")
for mod in test_modules:
module = importlib.import_module(mod)
module.plot()
code = tpl.get_tikz_code(include_disclaimer=False, float_format=".8g")
plt.close()
tex_filename = mod + "_reference.tex"
with open(os.path.join(this_dir, tex_filename), "w",
encoding="utf8") as f:
f.write(code)
def test_xlog_2(self):
x = np.arange(1, 100)
y = np.arange(1, 100)
with plt.rc_context(rc=RC_PARAMS):
fig, ax = plt.subplots(1)
ax.plot(x, y)
ax.set_xscale("log")
raw = get_tikz_code()
clean_figure()
clean = get_tikz_code()
numLinesRaw = raw.count("\n")
numLinesClean = clean.count("\n")
assert numLinesRaw - numLinesClean == 51
assert numLinesClean == 71
plt.close("all")
def test_xlog(self):
y = np.linspace(0, 3, 100)
x = np.exp(y)
with plt.rc_context(rc=RC_PARAMS):
fig, ax = plt.subplots(1)
ax.plot(x, y)
ax.set_xscale("log")
raw = get_tikz_code()
clean_figure()
clean = get_tikz_code()
numLinesRaw = raw.count("\n")
numLinesClean = clean.count("\n")
assert numLinesRaw - numLinesClean == 98
assert numLinesClean == 25
plt.close("all")
def test_xlog_3(self):
x = np.logspace(-3, 3, 20)
y = np.linspace(1, 100, 20)
with plt.rc_context(rc=RC_PARAMS):
fig, ax = plt.subplots(1, 1, figsize=(5, 5))
ax.plot(x, y)
ax.set_xscale("log")
ax.set_xlim([10**(-2), 10**(2)])
ax.set_ylim([20, 80])
raw = get_tikz_code()
clean_figure(fig)
clean = get_tikz_code()
numLinesRaw = raw.count("\n")
numLinesClean = clean.count("\n")
assert numLinesRaw - numLinesClean == 18
plt.close("all")
def to_tikz(fig):
tikzplotlib.clean_figure(fig)
output = tikzplotlib.get_tikz_code(figure=fig,
filepath=None,
axis_width=None,
axis_height=None,
textsize=10.0,
table_row_sep="\n")
return output
def save_comboplot(cip_cls, filename):
filepath = imgpath + filename + '.tex'
file_handle = codecs.open(filepath, 'w')
# Rate graph
cip_cls.plot_rate()
# To do: figure out why computer science ('11') raises error here
try:
tpl.clean_figure()
except ValueError:
pass
code = tpl.get_tikz_code(axis_height='140pt',
axis_width='300pt',
# axis_width='150pt',
# extra_axis_parameters={'x post scale=2',
# 'y post scale=1'}
)
file_handle.write(code)
file_handle.write('\n\\vspace{0.1cm}\n\\begin{tikzpicture}')
file_handle.close()
# area graph
cip_cls.plot_area()
tpl.clean_figure()
code = tpl.get_tikz_code(
wrap=False,
extra_axis_parameters={"height=90pt, width=160pt",
"reverse legend",
"legend style={"
+ "at={(2.02, 0.5)},"
+ "anchor=west,"
+ "}"},
extra_groupstyle_parameters={"horizontal sep=0.8cm",
"group name=my plots"},
)
with open(filepath, 'a+') as file_handle:
content = file_handle.read()
file_handle.seek(0, 0)
file_handle.write('\n' + code + '\n' + content)
group_title = 'Number Bachelor\'s degrees awarded (thousands)'
add_end_content(filepath, group_title, title_space="0.25cm")
def test_scatter(self):
x = np.linspace(1, 100, 20)
y = np.linspace(1, 100, 20)
with plt.rc_context(rc=RC_PARAMS):
fig, ax = plt.subplots(1, 1, figsize=(5, 5))
ax.scatter(x, y)
ax.set_ylim([20, 80])
ax.set_xlim([20, 80])
raw = get_tikz_code()
clean_figure()
clean = get_tikz_code()
# Use number of lines to test if it worked.
# the baseline (raw) should have 20 points
# the clean version (clean) should have 2 points
# the difference in line numbers should therefore be 2
numLinesRaw = raw.count("\n")
numLinesClean = clean.count("\n")
assert numLinesRaw - numLinesClean == 6
plt.close("all")
def test_sine(self):
x = np.linspace(1, 2 * np.pi, 100)
y = np.sin(8 * x)
with plt.rc_context(rc=RC_PARAMS):
fig, ax = plt.subplots(1, 1, figsize=(5, 5))
ax.plot(x, y, linestyle="-", marker="*")
ax.set_xlim([0.5 * np.pi, 1.5 * np.pi])
ax.set_ylim([-1, 1])
raw = get_tikz_code()
clean_figure(fig)
clean = get_tikz_code()
# Use number of lines to test if it worked.
# the baseline (raw) should have 20 points
# the clean version (clean) should have 2 points
# the difference in line numbers should therefore be 2
numLinesRaw = raw.count("\n")
numLinesClean = clean.count("\n")
assert numLinesRaw - numLinesClean == 39
plt.close("all")
def compare_mpl_tex(plot, flavor="latex"):
plot()
code = tikzplotlib.get_tikz_code(standalone=True)
directory = os.getcwd()
filename = "test-0.png"
plt.savefig(filename)
plt.close()
pdf_file = _compile(code, flavor)
pdf_dirname = os.path.dirname(pdf_file)
# Convert PDF to PNG.
subprocess.check_output(
["pdftoppm", "-r", "1000", "-png", pdf_file, "test"],
stderr=subprocess.STDOUT)
png_path = os.path.join(pdf_dirname, "test-1.png")
os.rename(png_path, os.path.join(directory, "test-1.png"))
def save(filepath: Path,
comment: Union[str, dict],
figure="gcf",
axis_width=None,
axis_height=None,
textsize=10.0,
table_row_sep="\n"):
tikzplotlib.clean_figure(fig=figure)
output = tikzplotlib.get_tikz_code(figure=figure,
filepath=filepath,
axis_width=axis_width,
axis_height=axis_height,
textsize=textsize,
table_row_sep=table_row_sep)
output = _add_comment(output, comment)
with open(filepath, "w") as tikz_file:
tikz_file.write(output)
mean=0.9981387614088575,
std=0.07243252473207047)
object_list = [adam, adapt_only_sgd, adapt_sgd, precon_sgd]
fig = plt.figure(figsize=(3, 3))
plt.bar([o.name for o in object_list], [o.mean for o in object_list],
alpha=0.7,
yerr=[o.std for o in object_list],
capsize=7)
plt.hlines(1, xmin=-1, xmax=4, linestyles='dashed', alpha=0.7)
plt.xticks(rotation='25', horizontalalignment='right', verticalalignment='top')
plt.show()
# mpl.use("pgf")
# mpl.rcParams["pgf.rcfonts"] = False
# plt.gcf().savefig("../../thesis/images/exp_perf_prec.pgf")
# General settings
code = tikzplotlib.get_tikz_code(
figure=fig,
extra_axis_parameters=[
"tick pos=left", "xticklabel style = {anchor = north east}"
],
) #strict = True)
print(code)
#catch missed underscores & save
code = code.replace("\_", "_").replace("_", "\_")
file = codecs.open("../../thesis/images/exp_perf_prec.pgf", "w", 'utf-8')
file.write(code)
file.close()
ax.set_ylim([-0.05, 1.1])
if gap_data:
ax.set_ylim([-0.1, 1.15])
ax.legend()
# ax.set_yticks([0.5, 0.8, 0.95, 1.0])
# ax.set_yticklabels([0.5, 0.8, 0.95, 1.0])
if plot_single_lines:
ax.set_ylim([-1.0, 2.5])
if save:
save_path = figure_dir.joinpath(
f"{experiment_name}_{method}_{metric}.pdf".replace(" ", "-"))
fig.savefig(save_path, bbox_inches="tight")
tex = tpl.get_tikz_code(
axis_width="\\figwidth", # we want LaTeX to take care of the width
axis_height="\\figheight", # we want LaTeX to take care of the height
# we want the plot to look *exactly* like here (e.g. axis limits, axis ticks, etc.)
# strict=True,
)
with save_path.with_suffix(".tex").open("w", encoding="utf-8") as f:
f.write(tex)
# %%
_net_sizes = np.arange(n_networks) + 1.0
_net_sizes = _net_sizes[np.logical_or(_net_sizes <= 20, _net_sizes % 5 == 0)]
fig, ax = plt.subplots(figsize=(18, 10))
higher_is_better = True
optimum_is_full_ensemble = True
plot_single_lines = False
method = "Ensemble"
nDf = NpvDf('OFIPS', 'SIM_ICV_01_STG_EXT')
fig, ax = plt.subplots()
ax.plot(nDf.df['Close Condition'], nDf.df['Npv'], 'o', markersize=4)
ax.tick_params(axis="x", labelrotation=90)
#ax.set_title('Net present value\\\\Production strategies w/ ON/OFF ICV\'s')
ax.set_xlabel('(GOR [$sm^3/sm^3$]; WCUT [$sm^3/sm^3$])')
ax.set_ylabel('Millions of dollars')
ax.set_xlim(0, 99)
ax.set_ylim(1100, 2400)
settings = {}
settings['textsize'] = 6
settings['figurewidth'] = '0.70\\textwidth'
settings['figureheight'] = '0.60\\textheight'
eap = []
eap.append(
'title={Net present value\\\\\\scriptsize{Production strategies w/ ON/OFF ICV\'s}}'
)
eap.append('title style={align=left, font=\\normalsize}')
eap.append('tick label style={font=\\scriptsize}')
eap.append('label style={font=\\scriptsize}')
eap.append('legend pos=north east')
settings['extra_axis_parameters'] = eap
settings['extra_tikzpicture_parameters'] = None
code = tikzplotlib.get_tikz_code(**settings)
code = utils.filter_xtikcs(code, 3)
with open('./latex/npvf/tikz/graph01.tikz', 'w') as fh:
fh.write(code)
def tpl_save(*args, **kwargs):
# these are not passed to get_tikz_code
encoding = kwargs.pop("encoding", None)
extra_body_parameters = kwargs.pop('extra_body_parameters', None)
# always pass certain tikzpicture parameters
extra_tikzpicture_parameters = kwargs.pop(
'extra_tikzpicture_parameters', None)
standard_tikzpicture_parameters = {
'\\providecommand{\\thisXlabelopacity}{1.0}',
'\\providecommand{\\thisYlabelopacity}{1.0}',
'\\pgfplotsset{compat=1.15}',
}
extra_tikzpicture_parameters = (
standard_tikzpicture_parameters
if extra_tikzpicture_parameters is None else
extra_tikzpicture_parameters | standard_tikzpicture_parameters
)
# always pass certain axis parameters
extra_axis_parameters = kwargs.pop('extra_axis_parameters', None)
standard_axis_parameters = {
'every axis x label/.append style={opacity=\\thisXlabelopacity}',
'every axis y label/.append style={opacity=\\thisYlabelopacity}',
}
extra_axis_parameters = (
standard_axis_parameters if extra_axis_parameters is None else
extra_axis_parameters | standard_axis_parameters
)
# get the code
code = tpl.get_tikz_code(
*args, **kwargs,
extra_axis_parameters=extra_axis_parameters,
extra_tikzpicture_parameters=extra_tikzpicture_parameters,
)
# perhaps tack some extra code before the \end{axis} command
if extra_body_parameters is not None:
end_axis = '\\end{axis}'
code = tpl.get_tikz_code(
*args, **kwargs,
extra_axis_parameters=extra_axis_parameters,
extra_tikzpicture_parameters=extra_tikzpicture_parameters,
)
code_pieces = code.split(end_axis)
code = (
code_pieces[0] +
reduce(lambda a, b: b+'\n'+a, reversed(extra_body_parameters), end_axis) +
code_pieces[1]
)
# ...
filepath = kwargs.pop('filepath')
file_handle = codecs.open(filepath, "w", encoding)
try:
file_handle.write(code)
except UnicodeEncodeError:
# We're probably using Python 2, so treat unicode explicitly
file_handle.write(six.text_type(code).encode("utf-8"))
file_handle.close()
def tpl_save(
#####
# non-tpl args
filepath,
#####
*args,
#####
# non-tpl kwargs
encoding=None,
pre_tikzpicture_lines=None,
extra_body_parameters=None,
#####
#####
# this kwarg has a non-empty default (set below)
extra_axis_parameters=None,
#####
**kwargs):
# Always pass certain pre-tikzpicture lines.
standard_pre_tikzpicture_lines = {
'\\providecommand{\\thisXlabelopacity}{1.0}',
'\\providecommand{\\thisYlabelopacity}{1.0}',
'\\pgfplotsset{compat=1.15}',
}
# To allow the boolean to shut these params off, even if they had been
# explicitly set to values, use post/.append style
for boolean, axis_param in zip(
['CLEANXAXIS', 'CLEANXAXIS', 'CLEANYAXIS', 'CLEANYAXIS'],
['xticklabels', 'xlabel', 'yticklabels', 'ylabel']):
standard_pre_tikzpicture_lines |= {
'\\provideboolean{%s}'
'\\ifthenelse{\\boolean{%s}}{%%'
'\n\t\\pgfplotsset{every axis post/.append style={%s = {} }}%%'
'\n}{}%%' % (boolean, boolean, axis_param)
}
# don't forget any pre_tikzpicture_lines that have been passed as args
pre_tikzpicture_lines = augment_params_set(pre_tikzpicture_lines,
standard_pre_tikzpicture_lines)
# always pass certain axis parameters
standard_axis_parameters = {
'every axis x label/.append style={opacity=\\thisXlabelopacity}',
'every axis y label/.append style={opacity=\\thisYlabelopacity}',
}
extra_axis_parameters = augment_params_set(extra_axis_parameters,
standard_axis_parameters)
# get the code
code = tpl.get_tikz_code(
*args,
**kwargs,
extra_axis_parameters=extra_axis_parameters,
)
# tack some extra code before anything
if pre_tikzpicture_lines is not None:
code = '%\n'.join(pre_tikzpicture_lines) + '%\n' + code
# perhaps tack some extra code before the \end{axis} command
if extra_body_parameters is not None:
end_axis = '\\end{axis}'
code_pieces = code.split(end_axis)
code = (code_pieces[0] +
reduce(lambda a, b: b + '\n' + a,
reversed(extra_body_parameters), end_axis) +
code_pieces[1])
# finally, write out the file
file_handle = codecs.open(filepath, "w", encoding)
try:
file_handle.write(code)
except UnicodeEncodeError:
# We're probably using Python 2, so treat unicode explicitly
file_handle.write(six.text_type(code).encode("utf-8"))
file_handle.close()
def plot(self,
X: Union[Iterable[np.ndarray], np.ndarray],
y: Union[Iterable[np.ndarray], np.ndarray],
batched: bool = False,
uncertainty: str = None,
filename: str = None,
tikz: bool = False,
title_suffix: str = None,
feature_names: List[str] = None,
**save_args) -> Union[plt.Figure, str]:
"""
Reliability diagram to visualize miscalibration. This could be either in classical way for confidences only
or w.r.t. additional properties (like x/y-coordinates of detection boxes, width, height, etc.). The additional
properties get binned. Afterwards, the miscalibration will be calculated for each bin. This is
visualized as a 2-D plots.
Parameters
----------
X : iterable of np.ndarray, or np.ndarray of shape=([n_bayes], n_samples, [n_classes/n_box_features])
NumPy array with confidence values for each prediction on classification with shapes
1-D for binary classification, 2-D for multi class (softmax).
If 3-D, interpret first dimension as samples from an Bayesian estimator with mulitple data points
for a single sample (e.g. variational inference or MC dropout samples).
If this is an iterable over multiple instances of np.ndarray and parameter batched=True,
interpret this parameter as multiple predictions that should be averaged.
On detection, this array must have 2 dimensions with number of additional box features in last dim.
y : iterable of np.ndarray with same length as X or np.ndarray of shape=([n_bayes], n_samples, [n_classes])
NumPy array with ground truth labels.
Either as label vector (1-D) or as one-hot encoded ground truth array (2-D).
If 3-D, interpret first dimension as samples from an Bayesian estimator with mulitple data points
for a single sample (e.g. variational inference or MC dropout samples).
If iterable over multiple instances of np.ndarray and parameter batched=True,
interpret this parameter as multiple predictions that should be averaged.
batched : bool, optional, default: False
Multiple predictions can be evaluated at once (e.g. cross-validation examinations) using batched-mode.
All predictions given by X and y are separately evaluated and their results are averaged afterwards
for visualization.
uncertainty : str, optional, default: False
Define uncertainty handling if input X has been sampled e.g. by Monte-Carlo dropout or similar methods
that output an ensemble of predictions per sample. Choose one of the following options:
- flatten: treat everything as a separate prediction - this option will yield into a slightly better
calibration performance but without the visualization of a prediction interval.
- mean: compute Monte-Carlo integration to obtain a simple confidence estimate for a sample
(mean) with a standard deviation that is visualized.
filename : str, optional, default: None
Optional filename to save the plotted figure.
tikz : bool, optional, default: False
If True, use 'tikzplotlib' package to return tikz-code for Latex rather than a Matplotlib figure.
title_suffix : str, optional, default: None
Suffix for plot title.
feature_names : list, optional, default: None
Names of the additional features that are attached to the axes of a reliability diagram.
**save_args : args
Additional arguments passed to 'matplotlib.pyplot.Figure.savefig' function if 'tikz' is False.
If 'tikz' is True, the argument are passed to 'tikzplotlib.get_tikz_code' function.
Returns
-------
matplotlib.pyplot.Figure if 'tikz' is False else str with tikz code.
Raises
------
AttributeError
- If parameter metric is not string or string is not 'ACE', 'ECE' or 'MCE'
- If parameter 'feature_names' is set but length does not fit to second dim of X
- If no ground truth samples are provided
- If length of bins parameter does not match the number of features given by X
- If more than 3 feature dimensions (including confidence) are provided
"""
# assign deprecated constructor parameter to title_suffix and feature_names
if hasattr(self, 'title_suffix') and title_suffix is None:
title_suffix = self.title_suffix
if hasattr(self, 'feature_names') and feature_names is None:
feature_names = self.feature_names
# check if metric is correct
if not isinstance(self.metric, str):
raise AttributeError(
'Parameter \'metric\' must be string with either \'ece\', \'ace\' or \'mce\'.'
)
# check metrics parameter
if self.metric.lower() not in ['ece', 'ace', 'mce']:
raise AttributeError(
'Parameter \'metric\' must be string with either \'ece\', \'ace\' or \'mce\'.'
)
else:
self.metric = self.metric.lower()
# perform checks and prepare input data
X, matched, sample_uncertainty, bin_bounds, num_features = self._miscalibration.prepare(
X, y, batched, uncertainty)
if num_features > 3:
raise AttributeError(
"Diagram is not defined for more than 2 additional feature dimensions."
)
histograms = []
for batch_X, batch_matched, batch_uncertainty, bounds in zip(
X, matched, sample_uncertainty, bin_bounds):
batch_histograms = self._miscalibration.binning(
bounds, batch_X, batch_matched, batch_X[:, 0],
batch_uncertainty[:, 0])
histograms.append(batch_histograms[:-1])
# no additional dimensions? compute standard reliability diagram
if num_features == 1:
fig = self.__plot_confidence_histogram(X, matched, histograms,
bin_bounds, title_suffix)
# one additional feature? compute 1D-plot
elif num_features == 2:
fig = self.__plot_1d(histograms, bin_bounds, title_suffix,
feature_names)
# two additional features? compute 2D plot
elif num_features == 3:
fig = self.__plot_2d(histograms, bin_bounds, title_suffix,
feature_names)
# number of dimensions exceeds 3? quit
else:
raise AttributeError(
"Diagram is not defined for more than 2 additional feature dimensions."
)
# if tikz is true, create tikz code from matplotlib figure
if tikz:
# get tikz code for our specific figure and also pass filename to store possible bitmaps
tikz_fig = tikzplotlib.get_tikz_code(fig,
filepath=filename,
**save_args)
# close matplotlib figure when tikz figure is requested to save memory
plt.close(fig)
fig = tikz_fig
# save figure either as matplotlib PNG or as tikz output file
if filename is not None:
if tikz:
with open(filename, "w") as open_file:
open_file.write(fig)
else:
fig.savefig(filename, **save_args)
return fig
def get_tikz_strings(model_dict, do_hist=True):
epochs = [ep + 1 for ep in list(range(model_dict['training']['epochs']))]
hist = model_dict['training']['history']
# accuracies
plt.close()
plt.figure()
for key in model_dict['training']['metrics']:
key_disp_stem = key.replace('_', ' ').capitalize()
if key == 'accuracy':
key = 'acc'
for metric in [key, 'val_' + key]:
if metric[:3] == 'val':
marker = 'o--'
metric_disp = 'Test ' + key_disp_stem
else:
marker = 'x--'
metric_disp = 'Training ' + key_disp_stem
# x axis
xmin, xmax = epochs[0] - .5, epochs[-1] + .5
plt.xlabel('Epoch')
plt.xticks(epochs)
# y axis
if len(model_dict['training']['metrics']) > 1:
plt.ylabel('Metric')
else:
plt.ylabel(metric_disp)
min_metric = float(min(hist[metric]))
min_loss = min([float(x) for x in hist['loss'] + hist['val_loss']])
max_loss = max([float(x) for x in hist['loss'] + hist['val_loss']])
ymin, ymax = .9 * min(round(min_metric, 1), 0.8), 1.025
yval = [float(val) for val in hist[metric]]
# axis limits
plt.axis([xmin, xmax, ymin, ymax])
# plot
plt.plot(epochs[:len(yval)],
yval,
marker,
label=metric_disp,
markersize=5,
linewidth=1)
# horizontal line at y=1
plt.plot([xmin, xmax], [1., 1.], 'k:', linewidth=1)
plt.title(r'{\bf Progression of Evaluation metrics}')
plt.legend(loc='lower right')
tikz_acc = tikzplotlib.get_tikz_code(extra_axis_parameters={'font=\small'},
strict=True)
# loss
plt.close()
fig = plt.figure()
for metric in ['loss', 'val_loss']:
metric_disp = 'Training Loss' if metric == 'loss' else 'Test Loss'
marker = 'o--' if metric[:3] == 'val' else 'x--'
# x axis
xmin, xmax = epochs[0] - .5, epochs[-1] + .5
plt.xlabel('Epoch')
plt.xticks(epochs)
# y axis
plt.ylabel('Loss')
min_loss = min([float(x) for x in hist['loss'] + hist['val_loss']])
max_loss = max([float(x) for x in hist['loss'] + hist['val_loss']])
ymin, ymax = .6 * min(round(min_loss, 0), 0.5), max_loss * 1.3
yval = [float(val) for val in hist[metric]]
# axis limits
plt.axis([xmin, xmax, ymin, ymax])
# plot
plt.plot(epochs[:len(yval)],
yval,
marker,
label=metric_disp,
markersize=5,
linewidth=1)
plt.legend(loc='upper right')
plt.title(r'{\bf Progression of loss function}')
tikz_loss = tikzplotlib.get_tikz_code(
extra_axis_parameters={'font=\small'}, strict=True)
######################################
# learning rate
plt.close()
plt.figure()
# x axis
xmin, xmax = epochs[0] - .5, epochs[-1] + .5
plt.xlabel('Epoch')
plt.xticks(epochs)
# y axis
plt.ylabel('Learning Rate')
min_lr, max_lr = float(min(hist['lr'])), float(max(hist['lr']))
ymin, ymax = .6 * min(round(min_lr, 1), 0.5), max_lr * 1.3
yval = [float(val) for val in hist['lr']]
# axis limits
plt.axis([xmin, xmax, ymin, ymax])
# plot
plt.plot(epochs[:len(yval)],
yval,
marker,
label='Learning Rate',
markersize=5,
linewidth=1)
plt.legend(loc='upper right')
plt.title(r'{\bf Progression of Learning rate}')
tikz_lr = tikzplotlib.get_tikz_code(extra_axis_parameters={'font=\small'},
strict=True)
out_dict = {'loss': tikz_loss, 'acc': tikz_acc, 'lr': tikz_lr}
return out_dict
axess[0][0].set_ylabel("test loss")
axess[1][0].set_ylabel("train loss")
axess[2][0].set_ylabel("test acc")
axess[3][0].set_ylabel("train acc")
# modify the plot
for axes in axess:
for ax in axes:
lines = ax.get_lines()
for line in lines:
line.set_linewidth(3)
fig.canvas.draw()
# General settings
code = tikzplotlib.get_tikz_code(figure = fig,
figurewidth = "\\figurewidth",
figureheight = "5cm",
extra_axis_parameters = ["tick pos=left",
"legend style={font=\\footnotesize, at={(0 ,0)},xshift=-0.4cm, yshift=-1.5cm,anchor=north,nodes=right}",],
extra_tikzpicture_parameters = ["every axis plot post./append style={line width = 1pt}"],
)#strict = True)
#catch missed underscores & save
code = code.replace("\_", "_").replace("_", "\_")
file = codecs.open("../../thesis/images/exp_tunedalpha.pgf", "w", 'utf-8')
file.write(code)
file.close()
def plot(dirs, exp_name='figure', save=True, show=True, plot_train=False):
import pandas as pd
import matplotlib.pyplot as plt
import tikzplotlib
def _patch_tikzplotlib():
def _new_draw_line2d(data, obj):
content = ["\\addplot +[mark=none] "] + tikzplotlib._line2d._table(
obj, data)[0]
legend_text = tikzplotlib._util.get_legend_text(obj)
if legend_text is not None:
content.append(f"\\addlegendentry{{{legend_text}}}\n")
return data, content
def _new_init(self, data, obj):
_tmp(self, data, obj)
self.axis_options = [
x for x in self.axis_options
if 'mod' in x or 'label' in x or 'title' in x
]
_tmp = tikzplotlib._axes.Axes.__init__
tikzplotlib._axes.Axes.__init__ = _new_init
tikzplotlib._line2d.draw_line2d = _new_draw_line2d
def _plot(ax, x, y, xlabel):
for exp in exps.values():
if plot_train:
ax.plot(exp['train'][x], exp['train'][y], ':')
mask = exp['val'][y] < 4
ax.plot(exp['val'][x][mask], exp['val'][y][mask])
ax.set(xlabel=xlabel, ylabel=y)
exps = {}
legends = []
for dir_name in dirs:
fnames = [
_name[:-10] for _name in os.listdir(dir_name)
if 'full' not in _name and 'train' in _name
]
for fname in fnames:
train = pd.read_csv(dir_name + '/' + fname + '_train.txt', sep=' ')
val = pd.read_csv(dir_name + '/' + fname + '_val.txt', sep=' ')
exps[fname] = {'train': train, 'val': val}
fname = fname.replace('_', '-')
if plot_train:
legends += [fname + '-train']
legends += [fname + '-val']
fig, axs = plt.subplots(1, 4)
_plot(axs[0], 'iterations', 'loss', '\#iters')
_plot(axs[1], 'train_time', 'loss', 'Training time / $s$')
# _plot(axs[1], 'run_time', 'loss', 'Run time / $s$')
_plot(axs[2], 'iterations', 'accuracy', '\#iters')
_plot(axs[3], 'train_time', 'accuracy', 'Training time / $s$')
# _plot(axs[3], 'run_time', 'accuracy', 'Run time / $s$')
plt.legend(legends)
if save:
_patch_tikzplotlib()
figure_content = tikzplotlib.get_tikz_code(filepath=exp_name,
figure=fig,
externalize_tables=True,
override_externals=False,
strict=False)
with open(exp_name + '-data.tex', 'w') as f:
data_fils = [x for x in os.listdir() if x.endswith('tsv')]
for f_path in data_fils:
with open(f_path, 'r') as f_data:
f.write(
'\\begin{filecontents}{%s}\n%s\\end{filecontents}\n\n\n'
% (f_path, f_data.read()))
os.remove(f_path)
with open('%s.tex' % exp_name, 'w') as f:
f.write('''\
\\documentclass{standalone}
\\usepackage[utf8]{inputenc}
\\usepackage{pgfplots}
\\usepgfplotslibrary{groupplots,dateplot}
\\usetikzlibrary{patterns,shapes.arrows}
\\pgfplotsset{compat=newest}
\\begin{document}
\\input{%s-data.tex}
%s
\\end{document}''' % (exp_name, figure_content))
if show:
plt.show()
'''
a = 5
t = np.linspace(0, 200)
f = 2000 * logistic.cdf((t - 75) / 10)
orig = np.r_[np.zeros(50), f, f[-1] * np.ones(50), np.flip(f)]
pmf = gamma.pdf(np.linspace(gamma.ppf(0.005, a), gamma.ppf(1 - 0.005, a)), a)
pmf /= sum(pmf)
obs = convolve(orig, pmf, mode="full")
obs *= sum(orig) / sum(obs)
plt.plot(obs, color=palette[1], label="symptom onset reports", linewidth=3)
plt.plot(orig, color="black", label="infections", linewidth=3)
plt.xlabel("time")
plt.ylabel("cases")
plt.legend()
print(tikzplotlib.get_tikz_code())
# b = 3
# orig = np.r_[0, 4, 6, 9, 7, 5, np.zeros(14)]
# pmf = poisson.pmf(range(9), b)
# plt.plot(pmf)
# plt.show()
blur = convolve(orig, pmf, mode="full")
plt.plot(orig)
plt.plot(blur)
plt.show()
# http://freerangestats.info/blog/2020/07/18/victoria-r-convolution
axes.get_lines()[1].set_marker("x")
axes.get_lines()[1].set_alpha(0.5)
axes.plot([1e-5, 100], [mean, mean],
linewidth=3,
linestyle="dashed",
color="grey")
axes.legend(["PreconditionedSGD", "SGD", "Constructed Learning Rate"])
fig.canvas.draw()
code = tikzplotlib.get_tikz_code(
figure=fig,
figurewidth="\\figurewidth + 1cm",
figureheight="5cm",
extra_axis_parameters=[
"tick pos=left",
"legend style={font=\\footnotesize, at={(0.5 ,0)}, yshift=-1.5cm,anchor=north,nodes=right}"
],
extra_tikzpicture_parameters=[],
) #strict = True)
#catch missed underscores & save
code = code.replace("\_", "_").replace("_", "\_")
file = codecs.open("../../thesis/images/exp_lr_sens.pgf", "w", 'utf-8')
file.write(code)
file.close()
###### Presentation
code = tikzplotlib.get_tikz_code(
figure=fig,