def plot_percentiles(percentiles, labels):
fig, ax = plt.subplots(figsize=(20, 12))
# plot values
for data in percentiles:
ax.plot(data['Percentile'], data['Latency'])
# set axis and legend
ax.grid()
ax.set(xlabel='Percentile',
ylabel='Latency (milliseconds)',
title='Latency Percentiles')
ax.set_xscale('logit')
plt.xticks([0.25, 0.5, 0.9, 0.99, 0.999, 0.9999, 0.99999, 0.999999])
majors = [
"25%", "50%", "90%", "99%", "99.9%", "99.99%", "99.999%", "99.9999%"
]
ax.xaxis.set_major_formatter(ticker.FixedFormatter(majors))
ax.xaxis.set_minor_formatter(ticker.NullFormatter())
# ax.xaxis.label.set_size(25)
# ax.yaxis.label.set_size(25)
for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +
ax.get_xticklabels() + ax.get_yticklabels()):
item.set_fontsize(20)
plt.legend(bbox_to_anchor=(0., 1.02, 1., .102),
loc=3,
ncol=2,
borderaxespad=0.,
labels=labels)
return fig, ax
def __init__(self, music_name):
with wave.open(music_name, "r") as wav:
(self.nchannels, self.sampwidth, self.framerate, self.nframes,
self.comptype, self.compname) = wav.getparams()
self.duration = self.nframes / self.framerate
_w, _h = 800, 200
self.k = int(self.nframes / _w / 32)
self.DPI = 72
self.peak = 256**self.sampwidth / 2
data = scipy.io.wavfile.read(music_name)
samples = data[1]
plt.figure(1,
figsize=(float(_w) / self.DPI, float(_h) / self.DPI),
dpi=self.DPI)
plt.subplots_adjust(wspace=0, hspace=0)
for n in range(self.nchannels):
channel = samples[n:]
channel = channel[0::self.k]
if self.nchannels == 1:
channel = channel - self.peak
axes = plt.subplot(2, 1, n + 1, facecolor="k")
axes.plot(channel, "g")
axes.yaxis.set_major_formatter(ticker.FuncFormatter(
self.format_db))
plt.grid(True, color="w")
axes.xaxis.set_major_formatter(ticker.NullFormatter())
axes.xaxis.set_major_formatter(ticker.FuncFormatter(self.format_time))
plt.savefig("wave", dpi=self.DPI)
def axis_settings(subax,
label=False,
arg1=None,
arg2=None,
arg3=None,
arg4=None,
arg5=None):
subax.set_yscale('log')
subax.set_xlim((0, 35))
subax.set_ylim((0.01, 100))
subax.set_xticks([7, 14, 21, 28, 35])
subax.tick_params(axis='x',
which='both',
bottom=True,
top=True,
labelbottom=label,
labelsize=8)
subax.set_yticks([0.01, 0.1, 1, 10, 100])
subax.tick_params(axis='y',
which='both',
left=True,
right=True,
labelleft=label,
labelsize=8)
locmin = mticker.LogLocator(base=10, subs=[1.0])
subax.yaxis.set_minor_locator(locmin)
subax.yaxis.set_minor_formatter(mticker.NullFormatter())
subax.yaxis.get_label().set_backgroundcolor('w')
for tick in subax.yaxis.get_major_ticks():
tick.label.set_backgroundcolor('w')
subax.grid(True, which="both", ls="--", c='gray', lw=0.5)
return (subax)
def add_dlog_plot(axes, x, y, style, label="", fit_deg=0):
axes.loglog(x,
y,
**style.marker,
**style.linestyle,
label=label,
color=style.color,
fillstyle="none")
if fit_deg:
log_x = np.log(x)
log_y = np.log(y)
coeffs = np.polyfit(log_x, log_y, deg=fit_deg)
poly_1d = np.poly1d(coeffs)
yfit = lambda x: np.exp(poly_1d(np.log(x)))
# label = rf"$y = {coeffs[0]:.2f}x {coeffs[1]:+.2f}$"
label = rf"$n = {coeffs[0]:.2f}$"
axes.plot(x, yfit(x), color=style.color, marker="", label=label)
# needed to prevent overlapping labels:
locs = axes.get_xticklabels(minor=True)
if len(locs) > 5:
axes.xaxis.set_minor_formatter(ticker.NullFormatter())
axes.xaxis.set_major_locator(ticker.MaxNLocator(nbins=5))
style.next_style()
def cleanup(self):
"""
Cleanup the image by removing textual/formatting elements.
"""
# Hide this method from the pytest traceback on test failure.
__tracebackhide__ = True
if self.remove_title:
self.ax.set_title("")
if self.remove_ticks:
null_formatter = ticker.NullFormatter()
for axis in ("xaxis", "yaxis", "zaxis"):
try:
axis = getattr(self.ax, axis)
axis.set_major_formatter(null_formatter)
axis.set_minor_formatter(null_formatter)
except AttributeError:
continue
if self.remove_labels:
self.ax.set_xlabel("")
self.ax.set_ylabel("")
if self.remove_legend and self.ax.get_legend() is not None:
self.ax.legend_.remove()
def srgan_loss_comparison():
"""Creates a plot which shows the theoretical loss curves for feature vector distances."""
sns.set_style('darkgrid')
figure, axes = plt.subplots(dpi=dpi)
x_axis = np.arange(-10, 10, 0.01)
l_g = -(np.log(np.abs(x_axis) + 1))
l_unlabeled = np.power(x_axis, 2)
axes.plot(x_axis, (l_g - l_g.min()) / (l_g.max() - l_g.min()),
color=sns.color_palette()[4],
label='$L_G$')
axes.plot(x_axis, (l_unlabeled - l_unlabeled.min()) /
(l_unlabeled.max() - l_unlabeled.min()),
color=sns.color_palette()[5],
label='$L_{fake}$')
axes.legend().set_visible(True)
axes.legend(loc='right')
# axes.get_yaxis().set_ticks([])
axes.set_ylabel('Loss')
axes.set_xlabel('Feature difference')
axes.get_yaxis().set_major_formatter(ticker.NullFormatter())
axes.get_yaxis().grid(False)
matplotlib2tikz.save(os.path.join('latex', 'srgan-losses.tex'))
plt.show()
plt.close(figure)
def or_plot(fitted, alpha=0.05, intercept=False):
"""
Odds ratio plot
Parameters
----------
fitted A fitted logistic regression model
alpha Significance level
intercept Include intercept in plot (True or False)
"""
df = or_conf_int(fitted, alpha=alpha, intercept=intercept,
dec=None).iloc[::-1]
low, high = [100 * alpha / 2, 100 * (1 - (alpha / 2))]
err = [df["OR"] - df[f"{low}%"], df[f"{high}%"] - df["OR"]]
fig, ax = plt.subplots()
ax.axvline(1, ls="dashdot")
ax.errorbar(x="OR", y="index", data=df, xerr=err, fmt="none")
ax.scatter(x="OR", y="index", data=df)
ax.set_xscale("log")
ax.xaxis.set_minor_formatter(ticker.NullFormatter())
ax.xaxis.set_major_locator(
ticker.LogLocator(subs=[0.1, 0.2, 0.5, 1, 2, 5, 10]))
ax.xaxis.set_major_formatter(ticker.StrMethodFormatter("{x:.1f}"))
ax.set(xlabel="Odds-ratio")
return ax
def hyperopt_int_plot(
hyperopt_results_df,
hp_name,
metric,
filename,
log_scale_x=False,
log_scale_y=True
):
sns.set_style('whitegrid')
plt.figure()
seaborn_figure = sns.scatterplot(
x=hp_name,
y=metric,
data=hyperopt_results_df
)
if log_scale_x:
seaborn_figure.set(xscale="log")
if log_scale_y:
seaborn_figure.set(yscale="log")
seaborn_figure.xaxis.set_major_locator(ticker.MaxNLocator(integer=True))
seaborn_figure.xaxis.set_major_formatter(ticker.ScalarFormatter())
seaborn_figure.xaxis.set_minor_formatter(ticker.NullFormatter())
seaborn_figure.figure.tight_layout()
if filename:
seaborn_figure.figure.savefig(filename)
else:
seaborn_figure.figure.show()
def plot_correction(pre_mat, post_mat, title):
""" Plot comparison of pre-correction and post-correction matrices """
#Make figure
fig, ax = plt.subplots()
fig.suptitle(title, fontsize=16, weight="bold")
L = pre_mat.shape[1]
flank = int(L / 2.0)
xvals = np.arange(L) # each position corresponds to i in mat
#Customize minor tick labels
xtick_pos = xvals[:-1] + 0.5
xtick_labels = list(range(-flank, flank)) #-flank - flank without 0
ax.xaxis.set_major_locator(ticker.FixedLocator(xvals))
ax.xaxis.set_major_formatter(ticker.FixedFormatter(xtick_labels))
ax.xaxis.set_minor_locator(ticker.FixedLocator(
xtick_pos)) #locate minor ticks between major ones (cutsites)
ax.xaxis.set_minor_formatter(ticker.NullFormatter())
#PWMs for all mats
pre_pwm = pre_mat
post_pwm = post_mat
#Pre correction
for nuc in range(4):
yvals = [pre_pwm[nuc, m] for m in range(L)]
plt.plot(xvals,
yvals,
linestyle="--",
color=colors[nuc],
linewidth=1,
alpha=0.5)
#Post correction
for nuc in range(4):
yvals = [post_pwm[nuc, m] for m in range(L)]
plt.plot(xvals,
yvals,
color=colors[nuc],
linewidth=2,
label=names[nuc])
plt.xlim([0, L - 1])
plt.xlabel('Position from cutsite')
plt.ylabel('Nucleotide frequency')
#Set legend
plt.plot([0], [0],
linestyle="--",
linewidth=1,
color="black",
label="pre-correction")
plt.plot([0], [0], color="black", label="post-correction")
plt.legend(loc="lower right", prop={'size': 6})
plt.tight_layout()
fig.subplots_adjust(top=0.88, hspace=0.4)
return (fig)
def draw(file_name):
wav = wave.open(file_name, mode="r")
global nframes, k, peak, duration
(nchannels, sampwidth, framerate, nframes, comptype,
compname) = wav.getparams()
duration = nframes / framerate
w, h = 800, 300
k = nframes / w / 32
DPI = 72
peak = 256**sampwidth / 2
content = wav.readframes(nframes)
samples = np.fromstring(content, dtype=types[sampwidth])
plt.figure(1, figsize=(float(w) / DPI, float(h) / DPI), dpi=DPI)
plt.subplots_adjust(wspace=0, hspace=0)
for n in range(nchannels):
channel = samples[n::nchannels]
channel = channel[0::k]
if nchannels == 1:
channel = channel - peak
axes = plt.subplot(2, 1, n + 1, axisbg="k")
axes.plot(channel, "g")
axes.yaxis.set_major_formatter(ticker.FuncFormatter(format_db))
plt.grid(True, color="w")
axes.xaxis.set_major_formatter(ticker.NullFormatter())
axes.xaxis.set_major_formatter(ticker.FuncFormatter(format_time))
# plt.savefig("wave", dpi=DPI)
plt.show()
def set_yaxis(self):
"""
Custom Y axis with absolute or percentage formatting
"""
if self.yunits == '%':
# Set percentage scale
self.ymax = max(self.ymax, 0.01) # set a minimum of 1%
note_ymax = '{:.1%}'.format(np.around(self.ymax, 3)) if self.ymax < 1 else ''
divider = 4
majformatter = tkr.PercentFormatter(xmax=1)
self.log.debug("Plot Y axis set to percentual values")
else:
# Set absolute scale
self.ymax = max(self.ymax, 1) # set a minimum of 1 unit
note_ymax = '{:.0f}'.format(np.around(self.ymax, 0))
divider = 2 if self.ymax > 10 else 1
majformatter = tkr.ScalarFormatter()
self.log.debug("Plot Y axis set to absolute values")
self.ax.set_ylim([0, self.ymax])
self.ax.yaxis.set_minor_locator(tkr.AutoMinorLocator(divider))
self.ax.yaxis.set_major_locator(tkr.MaxNLocator())
self.ax.yaxis.set_minor_formatter(tkr.NullFormatter())
self.ax.yaxis.set_major_formatter(majformatter)
# Add axes labels
self.ax.set_ylabel(self.ylab)
# Add max value as annotation
self.add_annotation(note_ymax, (0.00, 1.03), align='center')
def logtick(ax, axis='x', grid=True, color="k", subs=[1., 2., 5.]):
if matplotlibversion < "1.2":
print "ERROR : logtick doesn't work with maptplotlib < 1.2"
return
def myfuncformatter(tick, tickposition=None):
s = "%.6f" % tick
if "." in s: s = s.rstrip('0').rstrip('.')
return s
major_locator = ticker.LogLocator(base=10., subs=subs)
major_formatter = ticker.FuncFormatter(myfuncformatter)
minor_locator = ticker.LogLocator(base=10., subs=[3., 4., 6., 7., 8., 9.])
minor_formatter = ticker.NullFormatter()
if 'x' in axis.lower():
ax.xaxis.set_major_locator(major_locator)
ax.xaxis.set_major_formatter(major_formatter)
ax.xaxis.set_minor_locator(minor_locator)
ax.xaxis.set_minor_formatter(minor_formatter)
if 'y' in axis.lower():
ax.yaxis.set_major_locator(major_locator)
ax.yaxis.set_major_formatter(major_formatter)
ax.yaxis.set_minor_locator(minor_locator)
ax.yaxis.set_minor_formatter(minor_formatter)
if grid:
ax.grid(True, which="major", color=color, linestyle=":")
ax.grid(True, which="minor", color=color, linestyle=":")
def common_ytick_labels(fig, axes=None):
""" Simplify common ytick labels.
Keep ytick labels only at the leftmost axes and center the common ylabel.
Parameters
----------
fig: matplotlib figure
The figure containing the axes.
axes: None or sequence of matplotlib axes
Axes whose yticks should be combined.
If None take all axes of the figure.
"""
if axes is None:
axes = fig.get_axes()
coords = np.array([ax.get_position().get_points().ravel() for ax in axes])
minx = np.min(coords[:, 0])
miny = np.min(coords[:, 1])
maxy = np.max(coords[:, 3])
yl = 0.5 * (miny + maxy)
done = False
for ax in axes:
if ax.get_position().p0[0] > minx + 1e-6:
ax.set_ylabel('')
ax.yaxis.set_major_formatter(ticker.NullFormatter())
elif done:
ax.set_ylabel('')
else:
x, y = ax.yaxis.get_label().get_position()
y = ax.transAxes.inverted().transform(
fig.transFigure.transform((0, yl)))[1]
ax.yaxis.get_label().set_position((x, y))
done = True
def plot_all(incl, save=None):
global models
rows = 2
cols = 2
fig, axes = plt.subplots(nrows=rows,
ncols=cols,
sharex=True,
sharey=True,
figsize=(19.20, 10.80))
fig.subplots_adjust(wspace=0., hspace=0.)
for i, model in enumerate(models):
ax = axes.flatten()[i]
star = Star(model, incl)
wave_obs, sed_obs = np.loadtxt(
'/home/rieutord/Ester/postprocessing/SED/SED', unpack=True)
wave_mod, sed_mod = star.SED()
ax.loglog(wave_mod * 1e4, sed_mod * 1e-4)
ax.loglog(wave_obs, sed_obs, 'o')
ax.yaxis.set_minor_locator(plt.LogLocator(base=10, numticks=15))
ax.yaxis.set_minor_formatter(ticker.NullFormatter())
ax.tick_params(labelsize=16,
direction='inout',
which='both',
length=5,
width=1)
if ax.colNum != 0:
ax.tick_params(left=False)
else:
ax.set_ylabel(
'F$_\lambda$ (erg$\cdot$s$^{-1}\cdot$cm$^{-2}\cdot\mu$m$^{-1}$)',
fontsize=20)
if ax.rowNum != 1:
ax.tick_params(bottom=False)
else:
ax.set_xlabel('$\lambda$ ($\mu$m)', fontsize=20)
text = (
'M = {star.mod.M/Star.Msun:.2f} M$\odot$\nZ = {star.mod.Z[0, 0]:.3f}\n'
'Xc = {star.mod.Xc:.3f}')
props = dict(boxstyle='round', facecolor='white', alpha=0.7)
# place a text box in lower left in axes coords
ax.text(0.75,
0.90,
text,
transform=ax.transAxes,
verticalalignment='top',
bbox=props,
fontdict=dict(fontsize=14))
if save:
fig.savefig(fname='/home/rieutord/Ester/postprocessing/SED/' + save,
bbox_inches='tight')
fig.show()
return
def plotFourierData(freq, mag, axis=None, color='b', alpha=1.0):
ax = axis
if axis is None:
fig = plt.figure(1337)
fig.clf()
fig.canvas.set_window_title("Non-Intrusive Load Monitoring - Frequency Spectrum - Felix Maass")
ax = fig.add_subplot(111)
ax.plot(freq, mag, color=color, alpha=alpha)
ax.set_title("Frequency Spectrum")
ax.set_xlabel('Frequency [Hz]')
ax.get_xaxis().set_major_formatter(ticker.EngFormatter())
ax.get_xaxis().set_minor_formatter(ticker.NullFormatter())
ax.set_ylabel('Magnitude (log10)')
ax.set_yscale('log')
#######
if axis is None:
fig.tight_layout()
plt.show()
def set_default_locators_and_formatters(self, axis):
axis.set_major_locator(GPSAutoLocator(unit=self.unit,
epoch=self.epoch))
axis.set_major_formatter(GPSFormatter(unit=self.unit,
epoch=self.epoch))
axis.set_minor_locator(GPSAutoMinorLocator(epoch=self.epoch))
axis.set_minor_formatter(ticker.NullFormatter())
def plotPowerCurve(chunk, axis=None):
ax = axis
if axis is None:
fig = plt.figure(271)
fig.clf()
fig.canvas.set_window_title("Non-Intrusive Load Monitoring - Power Characteristics - Felix Maass")
ax = fig.add_subplot(111)
ax.set_title("Power")
ax.set_xlabel('Time [ms]')
ax.set_ylabel('Power [VA / W / VAr]')
ax.get_xaxis().set_major_formatter(ticker.EngFormatter())
ax.get_xaxis().set_minor_formatter(ticker.NullFormatter())
apparentPower = chunk['u'] * chunk['i']
phaseShift = calculatePhaseShift(chunk)
realPower = apparentPower * cos(phaseShift)
reactivePower = apparentPower * sin(phaseShift)
ax.plot(chunk['t'], apparentPower, color='r', label='Apparent')
ax.plot(chunk['t'], realPower, color='g', label='Real')
ax.plot(chunk['t'], reactivePower, color='b', label='Reactive')
ax.legend()
#######
if axis is None:
fig.tight_layout()
plt.show()
def plotIVCurve(chunk, axis=None):
ax = axis
if axis is None:
fig = plt.figure(314)
fig.clf()
fig.canvas.set_window_title("Non-Intrusive Load Monitoring - Current-Voltage Characteristics - Felix Maass")
ax = fig.add_subplot(111)
ax.set_title("IV-Curve")
ax.set_xlabel('Voltage [V]')
ax.set_ylabel('Amperage [A]')
ax.get_xaxis().set_major_formatter(ticker.EngFormatter())
ax.get_xaxis().set_minor_formatter(ticker.NullFormatter())
if np.max(np.abs(chunk['i'])) < 0.3:
ax.set_ylim([-500,500])
ax.set_autoscaley_on(False)
else:
ax.set_autoscaley_on(True)
ax.plot(chunk['u'], chunk['i'], color='b')
#######
if axis is None:
fig.tight_layout()
plt.show()
def plot_emacs(model, run_name, model_name, noise_type):
emac = 0
noise = 0
emacs = []
denominator = 0
for name, param in model.named_parameters():
if "noise" in name:
mod = model
for subname in name.split('.')[:-1]:
mod = getattr(mod, subname)
e = torch.exp(param)
if mod.quantize_energy:
e = RoundSTE.apply(e)
if noise_type == "shot":
noise += 1. / torch.sqrt(e).mean() * mod.total_macs
elif noise_type == "thermal":
noise += 1. / torch.sqrt(e).mean() * mod.total_macs / 100.
if noise_type == "weight":
noise += 1. / torch.sqrt(e).mean() * mod.total_macs
emac += e.mean() * mod.total_macs
emacs.append(e.mean().item())
denominator += mod.total_macs
avg_emac = (emac / denominator).item()
avg_noise = (noise / denominator).item()
plt.figure(figsize=(5, 3.5))
plot = sns.lineplot(x=range(len(emacs)), y=np.array(emacs) * 0.128)
if model_name == "bert":
title = f"BERT Energy/MAC by Matrix Multiplication"
xlabel = "Matrix Multiplication"
else:
title = f"{model_name}".capitalize() + f" Energy/MAC by Layer"
xlabel = "Layer"
sns.set_color_codes()
plot.set_title(title)
plot.set(yscale="log")
plot.set(xlabel=xlabel, ylabel=f"Energy/MAC (aJ)")
plot.yaxis.set_major_formatter(ticker.ScalarFormatter())
y_minor = ticker.LogLocator(base=10.0,
subs=np.arange(1.0, 10.0) * 0.1,
numticks=10)
plot.get_yaxis().set_minor_locator(y_minor)
plot.grid(b=True,
which='minor',
color='lightgray',
axis='y',
linewidth=0.5)
plot.yaxis.set_minor_locator(y_minor)
plot.yaxis.set_minor_formatter(ticker.NullFormatter())
plt.savefig(f"{run_name}/emac_by_layer.pdf", bbox_inches="tight")
plt.close()
return avg_emac, avg_noise
def plot_formatter(ax, title='Title', fname='fname.png'):
ax.set_title(title)
ax.set_xlabel('$u - g$ [mag]')
ax.set_ylabel('$g - r$ [mag]')
ax.legend()
ax2 = ax.twinx()
ax2.set_ylabel('Blue $\\longrightarrow$ Red')
ax2.plot([1], [1], markersize=0)
ax3 = ax.twiny()
ax3.set_xlabel('Blue $\\longrightarrow$ Red')
ax3.plot([1], [1], markersize=0)
ax2.yaxis.set_minor_formatter(ticker.NullFormatter())
ax3.xaxis.set_minor_formatter(ticker.NullFormatter())
ax2.yaxis.set_major_formatter(ticker.NullFormatter())
ax3.xaxis.set_major_formatter(ticker.NullFormatter())
plt.savefig(fname, dpi=300)
plt.close()
def __init__(self, *args, **kwargs):
# Pass a dummy axis to the superclass
axis = type('Axis', (object, ), {'axis_name': 'x'})()
super().__init__(axis, *args, **kwargs)
self._default_major_locator = mticker.AutoLocator()
self._default_minor_locator = mticker.AutoMinorLocator()
self._default_major_formatter = pticker.AutoFormatter()
self._default_minor_formatter = mticker.NullFormatter()
def plot_one_for_all(incl, save=None, res=False, error=0.1):
global models
fig, ax = plt.subplots(figsize=(10.80, 10.80))
wave_obs, sed_obs = np.loadtxt(
'/home/rieutord/Ester/postprocessing/SED/SED', unpack=True)
ax.loglog(wave_obs, sed_obs, 'o')
ax.set_xlabel('$\lambda$ ($\mu$m)', fontsize=20)
ax.set_ylabel(
'F$_\lambda$ (erg$\cdot$s$^{-1}\cdot$cm$^{-2}\cdot\mu$m$^{-1}$)',
fontsize=20)
ax.yaxis.set_minor_locator(plt.LogLocator(base=10, numticks=15))
ax.yaxis.set_minor_formatter(ticker.NullFormatter())
ax.tick_params(labelsize=16,
direction='inout',
which='both',
length=5,
width=1)
linestyles = itertools.cycle([(0, (5, 5)), 'dashdot',
(0, (3, 5, 1, 5, 1, 5)), 'dotted', '-'])
# Print reduced Chi2 of fit with arbitrary uncertainty on observed data
if res:
print('Reduced chi2 ({error*100}% artificial error on data):\n')
for i, model in enumerate(models):
star = Star(mod=model, incl=incl)
wave_mod, sed_mod = star.SED()
ax.loglog(
wave_mod * 1e4,
sed_mod * 1e-4,
ls=next(linestyles),
label=
('M = {star.mod.M/Star.Msun:.2f} M$\odot$, Z = {star.mod.Z[0, 0]:.3f}, '
'Xc = {star.mod.Xc:.2f}, $\overline{{\mathrm{{T}}}} = '
'{int(star.Teff_mean())} $K'),
zorder=0)
if res:
wave_mod_chi2, sed_mod_chi2 = star.SED(wavelength=wave_obs * 1e-4)
sum_squared_res = sum(
((sed_mod_chi2 * 1e-4 - sed_obs) / (error * sed_obs))**2)
chi2_red = sum_squared_res / len(sed_mod_chi2)
print('model {star.mod.M/Star.Msun:.2f}: {chi2_red}')
ax.legend(fontsize=16, loc='lower left')
if save:
fig.savefig(fname='./' + save, bbox_inches='tight')
fig.show()
return
def test_colorbars_no_overlapH():
fig = plt.figure(figsize=(4, 2), layout="constrained")
fig.suptitle("foo")
axs = fig.subplots(1, 2, sharex=True, sharey=True)
for ax in axs:
ax.yaxis.set_major_formatter(ticker.NullFormatter())
ax.tick_params(axis='both', direction='in')
im = ax.imshow([[1, 2], [3, 4]])
fig.colorbar(im, ax=ax, orientation="horizontal")
def colorbar(self,
fig=None,
anchor=(0.35, 0.24),
size=(0.3, 0.02),
fmt="{f:.0f}",
label=True):
"""カラーバーを描く
Parameters:
----------
fig: matplotlib Figure
プロット領域を作成した際の戻り値
anchor: tuple(float, float)
カラーバーの位置
size: tuple(float, float)
カラーバーの大きさ
fmt: str
カラーバーの目盛り線ラベルの書式
label: bool
カラーバーの目盛り線ラベルを描くかどうか
----------
"""
if fig is None:
raise Exception('fig is needed')
ax = fig.add_axes(anchor + size)
gradient = np.linspace(0, 1, self.cm.N)
gradient_array = np.vstack((gradient, gradient))
ticks = list()
labels = list()
ll = np.arange(self.tmin, self.tmax, self.tstep)
for t in ll:
ticks.append((t - self.tmin) / (self.tmax - self.tmin) * self.cm.N)
if label:
labels.append(fmt.format(f=t))
# カラーバーを描く
ax.imshow(gradient_array, aspect='auto', cmap=self.cm)
ax.yaxis.set_major_locator(mticker.NullLocator())
ax.yaxis.set_minor_locator(mticker.NullLocator())
ax.set_xticks(ticks)
if label:
ax.set_xticklabels(labels)
else:
ax.xaxis.set_major_formatter(mticker.NullFormatter())
ax.xaxis.set_minor_formatter(mticker.NullFormatter())
def plot_history(env, h):
grid = np.ones(env.state_space) * 255
xs = []
ys = []
us = []
vs = []
for t in range(1, len(h) - 1):
state = h[t][0]
next_state = h[t + 1][0]
x = state[1]
y = state[0]
u = next_state[1] - state[1]
v = -(next_state[0] - state[0])
xs.append(x)
ys.append(y)
us.append(u)
vs.append(v)
grid[y, x] = 200
fig, ax = plt.subplots(1, figsize=(20, 15))
plt.imshow(grid, cmap='gray', vmin=0, vmax=255)
ax.grid(linestyle='-', linewidth=1)
ax.set_xticks(np.arange(-.5, 10, 1))
ax.set_yticks(np.arange(-.5, 10, 1))
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_xlabel('Wind (number of steps pushed North)', fontsize=30)
ax.text(env.initial_state[1],
env.initial_state[0],
'Start',
ha="center",
va="center",
fontsize=30)
ax.text(env.terminate_state[1],
env.terminate_state[0],
'End',
ha="center",
va="center",
fontsize=30)
ax.xaxis.set_major_formatter(ticker.NullFormatter())
ax.xaxis.set_minor_locator(ticker.FixedLocator(np.arange(0, 10, 1)))
ax.xaxis.set_minor_formatter(ticker.FixedFormatter(np.abs(env.north_wind)))
ax.tick_params(which='minor', labelsize=20)
plt.arrow(5.5, 6, 0, -4, width=2, head_width=5, head_length=2, alpha=0.4)
plt.quiver(xs, ys, us, vs)
plt.title('Policy', fontsize=35)
def plot_num_triplet_with_nonzero_integer_ambiguity(fname, display=False, font_size=12, fig_size=[9,3]):
"""Plot the histogram for the number of triplets with non-zero integer ambiguity
Fig. 3d-e in Yunjun et al. (2019, CAGEO).
"""
# read data
data, atr = readfile.read(fname)
vmax = int(np.nanmax(data))
# plot
fig, axs = plt.subplots(nrows=1, ncols=2, figsize=fig_size)
# subplot 1 - map
ax = axs[0]
im = ax.imshow(data, cmap='RdBu_r', interpolation='nearest')
# reference point
if all(key in atr.keys() for key in ['REF_Y','REF_X']):
ax.plot(int(atr['REF_X']), int(atr['REF_Y']), 's', color='white', ms=3)
# format
pp.auto_flip_direction(atr, ax=ax, print_msg=False)
fig.colorbar(im, ax=ax)
ax.set_title(r'$T_{int}$', fontsize=font_size)
# subplot 2 - histogram
ax = axs[1]
ax.hist(data[~np.isnan(data)].flatten(), range=(0, vmax), log=True, bins=vmax)
# axis format
ax.set_xlabel(r'# of triplets w non-zero int ambiguity $T_{int}$', fontsize=font_size)
ax.set_ylabel('# of pixels', fontsize=font_size)
ax.xaxis.set_minor_locator(ticker.AutoMinorLocator())
ax.yaxis.set_major_locator(ticker.LogLocator(base=10.0, numticks=15))
ax.yaxis.set_minor_locator(ticker.LogLocator(base=10.0, numticks=15,
subs=(0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9)))
ax.yaxis.set_minor_formatter(ticker.NullFormatter())
for ax in axs:
ax.tick_params(which='both', direction='in', labelsize=font_size,
bottom=True, top=True, left=True, right=True)
fig.tight_layout()
# output
out_fig = '{}.png'.format(os.path.splitext(fname)[0])
print('plot and save figure to file', out_fig)
fig.savefig(out_fig, bbox_inches='tight', transparent=True, dpi=300)
if display:
plt.show()
else:
plt.close(fig)
return
def mirror_xticks(my_axes, xlim, xmajor, xminor=None):
my_axes.xaxis.set_ticks(xmajor)
if xminor is not None:
my_axes.xaxis.set_ticks(xminor, minor=True)
my_axes.xaxis.set_minor_formatter(ticker.NullFormatter())
my_axes.set_xlim(xlim)
tx = my_axes.twiny()
tx.set_xscale(my_axes.get_xscale())
tx.xaxis.tick_top()
tx.xaxis.set_tick_params(direction='in', which='both')
tx.xaxis.set_ticks(xmajor)
if xminor is not None:
tx.xaxis.set_ticks(xminor, minor=True)
tx.xaxis.set_minor_formatter(ticker.NullFormatter())
tx.set_xlim(xlim)
for ticklabel in tx.xaxis.get_majorticklabels():
ticklabel.set_visible(False)
return tx
def mirror_yticks(my_axes, ylim, ymajor, yminor=None):
my_axes.yaxis.set_ticks(ymajor)
if yminor is not None:
my_axes.yaxis.set_ticks(yminor, minor=True)
my_axes.yaxis.set_minor_formatter(ticker.NullFormatter())
my_axes.set_ylim(ylim)
ty = my_axes.twinx()
ty.set_yscale(my_axes.get_yscale())
ty.yaxis.tick_right()
ty.yaxis.set_tick_params(direction='in', which='both')
ty.yaxis.set_ticks(ymajor)
if yminor is not None:
ty.yaxis.set_ticks(yminor, minor=True)
ty.yaxis.set_minor_formatter(ticker.NullFormatter())
ty.set_ylim(ylim)
for ticklabel in ty.yaxis.get_majorticklabels():
ticklabel.set_visible(False)
return ty
def createplotforoperation(op, data, inter):
plt.cla()
plt.clf()
plt.rcParams.update({'font.size': 12})
plt.figure(figsize=(7.5, 5))
plt.yscale('log') #Vi skal lige vælge om det er log eller ej
plt.xscale('log')
plt.gca().yaxis.set_major_formatter(mtick.StrMethodFormatter('{x:,.0f}'))
plt.gca().yaxis.set_minor_formatter(mtick.NullFormatter())
df = pd.DataFrame(data[data["Op"] == op])
df = df.astype({'OpCount': 'int64'})
df['Avg(micros)'] = (df['Time(s)'] / df['OpCount']) * 1000 * 1000
print(df)
texts = []
i = 0
for name in sorted(list(pd.unique(df['DS']))):
dfn = df[df['DS'] == name]
x = list(dfn['Size'])
y = list(dfn['Avg(micros)'])
p = plt.plot(x, y, label=name, marker=markers[i])
i += 1
texts.append(
plt.annotate(f'{name}', (x[-1], y[-1]), color=p[0].get_color()))
plt.xlabel('Initial elements')
plt.ylabel('Average time (µs)')
plt.grid(True, which="both", linestyle='--')
size = texts[0].get_fontsize()
overlapping = True
while overlapping:
overlap = set()
overlapping = False
for a in texts:
for b in texts:
if a == b: continue
if a._get_position_xy(plt)[1] < b._get_position_xy(
plt)[1] and a._get_position_xy(
plt)[1] + size > b._get_position_xy(plt)[1]:
overlap.add(a)
overlap.add(b)
overlapping = True
if len(overlap) == 0: break
mi = min(overlap, key=lambda a: a.xy[1])
ma = max(overlap, key=lambda a: a.xy[1])
mi.set_y(mi.xy[1] - mi.xy[1] / 100)
ma.set_y(ma.xy[1] + ma.xy[1] / 100)
mi.xy = (mi._x, mi._y)
ma.xy = (ma._x, ma._y)
plt.legend(loc="upper left")
plt.margins(x=0)
plt.title(f'Average runtime for N "{op}" operations in {l}')
plt.tight_layout()
pathlib.Path(f'../results/graphs_{inter}').mkdir(parents=True,
exist_ok=True)
plt.savefig(f'../results/graphs_{inter}/{op}.png', bbox_inches='tight')
def decorate_data_late(ax, t, ym, yM):
'''
input:
ax, axis handle
sets limits,writes x_label
'''
from matplotlib import ticker
ax.set_xlim(t[0], t.max())
ax.set_ylim(ym, yM)
ax.yaxis.set_major_formatter(ticker.NullFormatter()) #
