def filterstats(input_fn, output_dir, topn=None,
maxeerates=[0.25, 0.5, 0.75, 1, 1.25, 1.5], maxns=None):
if not os.path.isdir(output_dir):
raise ValueError("directory {} does not exist".format(output_dir))
minlen_fn = os.path.join(output_dir, "filterstats_minlen.txt")
trunclen_fn = os.path.join(output_dir, "filterstats_trunclen.txt")
plot_fn = os.path.join(output_dir, "filterstats_plot.png")
minlen, trunclen = _stats(
input_fn=input_fn,
topn=topn,
maxeerates=maxeerates,
maxns=maxns)
minlen.to_csv(minlen_fn, sep="\t", float_format="%.3f", index=False)
trunclen.to_csv(trunclen_fn, sep="\t", float_format="%.3f", index=False)
# custom rc. svg.fonttype": "none" corrects the conversion of text in PDF
# and SVG files
rc = {
"xtick.labelsize": 8,
"ytick.labelsize": 8,
"axes.labelsize": 10,
"legend.fontsize": 10,
"svg.fonttype": "none"}
with plt.rc_context(rc=rc):
_plot(minlen, trunclen, plot_fn)
def _fig_size_cntx(fig, fig_size_inches, tight_layout):
"""Resize a figure in a context
Parameters
----------
fig : matplotlib.figure.Figure
The figure to resize
fig_size_inches : tuple
The (height, width) to use in the context. If None, the size
is not changed
tight_layout : boolean
When True, tight layout is used.
"""
orig_size = fig.get_size_inches()
orig_layout = fig.get_tight_layout()
if fig_size_inches is not None:
fig.set_size_inches(*fig_size_inches)
fig.set_tight_layout(tight_layout)
if tight_layout:
rc_params = {'savefig.bbox': 'tight'}
else:
rc_params = {'savefig.bbox': 'standard'}
try:
with plt.rc_context(rc_params):
yield fig
finally:
fig.set_size_inches(*orig_size)
fig.set_tight_layout(orig_layout)
def stats(input_fn, output_dir, topn=None):
if not os.path.isdir(output_dir):
raise ValueError("directory {} does not exist".format(output_dir))
len_dist_fn = os.path.join(output_dir, "stats_lendist.txt")
qual_dist_fn = os.path.join(output_dir, "stats_qualdist.txt")
qual_summ_fn = os.path.join(output_dir, "stats_qualsumm.txt")
len_dist_plot_fn = os.path.join(output_dir, "stats_lendist_plot.png")
qual_dist_plot_fn = os.path.join(output_dir, "stats_qualdist_plot.png")
qual_summ_plot_fn = os.path.join(output_dir, "stats_qualsumm_plot.png")
len_dist, qual_dist, qual_summ = _stats(input_fn=input_fn, topn=topn)
len_dist.to_csv(len_dist_fn, sep="\t", float_format="%.3f", index=False)
qual_dist.to_csv(qual_dist_fn, sep="\t", float_format="%.3f", index=False)
qual_summ.to_csv(qual_summ_fn, sep="\t", float_format="%.3f", index=False)
# custom rc. "svg.fonttype: none" corrects the conversion of text in PDF
# and SVG files
rc = {
"xtick.labelsize": 8,
"ytick.labelsize": 8,
"axes.labelsize": 10,
"legend.fontsize": 10,
"svg.fonttype": "none"}
with plt.rc_context(rc=rc):
_plot_len_dist(len_dist, len_dist_plot_fn)
_plot_qual_dist(qual_dist, qual_dist_plot_fn)
_plot_qual_summ(qual_summ, qual_summ_plot_fn)
def minorticksubplot(xminor, yminor, i):
rc = {'xtick.minor.visible': xminor,
'ytick.minor.visible': yminor}
with plt.rc_context(rc=rc):
ax = fig.add_subplot(2, 2, i)
assert (len(ax.xaxis.get_minor_ticks()) > 0) == xminor
assert (len(ax.yaxis.get_minor_ticks()) > 0) == yminor
def plot_alpha(metadata, category, hue):
import seaborn as sns
with plt.rc_context(dict(sns.axes_style("darkgrid"),
**sns.plotting_context("notebook", font_scale=2))):
width = len(metadata[category].unique())
plt.figure(figsize=(width*4, 8))
sns.boxplot(x=category, y='Alpha diversity',
data=metadata.sort(category), hue=hue, palette='cubehelix')
def test_get_color_cycle(self):
if mpl_ge_150:
colors = [(1., 0., 0.), (0, 1., 0.)]
prop_cycle = plt.cycler(color=colors)
with plt.rc_context({"axes.prop_cycle": prop_cycle}):
result = utils.get_color_cycle()
assert result == colors
def view(self, test=False):
"""Displays the graph"""
if test:
self._attr["style"] = True
AttrConf.MPL_STYLE["interactive"] = False
if self._attr["concat"]:
if self._attr["style"]:
with plt.rc_context(AttrConf.MPL_STYLE):
self._plot_concat()
else:
self._plot_concat()
else:
if self._attr["style"]:
with plt.rc_context(AttrConf.MPL_STYLE):
self._plot(self._attr["permute"])
else:
self._plot(self._attr["permute"])
def create_icon_axes(fig, ax_position, lw_bars, lw_grid, lw_border, rgrid):
"""
Create a polar axes containing the matplotlib radar plot.
Parameters
----------
fig : matplotlib.figure.Figure
The figure to draw into.
ax_position : (float, float, float, float)
The position of the created Axes in figure coordinates as
(x, y, width, height).
lw_bars : float
The linewidth of the bars.
lw_grid : float
The linewidth of the grid.
lw_border : float
The linewidth of the Axes border.
rgrid : array-like
Positions of the radial grid.
Returns
-------
ax : matplotlib.axes.Axes
The created Axes.
"""
with plt.rc_context({'axes.edgecolor': MPL_BLUE,
'axes.linewidth': lw_border}):
ax = fig.add_axes(ax_position, projection='polar')
ax.set_axisbelow(True)
N = 7
arc = 2. * np.pi
theta = np.arange(0.0, arc, arc / N)
radii = np.array([2, 6, 8, 7, 4, 5, 8])
width = np.pi / 4 * np.array([0.4, 0.4, 0.6, 0.8, 0.2, 0.5, 0.3])
bars = ax.bar(theta, radii, width=width, bottom=0.0, align='edge',
edgecolor='0.3', lw=lw_bars)
for r, bar in zip(radii, bars):
color = *cm.jet(r / 10.)[:3], 0.6 # color from jet with alpha=0.6
bar.set_facecolor(color)
ax.tick_params(labelbottom=False, labeltop=False,
labelleft=False, labelright=False)
ax.grid(lw=lw_grid, color='0.9')
ax.set_rmax(9)
ax.set_yticks(rgrid)
# the actual visible background - extends a bit beyond the axis
ax.add_patch(Rectangle((0, 0), arc, 9.58,
facecolor='white', zorder=0,
clip_on=False, in_layout=False))
return ax
def prepare(self):
sns.set_style('ticks')
sns.set_context('paper')
with plt.rc_context(plot_params):
self.fig = plt.figure(figsize=(7, 7))
gs = plt.GridSpec(3, 2)
self.ax = {
'ispectrum': self.fig.add_subplot(gs[2, :]),
'scatter': self.fig.add_subplot(gs[:2, :]),
}
# self.ax['violin'] = self.fig.add_subplot(gs[1:, -1])
self.gs = gs
def view(self, test=False):
"""Displays the graph"""
if test:
self._attr["style"] = True
AttrConf.MPL_STYLE["interactive"] = False
permute = self._attr["permute"] and not self._attr["concat"]
if self._attr["style"]:
with plt.rc_context(AttrConf.MPL_STYLE):
self._resolve(permute, self._attr["concat"])
else:
self._resolve(permute, self._attr["concat"])
def stats(input_fn, output_dir, step=100, replace=False, seed=0):
if not os.path.isdir(output_dir):
raise ValueError("directory {} does not exist".format(output_dir))
sample_summ_fn = os.path.join(output_dir, "tablestats_samplesumm.txt")
otu_summ_fn = os.path.join(output_dir, "tablestats_otusumm.txt")
rarecurve_fn = os.path.join(output_dir, "tablestats_rarecurve.txt")
rarecurve_plot_fn = os.path.join(output_dir, "tablestats_rarecurve_plot.png")
table = micca.table.read(input_fn)
# sample summary
sample_summ = pd.DataFrame({
"Depth": table.sum(),
"NOTU": (table > 0).sum(),
"NSingle": (table == 1).sum()},
columns=["Depth", "NOTU", "NSingle"])
sample_summ.index.name = "Sample"
sample_summ.sort_values(by="Depth", inplace=True)
sample_summ.to_csv(sample_summ_fn, sep='\t')
# OTU summary
otu_summ = pd.DataFrame({
"N": table.sum(axis=1),
"NSample": (table > 0).sum(axis=1)},
columns=["N", "NSample"])
otu_summ.index.name = "OTU"
otu_summ.sort_values(by="N", inplace=True, ascending=False)
otu_summ.to_csv(otu_summ_fn, sep='\t')
# rarefaction curves
rarecurve = micca.table.rarecurve(table, step=step, replace=replace,
seed=seed)
rarecurve.to_csv(rarecurve_fn, sep='\t', float_format="%.0f", na_rep="NA")
# custom rc. "svg.fonttype: none" corrects the conversion of text in PDF
# and SVG files
rc = {
"xtick.labelsize": 8,
"ytick.labelsize": 8,
"axes.labelsize": 10,
"legend.fontsize": 10,
"svg.fonttype": "none"}
with plt.rc_context(rc=rc):
fig = plt.figure(figsize=(10, 6))
plt.plot(rarecurve.index, rarecurve.to_numpy(), color="k")
plt.xlabel("Depth")
plt.ylabel("#OTUs")
fig.savefig(rarecurve_plot_fn, dpi=300, bbox_inches='tight', format="png")
def prepare(self):
sns.set_style('ticks')
sns.set_context('paper')
with plt.rc_context(plot_params):
self.fig = plt.figure(figsize=(7, 7))
gs = plt.GridSpec(3, 12)
self.ax = {
'spectrum': self.fig.add_subplot(gs[:2, 4:]),
'ISI': self.fig.add_subplot(gs[0, :4]),
'cycle': self.fig.add_subplot(gs[1, :4]),
'vs_freq': self.fig.add_subplot(gs[2, :4]),
}
self.ax['cycle_ampl'] = self.ax['cycle'].twinx()
self.ax['circ'] = self.fig.add_subplot(gs[2, 4:8])
self.ax['contrast'] = self.fig.add_subplot(gs[2, 8:])
def prepare(self):
sns.set_style('ticks')
sns.set_context('paper')
with plt.rc_context(plot_params):
self.fig = plt.figure(figsize=(7, 7))
gs = plt.GridSpec(3, 2)
self.ax = {
'scatter': self.fig.add_subplot(gs[-1, :]),
# 'spectrum': self.fig.add_subplot(gs[1:, :-1]),
'ISI': self.fig.add_subplot(gs[1, 1]),
'EOD': self.fig.add_subplot(gs[1, 0]),
}
self.ax['scatter_base'] = self.fig.add_subplot(gs[0, :])
self.ax['EOD_ampl'] = self.ax['EOD'].twinx()
self.gs = gs
def plot_dendrogram(clustering, size=10):
link = clustering['linkage']
labels = clustering['labels']
link_function, colors = get_dendrogram_color_fun(link, clustering['reorder_vec'],
labels)
# set figure properties
figsize = (size, size*.6)
with sns.axes_style('white'):
fig = plt.figure(figsize=figsize)
# **********************************
# plot dendrogram
# **********************************
with plt.rc_context({'lines.linewidth': size*.125}):
dendrogram(link, link_color_func=link_function,
orientation='top')
def plot_stacked_bar(df):
import seaborn as sns
with plt.rc_context(dict(sns.axes_style("darkgrid"),
**sns.plotting_context("notebook", font_scale=1.8))):
f, ax = plt.subplots(1, figsize=(10, 10))
x = list(range(len(df.columns)))
bottom = np.array([0] * len(df.columns))
cat_percents = []
for id_ in df.index:
color = '#' + ''.join(np.random.choice(list('ABCDEF123456789'), 6))
ax.bar(x, df.loc[id_], color=color, bottom=bottom, align='center')
bottom = df.loc[id_] + bottom
cat_percents.append(''.join(["[{0:.2f}] ".format(x) for x in df.loc[id_].tolist()]))
legend_labels = [' '.join(e) for e in zip(cat_percents, df.index.tolist())]
ax.set_xticks(x)
ax.set_xticklabels(df.columns.tolist())
ax.set_ylim([0, 1])
ax.legend(legend_labels, loc='center left', bbox_to_anchor=(1, 0.5))
def render(self):
"""
Actually render the figure.
:returns: A :mod:`matplotlib` figure object.
"""
# Use custom matplotlib context
with plt.rc_context(rc=custom_mpl.custom_rc(rc=self.custom_mpl_rc)):
# Create figure if necessary
figure, axes = self._render_grid()
# Render depending on animation type
if self.animation["type"] is False:
self._render_no_animation(axes)
elif self.animation["type"] == "gif":
self._render_gif_animation(figure, axes)
elif self.animation["type"] == "animation":
# TODO
return None
else:
return None
# Use tight_layout to optimize layout, use custom padding
figure.tight_layout(pad=1) # TODO: Messes up animations
return figure
def newton_calcula(request, form):
plt.rcParams.update(plt.rcParamsDefault)
plt.close('all')
try:
valores = form.cleaned_data # funcion y valor inicial
context = {'form': form}
starting = valores['ini']
fucn = valores['f']
x, y, z, t = sympy.symbols('x y z t')
fx = sympy.sympify(fucn)
dfdx = sympy.diff(fx, x)
e = .00001
x0 = starting
iterations = 0
delta = 1
b = 1
iteraciones_permitidas = 60
while e < delta:
r = x0 - fx.subs(x, x0) / dfdx.subs(x, x0)
delta = abs((r - x0) / r)
iterations += 1
x0 = r
if iterations > iteraciones_permitidas:
b = 0
break
except Exception:
print_exc()
return errors_view(request)
else:
fxx = sympy.lambdify(x, fx, "numpy")
nuevo = estiliza_string(fucn)
t = np.arange(r - 25, r + 25, .5)
s = []
for n in t:
s.append(float(fxx(n)))
plt.rc_context({'axes.edgecolor': 'black', 'xtick.color': 'black', 'ytick.color': 'black'})
# plt.style.use("dark_background")
fig, ax = plt.subplots()
# plt.axvline(0, color='black')
ax.axhline(0, color='gray')
ax.plot(t, s, label=f'f(x) = {nuevo}', color='#40E0D0')
ax.grid(color="gray")
if b == 1: # si se encontro corte antes de 50 iteraciones
plt.plot(r, fxx(r), marker='o', markersize=5, color="red", label=f"Corte con Eje x = {r:.4f}")
ax.set(xlabel='x', ylabel='f(x)', title=f"Raíz calculada después de {iterations} iteraciones")
else:
ax.hlines(0, 0, 0, color='r', label='No Se Encontró Corte con Eje X')
ax.set(xlabel='x', ylabel='f(x)',
title=f"No se logro encontrar raíz después de {iteraciones_permitidas} iteraciones")
plt.legend(loc='best')
buf = BytesIO()
fig.savefig(buf, format='jpg', quality=90, dpi=160, facecolor="#f3f2f1", edgecolor='#f3f2f1')
buf.seek(0)
uri = 'data:image/png;base64,' + parse.quote(b64encode(buf.read()))
context['image'] = uri
return render(request, "newton_calculado.html", context)
def visualise(X, y, Xq, fq_exp, fq_cov, noise = 1.0, n_draws = 10):
FONTSIZE = 25
FONTNAME = 'Sans Serif'
TICKSIZE = 24
mycmap = cm.get_cmap(name = 'gist_rainbow', lut = None)
rcparams = {
'backend': 'pdf',
'axes.labelsize': TICKSIZE,
'text.fontsize': FONTSIZE,
'legend.fontsize': FONTSIZE,
'xtick.labelsize': TICKSIZE,
'ytick.labelsize': TICKSIZE,
'text.usetex': True,
'axes.color_cycle': [mycmap(k) for k in np.linspace(0, 1, n_draws)]
}
plt.rc_context(rcparams)
fq_var = fq_cov.diagonal()
yq_draws = gp.draws(n_draws, fq_exp, fq_cov)
yq_var = fq_var + noise**2
yq_ub = fq_exp + 2 * yq_var
yq_lb = fq_exp - 2 * yq_var
if y.shape[0] == 0:
title = 'prior'
else:
title = 'posterior'
# Plot
fig1 = plt.figure(figsize = (8.0, 6.0))
fig2 = plt.figure(figsize = (8.0, 6.0))
ax1 = fig1.add_subplot(111)
ax2 = fig2.add_subplot(111)
ax1.plot(Xq, fq_exp, 'k-', linewidth = 2)
ax1.fill_between(Xq[:, 0], yq_ub, yq_lb, facecolor = (0.9, 0.9, 0.9), edgecolor = (0.5, 0.5, 0.5))
ax1.plot(X[:, 0], y, 'c.')
ax1.set_ylim((-3.0, 3.0))
ax1.set_xlabel('$x$', fontsize = FONTSIZE)
ax1.set_ylabel('$f(x)$', fontsize = FONTSIZE)
ax1.set_title(title, fontsize = FONTSIZE)
ax2.plot(Xq, fq_exp, 'k-', linewidth = 2)
ax2.fill_between(Xq[:, 0], yq_ub, yq_lb, facecolor = (0.9, 0.9, 0.9), edgecolor = (0.5, 0.5, 0.5))
ax2.plot(X[:, 0], y, 'c.')
for i in range(n_draws):
ax2.plot(Xq[:, 0], yq_draws[i], '--')
ax2.set_ylim((-3.0, 3.0))
ax2.set_xlabel('$x$', fontsize = FONTSIZE)
ax2.set_ylabel('$f(x)$', fontsize = FONTSIZE)
ax2.set_title(title, fontsize = FONTSIZE)
fig1.tight_layout()
fig2.tight_layout()
if y.shape[0] == 0:
fig1.savefig('bayesian_modeling/prior.eps')
fig2.savefig('bayesian_modeling/prior_draws.eps')
else:
fig1.savefig('bayesian_modeling/posterior%d.eps' % y.shape[0])
fig2.savefig('bayesian_modeling/posterior_draws%d.eps' % y.shape[0])
return np.sin(k / (N + 1) * np.pi)**2
t1 = np.linspace(-0.5, end + 1.5, 1001)
y1 = y(t1)
t2 = np.linspace(1, min(22, end), min(22, end))
y2 = y(t2)
rc = {
"xtick.direction": "inout",
"ytick.direction": "inout",
"xtick.major.size": 6,
"ytick.major.size": 6
}
with plt.rc_context(rc):
fig, ax = plt.subplots(figsize=[8, 4])
ax.grid(b=True, which='major', color='#666666', linestyle='-')
ax.grid(b=True, which='minor', color='#bbbbbb', linestyle='-')
ax.set_xticks(list(range(1, end + 3, 2)))
ax.set_yticks([0.2, 0.4, 0.6, 0.8, 1.0])
ax.plot(t1, y1, color='gray', linestyle='--')
ax.scatter(t2, y2, zorder=3, color=(0, 0.4470, 0.7410))
for i in range(1, min(22, end) + 1):
ax.vlines(i, 0, y2[i - 1], color='gray', lw=1, linestyles='dotted')
plt.xlabel('$k$')
plt.ylabel('Weighting Factor $w_k$')
arrowed_spines(fig, ax)
(DLtimestamplist[i], fstamp, tstamp)].value)
A0max.append(np.amax(bp))
A0 = A0amp * max(A0max)
tcount = 0
for tstamp in time[::tstep]:
#for tstamp in time[0:3]:
tcount = tcount + 1
bp = np.transpose(f['BeamPower/%s/%s/%s/bp' %
(DLtimestamplist[i], fstamp, tstamp)].value)
#bp to be dB
bp_dB = 10 * np.log10(bp / A0)
#print(np.amax(bp_dB))
r, theta = np.meshgrid(cvec, thetavec)
#-- Plot... ------------------------------------------------
with plt.rc_context({'ytick.color': whitecolor}):
fig, ax = plt.subplots(subplot_kw=dict(projection='polar'),
figsize=(8, 8))
levels = np.linspace(dBmin, dBmax, levelnum)
cs = ax.contourf(theta,
r,
bp_dB,
cmap=colormap,
levels=levels,
extend='both')
# plot decoration
ax.set_xticklabels(['E', '', 'N', '', 'W', '', 'S', ''])
ax.set_yticks([2, 3, 4, 5])
ax.annotate('[km/s]', (1.00, 0.701), xycoords='axes fraction')
ax.set_title('f: %4.2f [Hz] Time: %s' % (freq, tstamp), y=1.08)
cbar = fig.colorbar(cs,
#%% Plot
sns.set(font_scale=1.4, style='ticks')
rc_params = {
'font.sans-serif': "Arial", # just an example
'svg.fonttype': 'none',
}
fig, ax = plt.subplots()
g1 = sns.swarmplot(data=data,
x='compound_group',
y='novelty_score',
ax=ax,
size=10)
g1 = sns.swarmplot(data=data,
x='compound_group',
y='novelty_score',
hue='correct',
ax=ax,
size=10)
ax.get_legend().remove()
g1.axes.set_xlabel('')
g1.axes.set_ylabel('novelty score')
with plt.rc_context(rc_params):
plt.savefig('novelty_scores.pdf')
plt.savefig('novelty_scores.svg')
def test_skewt_with_grid_enabled():
"""Test using SkewT when gridlines are already enabled (#271)."""
with plt.rc_context(rc={'axes.grid': True}):
# Also tests when we don't pass in Figure
SkewT()
plot_keys = [
('RotSpeed', i_gspd, 'Generator Speed [rpm]', 1),
('BldPitch1', i_pit, 'Blade Pitch [deg]', 1),
('GenPwr', i_pow, 'Generator Power [MW]', 1e-3),
('RootMyb1', i_flp, 'Flapwise [MNm]', 1e-3),
# ('RootMEdg1', 'edge', 'Edgewise [MNm]', 1e-3),
('TwrBsMyt', i_tbfa, 'Tower Base Fore-Aft Moment [MNm]', 1e-3),
('TipDxb1', i_tipf, 'Flapwise Blade Tip Deflection [m]', 1)
]
alpha = 0.8
bd_maxwsp = 20.1 # cutoff for BeamDyn frequencies
# make figure
pltprms = {'font.size': 10, 'axes.labelsize': 10}
with plt.rc_context(pltprms):
fig, axs = plt.subplots(2, 3, num=3, figsize=(9, 4), clear=True)
# plot stuff
for i, (fastname, h2name) in enumerate(model_keys):
# make paths
h2_path = steady_dir + f'{h2name}_Steady_stats.csv'
fast_path = steady_dir + f'IEA15MW_torque_steady_{fastname}_stats.yaml'
# load data
h2_df = read_steady(h2_path)
fast_df = read_steady(fast_path)
for j, (fast_key, h2_chan, label, scl) in enumerate(plot_keys):
ax = axs[j // 3, j % 3]
# update fast_keys and scaling for beamdyn
fst_scl, h2scl = scl, scl
if 'GenPwr' in fast_key:
def boxplot(
data,
column=None,
by=None,
ax=None,
fontsize=None,
rot=0,
grid=True,
figsize=None,
layout=None,
return_type=None,
**kwds,
):
import matplotlib.pyplot as plt
# validate return_type:
if return_type not in BoxPlot._valid_return_types:
raise ValueError("return_type must be {'axes', 'dict', 'both'}")
if isinstance(data, pd.Series):
data = data.to_frame("x")
column = "x"
def _get_colors():
# num_colors=3 is required as method maybe_color_bp takes the colors
# in positions 0 and 2.
# if colors not provided, use same defaults as DataFrame.plot.box
result = get_standard_colors(num_colors=3)
result = np.take(result, [0, 0, 2])
result = np.append(result, "k")
colors = kwds.pop("color", None)
if colors:
if is_dict_like(colors):
# replace colors in result array with user-specified colors
# taken from the colors dict parameter
# "boxes" value placed in position 0, "whiskers" in 1, etc.
valid_keys = ["boxes", "whiskers", "medians", "caps"]
key_to_index = dict(zip(valid_keys, range(4)))
for key, value in colors.items():
if key in valid_keys:
result[key_to_index[key]] = value
else:
raise ValueError(
f"color dict contains invalid key '{key}'. "
f"The key must be either {valid_keys}"
)
else:
result.fill(colors)
return result
def maybe_color_bp(bp, **kwds):
# GH 30346, when users specifying those arguments explicitly, our defaults
# for these four kwargs should be overridden; if not, use Pandas settings
if not kwds.get("boxprops"):
setp(bp["boxes"], color=colors[0], alpha=1)
if not kwds.get("whiskerprops"):
setp(bp["whiskers"], color=colors[1], alpha=1)
if not kwds.get("medianprops"):
setp(bp["medians"], color=colors[2], alpha=1)
if not kwds.get("capprops"):
setp(bp["caps"], color=colors[3], alpha=1)
def plot_group(keys, values, ax: Axes, **kwds):
# GH 45465: xlabel/ylabel need to be popped out before plotting happens
xlabel, ylabel = kwds.pop("xlabel", None), kwds.pop("ylabel", None)
if xlabel:
ax.set_xlabel(pprint_thing(xlabel))
if ylabel:
ax.set_ylabel(pprint_thing(ylabel))
keys = [pprint_thing(x) for x in keys]
values = [np.asarray(remove_na_arraylike(v), dtype=object) for v in values]
bp = ax.boxplot(values, **kwds)
if fontsize is not None:
ax.tick_params(axis="both", labelsize=fontsize)
# GH 45465: x/y are flipped when "vert" changes
is_vertical = kwds.get("vert", True)
ticks = ax.get_xticks() if is_vertical else ax.get_yticks()
if len(ticks) != len(keys):
i, remainder = divmod(len(ticks), len(keys))
assert remainder == 0, remainder
keys *= i
if is_vertical:
ax.set_xticklabels(keys, rotation=rot)
else:
ax.set_yticklabels(keys, rotation=rot)
maybe_color_bp(bp, **kwds)
# Return axes in multiplot case, maybe revisit later # 985
if return_type == "dict":
return bp
elif return_type == "both":
return BoxPlot.BP(ax=ax, lines=bp)
else:
return ax
colors = _get_colors()
if column is None:
columns = None
else:
if isinstance(column, (list, tuple)):
columns = column
else:
columns = [column]
if by is not None:
# Prefer array return type for 2-D plots to match the subplot layout
# https://github.com/pandas-dev/pandas/pull/12216#issuecomment-241175580
result = _grouped_plot_by_column(
plot_group,
data,
columns=columns,
by=by,
grid=grid,
figsize=figsize,
ax=ax,
layout=layout,
return_type=return_type,
**kwds,
)
else:
if return_type is None:
return_type = "axes"
if layout is not None:
raise ValueError("The 'layout' keyword is not supported when 'by' is None")
if ax is None:
rc = {"figure.figsize": figsize} if figsize is not None else {}
with plt.rc_context(rc):
ax = plt.gca()
data = data._get_numeric_data()
naxes = len(data.columns)
if naxes == 0:
raise ValueError(
"boxplot method requires numerical columns, nothing to plot."
)
if columns is None:
columns = data.columns
else:
data = data[columns]
result = plot_group(columns, data.values.T, ax, **kwds)
ax.grid(grid)
return result
def boxplot(data, column=None, by=None, ax=None, fontsize=None,
rot=0, grid=True, figsize=None, layout=None, return_type=None,
**kwds):
# validate return_type:
if return_type not in BoxPlot._valid_return_types:
raise ValueError("return_type must be {'axes', 'dict', 'both'}")
if isinstance(data, ABCSeries):
data = data.to_frame('x')
column = 'x'
def _get_colors():
# num_colors=3 is required as method maybe_color_bp takes the colors
# in positions 0 and 2.
return _get_standard_colors(color=kwds.get('color'), num_colors=3)
def maybe_color_bp(bp):
if 'color' not in kwds:
from matplotlib.artist import setp
setp(bp['boxes'], color=colors[0], alpha=1)
setp(bp['whiskers'], color=colors[0], alpha=1)
setp(bp['medians'], color=colors[2], alpha=1)
def plot_group(keys, values, ax):
keys = [pprint_thing(x) for x in keys]
values = [np.asarray(remove_na_arraylike(v)) for v in values]
bp = ax.boxplot(values, **kwds)
if fontsize is not None:
ax.tick_params(axis='both', labelsize=fontsize)
if kwds.get('vert', 1):
ax.set_xticklabels(keys, rotation=rot)
else:
ax.set_yticklabels(keys, rotation=rot)
maybe_color_bp(bp)
# Return axes in multiplot case, maybe revisit later # 985
if return_type == 'dict':
return bp
elif return_type == 'both':
return BoxPlot.BP(ax=ax, lines=bp)
else:
return ax
colors = _get_colors()
if column is None:
columns = None
else:
if isinstance(column, (list, tuple)):
columns = column
else:
columns = [column]
if by is not None:
# Prefer array return type for 2-D plots to match the subplot layout
# https://github.com/pandas-dev/pandas/pull/12216#issuecomment-241175580
result = _grouped_plot_by_column(plot_group, data, columns=columns,
by=by, grid=grid, figsize=figsize,
ax=ax, layout=layout,
return_type=return_type)
else:
if return_type is None:
return_type = 'axes'
if layout is not None:
raise ValueError("The 'layout' keyword is not supported when "
"'by' is None")
if ax is None:
rc = {'figure.figsize': figsize} if figsize is not None else {}
with plt.rc_context(rc):
ax = plt.gca()
data = data._get_numeric_data()
if columns is None:
columns = data.columns
else:
data = data[columns]
result = plot_group(columns, data.values.T, ax)
ax.grid(grid)
return result
import matplotlib
matplotlib.use('svg')
import matplotlib.pyplot as plt
import pandas as pd
import constants as c
import plotting
if __name__ == '__main__':
samples = pd.read_pickle(
os.path.join(c.Paths.output, 'ex_2_11', 'samples.pkl'))
results = pd.read_pickle(
os.path.join(c.Paths.output, 'ex_2_11', 'results.pkl'))
with plt.rc_context(plotting.rc()):
fig, ax = plt.subplots(1)
samples.plot(ax=ax)
ax.legend(title='Actions', bbox_to_anchor=(1, 1), loc='upper left')
ax.grid(alpha=0.25)
ax.set_xlabel('$t$')
ax.set_ylabel('Action Values')
ax.set_title('True Action Values on 10-Armed Bandit')
# plt.tight_layout()
fig.savefig(os.path.join(c.Paths.output, 'ex_2_11',
'action_values.png'),
bbox_inches='tight')
fig, ax = plt.subplots(1)
results.plot(ax=ax)
ax.set_xscale('log', basex=2)
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(5)
fig = plt.figure(figsize=(6, 3))
fig.subplots_adjust(bottom=0.15, wspace=0.3, left=0.09, right=0.95)
x = np.linspace(2000, 2008, 9)
y = np.random.randn(9) + 50000
with plt.rc_context(rc={'axes.formatter.offset_threshold' : 2}):
ax1 = fig.add_subplot(1, 2, 1)
ax1.plot(x, y)
ax1.set_title('classic')
ax2 = fig.add_subplot(1, 2, 2)
ax2.plot(x, y)
ax2.set_title('v2.0')
def _i_mtv(self, data, wcs, title, isMask):
"""Internal routine to display an Image or Mask on a DS9 display"""
title = str(title) if title else ""
dataArr = data.getArray()
if isMask:
maskPlanes = data.getMaskPlaneDict()
nMaskPlanes = max(maskPlanes.values()) + 1
planes = {} # build inverse dictionary
for key in maskPlanes:
planes[maskPlanes[key]] = key
planeList = range(nMaskPlanes)
maskArr = np.zeros_like(dataArr, dtype=np.int32)
colorNames = ['black']
colorGenerator = self.display.maskColorGenerator(omitBW=True)
for p in planeList:
color = self.display.getMaskPlaneColor(
planes[p]) if p in planes else None
if not color: # none was specified
color = next(colorGenerator)
elif color.lower() == afwDisplay.IGNORE:
color = 'black' # we'll set alpha = 0 anyway
colorNames.append(color)
#
# Convert those colours to RGBA so we can have per-mask-plane transparency
# and build a colour map
#
# Pixels equal to 0 don't get set (as no bits are set), so leave them transparent
# and start our colours at [1] -- hence "i + 1" below
#
colors = mpColors.to_rgba_array(colorNames)
alphaChannel = 3 # the alpha channel; the A in RGBA
colors[0][alphaChannel] = 0.0 # it's black anyway
for i, p in enumerate(planeList):
if colorNames[i + 1] == 'black':
alpha = 0.0
else:
alpha = 1 - self._getMaskTransparency(planes[p] if p in
planes else None)
colors[i + 1][alphaChannel] = alpha
cmap = mpColors.ListedColormap(colors)
norm = mpColors.NoNorm()
else:
cmap = self._image_colormap
norm = self._normalize
ax = self._figure.gca()
bbox = data.getBBox()
extent = (bbox.getBeginX() - 0.5, bbox.getEndX() - 0.5,
bbox.getBeginY() - 0.5, bbox.getEndY() - 0.5)
with pyplot.rc_context(dict(interactive=False)):
if isMask:
for i, p in reversed(list(enumerate(planeList))):
if colors[i +
1][alphaChannel] == 0: # colors[0] is reserved
continue
bitIsSet = (dataArr & (1 << p)) != 0
if bitIsSet.sum() == 0:
continue
maskArr[
bitIsSet] = i + 1 # + 1 as we set colorNames[0] to black
if not self._fastMaskDisplay: # we draw each bitplane separately
ax.imshow(maskArr,
origin='lower',
interpolation='nearest',
extent=extent,
cmap=cmap,
norm=norm)
maskArr[:] = 0
if self._fastMaskDisplay: # we only draw the lowest bitplane
ax.imshow(maskArr,
origin='lower',
interpolation='nearest',
extent=extent,
cmap=cmap,
norm=norm)
else:
mappable = ax.imshow(dataArr,
origin='lower',
interpolation='nearest',
extent=extent,
cmap=cmap,
norm=norm)
self._mappable = mappable
self._figure.canvas.draw_idle()
def plot_return_value_stability(
ts: pd.Series,
return_period,
return_period_size: typing.Union[str, pd.Timedelta] = "1Y",
thresholds=None,
r: typing.Union[str, pd.Timedelta] = "24H",
extremes_type: str = "high",
distributions: typing.List[typing.Union[str,
scipy.stats.rv_continuous]] = [
"genpareto",
"expon",
],
alpha: typing.Optional[float] = None,
n_samples: int = 100,
figsize: tuple = (8, 5),
) -> tuple: # pragma: no cover
"""
Plot return value stability plot for given threshold values.
The return value stability plot shows return values for given return period
for given thresholds.
The purpose of this plot is to investigate statibility and sensitivity of the
Generalized Pareto Distribution model to threshold value.
Threshold value selection should still be guided by the mean residual life plot
and the parameter stability plot. This plot should be used as additional check.
Parameters
----------
ts : pandas.Series
Time series of the signal.
return_period : number
Return period.
Given as a multiple of `return_period_size`.
return_period_size : str or pandas.Timedelta, optional
Size of return period (default='1Y').
If set to '30D', then a return period of 12
would be roughly equivalent to a 1 year return period (360 days).
thresholds : array-like, optional
An array of thresholds for which the mean residual life plot is plotted.
If None (default), plots mean residual life for 100 equally-spaced thresholds
between 90th (10th if extremes_type='low') percentile
and 10th largest (smallest if extremes_type='low') value in the series.
r : str or pandas.Timedelta, optional
Duration of window used to decluster the exceedances.
By default r='24H' (24 hours).
extremes_type : str, optional
high (default) - extreme high values
low - extreme low values
distributions : list, optional
List of distributions for which the return value curves are plotted.
By default these are "genpareto" and "expon".
A distribution must be either a name of distribution from with scipy.stats
or a subclass of scipy.stats.rv_continuous.
See https://docs.scipy.org/doc/scipy/reference/stats.html
alpha : float, optional
Confidence interval width in the range (0, 1).
If None (default), then confidence interval is not shown.
n_samples : int, optional
Number of bootstrap samples used to estimate
confidence interval bounds (default=100).
Ignored if `alpha` is None.
figsize : tuple, optional
Figure size in inches in format (width, height).
By default it is (8, 5).
Returns
-------
figure : matplotlib.figure.Figure
Figure object.
axes : matplotlib.axes._axes.Axes
Axes object.
"""
# Get default thresholds
if thresholds is None:
thresholds = get_default_thresholds(
ts=ts,
extremes_type=extremes_type,
num=100,
)
# Instantiate model
model = EVA(data=ts)
# Calculate return values for each threshold and distribution
return_values: typing.Dict[str, typing.List[float]] = {}
ci_lower: typing.Dict[str, typing.List[float]] = {}
ci_upper: typing.Dict[str, typing.List[float]] = {}
for distribution in distributions:
for threshold in thresholds:
model.get_extremes(
method="POT",
extremes_type=extremes_type,
threshold=threshold,
r=r,
)
model.fit_model(
model="MLE",
distribution=distribution,
)
rv, cil, ciu = model.get_return_value(
return_period=return_period,
return_period_size=return_period_size,
alpha=alpha,
n_samples=n_samples,
)
try:
return_values[distribution].append(rv)
ci_lower[distribution].append(cil)
ci_upper[distribution].append(ciu)
except KeyError:
return_values[distribution] = [rv]
ci_lower[distribution] = [cil]
ci_upper[distribution] = [ciu]
with plt.rc_context(rc=pyextremes_rc):
# Create figure and axes
fig, ax = plt.subplots(figsize=figsize, dpi=96)
ax.grid(False)
# Plot central estimate of return values
for i, distribution in enumerate(distributions):
color = pyextremes_rc["axes.prop_cycle"].by_key()["color"][i]
ax.plot(
thresholds,
return_values[distribution],
color=color,
lw=2,
ls="-",
label=distribution,
zorder=(i + 3) * 5,
)
# Plot confidence bounds
if alpha is not None:
for ci in [ci_lower[distribution], ci_upper[distribution]]:
ax.plot(
thresholds,
ci,
color=color,
lw=1,
ls="--",
zorder=(i + 2) * 5,
)
ax.fill_between(
thresholds,
ci_lower[distribution],
ci_upper[distribution],
facecolor=color,
edgecolor="None",
alpha=0.25,
zorder=(i + 1) * 5,
)
# Plot legend
ax.legend(
frameon=True,
framealpha=0.9,
)
# Label axes
ax.set_xlabel("Threshold")
ax.set_ylabel("Return value")
return fig, ax
plt.figure()
plt.scatter(sepal_length,
sepal_width,
s=100 * petal_width,
c=df["colors"],
alpha=0.2)
plt.xlabel("longueur des sépales [cm]")
plt.ylabel("largeur des sépales [cm]")
# Création d'une légende à partir d'un scatter plot vide
for i, v in enumerate(variety.unique()):
plt.scatter([], [], c="C{}".format(i), alpha=0.2, label=v)
plt.legend()
# Changement de taille de police uniquement pour cette figure
with plt.rc_context({"font.size": 5}):
# Définition d'une grille de sous-figures
fig, ax = plt.subplots(len(labels),
len(labels),
sharex="col",
sharey="row",
figsize=(1.5 * len(labels), 1.5 * len(labels)))
for l1, d1 in labels.items():
i1 = list(labels.keys()).index(l1)
for l2, d2 in labels.items():
i2 = list(labels.keys()).index(l2)
for v in variety.unique():
sc = (variety == v)
if l1 == l2:
ax[i1, i2].hist(d1[sc], alpha=0.5, bins=10, density=True)
def plot_dendrogram(loading, clustering, title=None,
break_lines=True, drop_list=None, double_drop_list=None,
absolute_loading=False, size=4.6, dpi=300,
filename=None):
""" Plots HCA results as dendrogram with loadings underneath
Args:
loading: pandas df, a results EFA loading matrix
clustering: pandas df, a results HCA clustering
title (optional): str, title to plot
break_lines: whether to separate EFA heatmap based on clusters, default=True
drop_list (optional): list of cluster indices to drop the cluster label
drop_list (optional): list of cluster indices to drop the cluster label twice
absolute_loading: whether to plot the absolute loading value, default False
plot_dir: if set, where to save the plot
"""
c = loading.shape[1]
# extract cluster vars
link = clustering['linkage']
DVs = clustering['clustered_df'].columns
ordered_loading = loading.loc[DVs]
if absolute_loading:
ordered_loading = abs(ordered_loading)
# get cluster sizes
labels=clustering['labels']
cluster_sizes = [np.sum(labels==(i+1)) for i in range(max(labels))]
link_function, colors = get_dendrogram_color_fun(link, clustering['reorder_vec'],
labels)
# set figure properties
figsize = (size, size*.6)
# set up axes' size
heatmap_height = ordered_loading.shape[1]*.035
heat_size = [.1, heatmap_height]
dendro_size=[np.sum(heat_size), .3]
# set up plot axes
dendro_size = [.15,dendro_size[0], .78, dendro_size[1]]
heatmap_size = [.15,heat_size[0],.78,heat_size[1]]
cbar_size = [.935,heat_size[0],.015,heat_size[1]]
ordered_loading = ordered_loading.T
with sns.axes_style('white'):
fig = plt.figure(figsize=figsize)
ax1 = fig.add_axes(dendro_size)
# **********************************
# plot dendrogram
# **********************************
with plt.rc_context({'lines.linewidth': size*.125}):
dendrogram(link, ax=ax1, link_color_func=link_function,
orientation='top')
# change axis properties
ax1.tick_params(axis='x', which='major', labelsize=14,
labelbottom=False)
ax1.get_yaxis().set_visible(False)
ax1.spines['top'].set_visible(False)
ax1.spines['right'].set_visible(False)
ax1.spines['bottom'].set_visible(False)
ax1.spines['left'].set_visible(False)
# **********************************
# plot loadings as heatmap below
# **********************************
ax2 = fig.add_axes(heatmap_size)
cbar_ax = fig.add_axes(cbar_size)
max_val = np.max(abs(loading.values))
# bring to closest .25
max_val = ceil(max_val*4)/4
sns.heatmap(ordered_loading, ax=ax2,
cbar=True, cbar_ax=cbar_ax,
yticklabels=True,
xticklabels=True,
vmax = max_val, vmin = -max_val,
cbar_kws={'orientation': 'vertical',
'ticks': [-max_val, 0, max_val]},
cmap=sns.diverging_palette(220,15,n=100,as_cmap=True))
ax2.set_yticklabels(ax2.get_yticklabels(), rotation=0)
ax2.tick_params(axis='y', labelsize=size*heat_size[1]*30/c, pad=size/4, length=0)
# format cbar axis
cbar_ax.set_yticklabels([format_num(-max_val), 0, format_num(max_val)])
cbar_ax.tick_params(labelsize=size*heat_size[1]*25/c, length=0, pad=size/2)
cbar_ax.set_ylabel('Factor Loading', rotation=-90,
fontsize=size*heat_size[1]*30/c, labelpad=size*2)
# add lines to heatmap to distinguish clusters
if break_lines == True:
xlim = ax2.get_xlim();
ylim = ax2.get_ylim()
step = xlim[1]/len(labels)
cluster_breaks = [i*step for i in np.cumsum(cluster_sizes)]
ax2.vlines(cluster_breaks[:-1], ylim[0], ylim[1], linestyles='dashed',
linewidth=size*.1, colors=[.5,.5,.5], zorder=10)
# **********************************
# plot cluster names
# **********************************
beginnings = np.hstack([[0],np.cumsum(cluster_sizes)[:-1]])
centers = beginnings+np.array(cluster_sizes)//2+.5
offset = .07
if 'cluster_names' in clustering.keys():
ax2.tick_params(axis='x', reset=True, top=False, bottom=False, width=size/8, length=0)
names = [transform_name(i) for i in clustering['cluster_names']]
ax2.set_xticks(centers)
ax2.set_xticklabels(names, rotation=0, ha='center',
fontsize=heatmap_size[2]*size*1)
ticks = ax2.xaxis.get_ticklines()[::2]
for i, label in enumerate(ax2.get_xticklabels()):
if label.get_text() != '':
ax2.hlines(c+offset,beginnings[i]+.5,beginnings[i]+cluster_sizes[i]-.5,
clip_on=False, color=colors[i], linewidth=size/5)
label.set_color(colors[i])
ticks[i].set_color(colors[i])
y_drop = .005
line_drop = .3
if drop_list and i in drop_list:
y_drop = .05
line_drop = 1.6
if double_drop_list and i in double_drop_list:
y_drop = .1
line_drop = 2.9
label.set_y(-(y_drop/heatmap_height+heatmap_height/c*offset))
ax2.vlines(beginnings[i]+cluster_sizes[i]/2,
c+offset, c+offset+line_drop,
clip_on=False, color=colors[i],
linewidth=size/7.5)
# add title
if title:
ax1.set_title(title, fontsize=size*2, y=1.05)
if filename is not None:
save_figure(fig, filename,
{'bbox_inches': 'tight', 'dpi': dpi})
plt.close()
else:
return fig
def boxplot(
data,
column=None,
by=None,
ax=None,
fontsize=None,
rot=0,
grid=True,
figsize=None,
layout=None,
return_type=None,
**kwds,
):
import matplotlib.pyplot as plt
# validate return_type:
if return_type not in BoxPlot._valid_return_types:
raise ValueError("return_type must be {'axes', 'dict', 'both'}")
if isinstance(data, ABCSeries):
data = data.to_frame("x")
column = "x"
def _get_colors():
# num_colors=3 is required as method maybe_color_bp takes the colors
# in positions 0 and 2.
# if colors not provided, use same defaults as DataFrame.plot.box
result = _get_standard_colors(num_colors=3)
result = np.take(result, [0, 0, 2])
result = np.append(result, "k")
colors = kwds.pop("font", None)
if colors:
if is_dict_like(colors):
# replace colors in result array with user-specified colors
# taken from the colors dict parameter
# "boxes" value placed in position 0, "whiskers" in 1, etc.
valid_keys = ["boxes", "whiskers", "medians", "caps"]
key_to_index = dict(zip(valid_keys, range(4)))
for key, value in colors.items():
if key in valid_keys:
result[key_to_index[key]] = value
else:
raise ValueError(
f"font dict contains invalid key '{key}'. "
f"The key must be either {valid_keys}")
else:
result.fill(colors)
return result
def maybe_color_bp(bp):
setp(bp["boxes"], color=colors[0], alpha=1)
setp(bp["whiskers"], color=colors[1], alpha=1)
setp(bp["medians"], color=colors[2], alpha=1)
setp(bp["caps"], color=colors[3], alpha=1)
def plot_group(keys, values, ax):
keys = [pprint_thing(x) for x in keys]
values = [np.asarray(remove_na_arraylike(v)) for v in values]
bp = ax.boxplot(values, **kwds)
if fontsize is not None:
ax.tick_params(axis="both", labelsize=fontsize)
if kwds.get("vert", 1):
ax.set_xticklabels(keys, rotation=rot)
else:
ax.set_yticklabels(keys, rotation=rot)
maybe_color_bp(bp)
# Return axes in multiplot case, maybe revisit later # 985
if return_type == "dict":
return bp
elif return_type == "both":
return BoxPlot.BP(ax=ax, lines=bp)
else:
return ax
colors = _get_colors()
if column is None:
columns = None
else:
if isinstance(column, (list, tuple)):
columns = column
else:
columns = [column]
if by is not None:
# Prefer array return type for 2-D plots to match the subplot layout
# https://github.com/pandas-dev/pandas/pull/12216#issuecomment-241175580
result = _grouped_plot_by_column(
plot_group,
data,
columns=columns,
by=by,
grid=grid,
figsize=figsize,
ax=ax,
layout=layout,
return_type=return_type,
)
else:
if return_type is None:
return_type = "axes"
if layout is not None:
raise ValueError(
"The 'layout' keyword is not supported when 'by' is None")
if ax is None:
rc = {"figure.figsize": figsize} if figsize is not None else {}
with plt.rc_context(rc):
ax = plt.gca()
data = data._get_numeric_data()
if columns is None:
columns = data.columns
else:
data = data[columns]
result = plot_group(columns, data.values.T, ax)
ax.grid(grid)
return result
def plot_fluxnet_comparison_one_site(driver, science_test_data_dir,
compare_data_dict, result_dir, plot_dir,
plots_to_make, context, style, var_names,
months, obs_dir, subdir):
if check_site_files(obs_dir, subdir):
# get CSV file from site directory to get lat/lng for site
lat, lng = get_fluxnet_lat_lon(obs_dir, subdir)
print(lat, lng)
# loop over data to compare
data = {}
for key, items in compare_data_dict.items():
if key == "ecflux":
try:
# load Ameriflux data
data[key] = read_fluxnet_obs(subdir,
science_test_data_dir,
items)
except OSError:
warnings.warn(
"this %s site does not have data" % subdir)
elif key == "VIC.4.2.d":
try:
# load VIC 4.2 simulations
data[key] = read_vic_42_output(lat, lng,
science_test_data_dir,
items)
except OSError:
warnings.warn(
"this site has a lat/lng precision issue")
else:
try:
# load VIC 5 simulations
data[key] = read_vic_5_output(lat, lng,
result_dir,
items)
except OSError:
warnings.warn(
"this site has a lat/lng precision issue")
# make figures
# plot preferences
fs = 15
dpi = 150
if 'annual_mean_diurnal_cycle' in plots_to_make:
# make annual mean diurnal cycle plots
with plt.rc_context(dict(sns.axes_style(style),
**sns.plotting_context(context))):
f, axarr = plt.subplots(4, 1, figsize=(8, 8), sharex=True)
for i, (vic_var, variable_name) in enumerate(
var_names.items()):
# calculate annual mean diurnal cycle for each
# DataFrame
annual_mean = {}
for key, df in data.items():
annual_mean[key] = pd.DataFrame(
df[vic_var].groupby(df.index.hour).mean())
df = pd.DataFrame(
{key: d[vic_var] for key, d in annual_mean.items()
if vic_var in d})
for key, series in df.iteritems():
series.plot(
linewidth=compare_data_dict[key]['linewidth'],
ax=axarr[i],
color=compare_data_dict[key]['color'],
linestyle=compare_data_dict[key]['linestyle'],
zorder=compare_data_dict[key]['zorder'])
axarr[i].legend(loc='upper left')
axarr[i].set_ylabel(
'%s ($W/{m^2}$)' % variable_name,
size=fs)
axarr[i].set_xlabel('Time of Day (Hour)', size=fs)
axarr[i].set_xlim([0, 24])
axarr[i].xaxis.set_ticks(np.arange(0, 24, 3))
# save plot
plotname = '%s_%s.png' % (lat, lng)
os.makedirs(os.path.join(plot_dir, 'annual_mean'),
exist_ok=True)
savepath = os.path.join(plot_dir, 'annual_mean', plotname)
plt.savefig(savepath, bbox_inches='tight', dpi=dpi)
plt.clf()
plt.close()
if 'monthly_mean_diurnal_cycle' in plots_to_make:
# make monthly mean diurnal cycle plots
with plt.rc_context(dict(sns.axes_style(style),
**sns.plotting_context(context))):
f, axarr = plt.subplots(4, 12, figsize=(35, 7),
sharex=True,
sharey=True)
for i, (vic_var, variable_name) in enumerate(
var_names.items()):
# calculate monthly mean diurnal cycle
monthly_mean = {}
for (key, df) in data.items():
monthly_mean[key] = pd.DataFrame(
df[vic_var].groupby([df.index.month,
df.index.hour]).mean())
df = pd.DataFrame(
{key: d[vic_var] for key, d in monthly_mean.items()
if vic_var in d})
for j, month in enumerate(months):
for key, series in df.iteritems():
series[j + 1].plot(
linewidth=compare_data_dict[key]['linewidth'],
ax=axarr[i, j],
color=compare_data_dict[key]['color'],
linestyle=compare_data_dict[key]['linestyle'],
zorder=compare_data_dict[key]['zorder'])
axarr[i, j].set_ylabel(
'%s \n ($W/{m^2}$)' % variable_name,
size=fs)
axarr[i, j].set_xlabel('', size=fs)
axarr[i, j].set_xlim([0, 24])
axarr[i, j].xaxis.set_ticks(np.arange(0, 24, 3))
if i == 0:
axarr[i, j].set_title(month, size=fs)
# add legend
axarr[0, -1].legend(loc='center left',
bbox_to_anchor=(1, 0.5))
# add common x label
f.text(0.5, 0.04, 'Time of Day (Hour)', ha='center',
size=fs)
# save plot
plotname = '%s_%s.png' % (lat, lng)
os.makedirs(os.path.join(plot_dir, 'monthly_mean'),
exist_ok=True)
savepath = os.path.join(plot_dir,
'monthly_mean', plotname)
plt.savefig(savepath, bbox_inches='tight', dpi=dpi)
plt.clf()
plt.close()
def fancy_show_stars(
image,
stars,
ref_stars=None,
target=None,
size=15,
pixel_scale=None,
contrast=0.05,
aperture=None,
marker_color=np.array([131, 220, 255]) / 255,
proper_motion=False,
n_stars=None,
flip=False,
view="all",
zoom=True,
options={},
):
"""
Plot stack image and detected stars
Parameters
----------
size: float (optional)
pyplot figure (size, size)
image: int (optional)
index of image to plot in light files. Default is None, which show stack image
contrast: float
contrast within [0, 1] (zscale is applied here)
marker_color: [r, g, b]
proper_motion: bool
whether to display proper motion on the image
n_stars: int
max number of stars to show
flip: bool
flip image
view: 'all', 'reference'
- ``reference`` : only highlight target and comparison stars
- ``all`` : all stars are shown
zoom: bool
whether to include a zoom view
options: dict
style options:
- to do
Examples
--------
.. code-block:: python3
from specphot.observations import Photometry
phot = Photometry("your_path")
phot.plot_stars(view="reference")
.. image:: /user_guide/gallery/plot_stars.png
:align: center
"""
_options = {
"aperture_color": "seagreen",
"aperture_ls": "--"
}
_options.update(options)
marker_size = 9
if isinstance(image, str):
image = fits.getdata(image)
image_size = np.array(np.shape(image))[::-1]
fig = plt.figure(figsize=(size, size))
if flip:
image = utils.z_scale(image, c=contrast)[::-1, ::-1]
stars = np.array(image_size) - stars
else:
image = utils.z_scale(image, c=contrast)
ax = fig.add_subplot(111)
ax.imshow(image, cmap="Greys_r")
plt.title("Stack image", loc="left")
size_factor = size / 15
fontsize = min(size_factor, 1) * 15
label_yoffset = min(size_factor, 1) * 30
if view == "all":
for i, coord in enumerate(stars):
circle = mpatches.Circle(coord, marker_size, fill=None, ec=marker_color, )
ax = plt.gca()
ax.add_artist(circle)
plt.annotate(str(i),
xy=[coord[0], coord[1] + marker_size+1],
color=marker_color,
ha='center', fontsize=12, va='top')
if ref_stars is not None:
circle = mpatches.Circle(stars[target, :], marker_size, fill=None, ec=marker_color, label="target")
ax = plt.gca()
ax.add_artist(circle)
plt.annotate(target, xy=[stars[target][0], stars[target][1] + marker_size+1],
color=marker_color, ha='center', fontsize=12, va='top')
plt.imshow(image, cmap="Greys_r")
for i in ref_stars:
circle = mpatches.Circle(stars[i, :], marker_size, fill=None, ec="yellow", label="comparison")
ax.add_artist(circle)
plt.annotate(str(i), xy=[stars[i][0], stars[i][1] + marker_size+1], color="yellow",
fontsize=12,
ha='center',
va='top')
other_stars = np.arange(len(stars))
other_stars = np.setdiff1d(other_stars, target)
other_stars = np.setdiff1d(other_stars, ref_stars)
for i in other_stars:
circle = mpatches.Circle(stars[i, :], marker_size, fill=None, ec=marker_color, label="comparison",
alpha=0.4)
ax.add_artist(circle)
plt.tight_layout()
if pixel_scale is not None:
ob = AnchoredHScaleBar(size=60 / pixel_scale, label="1'", loc=4, frameon=False, extent=0,
pad=0.6, sep=4, linekw=dict(color="white", linewidth=0.8))
ax.add_artist(ob)
if target is not None and zoom:
with plt.rc_context({
'axes.edgecolor': "white",
'xtick.color': "white",
'ytick.color': "white"
}):
x, y = stars[target]
rect = patches.Rectangle(
(x - 80, y - 80),
160, 160, linewidth=1,
edgecolor='white',
facecolor='none',
alpha=0.3)
ax.add_patch(rect)
axins = zoomed_inset_axes(ax, 2.5, loc=1)
axins.imshow(image, cmap="Greys_r", origin="upper")
if aperture is not None:
ap = aperture / 2
aperture = patches.Circle(
(x, y),
ap, linewidth=1,
ls=_options["aperture_ls"],
edgecolor=_options["aperture_color"],
facecolor='none',
alpha=1)
axins.add_patch(aperture)
axins.set_xlim([x - 80, x + 80])
axins.set_ylim([y + 80, y - 80])
if pixel_scale is not None:
obin = AnchoredHScaleBar(size=15 / pixel_scale, label="15\"", loc=4,
frameon=False, extent=0, pad=0.6, sep=4,
linekw=dict(color="white", linewidth=0.8))
axins.add_artist(obin)
return fig
exp._set_labels_and_prepare_data(label_assoc, labels, sample_assoc)
exp._set_data_and_labels_for_examples(logger.get_value('examples'))
labels = exp.labels # Get subset of labels without examples
learner = exp._get_new_learner()
learner.dico = logger.get_last_value('dictionary')
data = exp.data
# Compute coefficients from data
print("Re-computing internal coefficients...")
internal = learner.reconstruct_internal_multi(exp.modalities,
data,
exp.iter_test)
# Compute mutual information for each pair of coef and label
n_labels = len(label_assoc[0])
by_label = organize_by_values(labels, nb_values=n_labels)
mutual_information_matrices.append(np.array([
mutual_information_by_label(internal[:, i], by_label)
for i in range(K)
]).T)
# Each matrix is of dim (K x n_labels)
# Plot result to disk
with plt.rc_context(rc=DEFAULT_PLOT_PARAMS):
plt.interactive(False)
fig = plt.figure()
sound_labels = label_assoc[exp.modalities.index("sound")]
plot_mutual_info(mutual_information_matrices[-1], sound_labels)
for ext in ['svg', 'pdf', 'eps']:
path = os.path.join(DEFAULT_FIG_DEST,
'mutual_info_{}.{}'.format(exp_idx, ext))
fig.savefig(path, transparent=True)
print('Written: {}.'.format(path))
def _do_plot(self):
self._do_compute()
with plt.rc_context({'axes.edgecolor': 'gray'}):
self._plot_spikes_in_feature_space_multi(
self._spike_waveforms_list, self._opts)
def draw_termite_plot(
values_mat,
col_labels,
row_labels,
*,
highlight_cols=None,
highlight_colors=None,
save=False,
rc_params=None,
):
"""
Make a "termite" plot, typically used for assessing topic models with a tabular
layout that promotes comparison of terms both within and across topics.
Args:
values_mat (:class:`np.ndarray` or matrix): matrix of values with shape
(# row labels, # col labels) used to size the dots on the grid
col_labels (seq[str]): labels used to identify x-axis ticks on the grid
row_labels(seq[str]): labels used to identify y-axis ticks on the grid
highlight_cols (int or seq[int], optional): indices for columns
to visually highlight in the plot with contrasting colors
highlight_colors (tuple of 2-tuples): each 2-tuple corresponds to a pair
of (light/dark) matplotlib-friendly colors used to highlight a single
column; if not specified (default), a good set of 6 pairs are used
save (str, optional): give the full /path/to/fname on disk to save figure
rc_params (dict, optional): allow passing parameters to rc_context in matplotlib.plyplot,
details in https://matplotlib.org/3.1.0/api/_as_gen/matplotlib.pyplot.rc_context.html
Returns:
:obj:`matplotlib.axes.Axes.axis`: Axis on which termite plot is plotted.
Raises:
ValueError: if more columns are selected for highlighting than colors
or if any of the inputs' dimensions don't match
References:
Chuang, Jason, Christopher D. Manning, and Jeffrey Heer. "Termite:
Visualization techniques for assessing textual topic models."
Proceedings of the International Working Conference on Advanced
Visual Interfaces. ACM, 2012.
See Also:
:meth:`TopicModel.termite_plot() <textacy.tm.topic_model.TopicModel.termite_plot>`
"""
try:
plt
except NameError:
raise ImportError(
"`matplotlib` is not installed, so `textacy.viz` won't work; "
"install it individually via `$ pip install matplotlib`, or "
"along with textacy via `pip install textacy[viz]`.")
n_rows, n_cols = values_mat.shape
max_val = np.max(values_mat)
if n_rows != len(row_labels):
msg = "values_mat and row_labels dimensions don't match: {} vs. {}".format(
n_rows, len(row_labels))
raise ValueError(msg)
if n_cols != len(col_labels):
msg = "values_mat and col_labels dimensions don't match: {} vs. {}".format(
n_cols, len(col_labels))
raise ValueError(msg)
if highlight_colors is None:
highlight_colors = COLOR_PAIRS
if highlight_cols is not None:
if isinstance(highlight_cols, int):
highlight_cols = (highlight_cols, )
elif len(highlight_cols) > len(highlight_colors):
msg = "no more than {} columns may be highlighted at once".format(
len(highlight_colors))
raise ValueError(msg)
highlight_colors = {
hc: COLOR_PAIRS[i]
for i, hc in enumerate(highlight_cols)
}
_rc_params = RC_PARAMS.copy()
if rc_params:
_rc_params.update(rc_params)
with plt.rc_context(RC_PARAMS):
fig, ax = plt.subplots(figsize=(pow(n_cols, 0.8), pow(n_rows, 0.66)))
_ = ax.set_yticks(range(n_rows))
yticklabels = ax.set_yticklabels(row_labels, fontsize=14, color="gray")
if highlight_cols is not None:
for i, ticklabel in enumerate(yticklabels):
max_tick_val = max(values_mat[i, hc] for hc in range(n_cols))
for hc in highlight_cols:
if max_tick_val > 0 and values_mat[i, hc] == max_tick_val:
ticklabel.set_color(highlight_colors[hc][1])
ax.get_xaxis().set_ticks_position("top")
_ = ax.set_xticks(range(n_cols))
xticklabels = ax.set_xticklabels(col_labels,
fontsize=14,
color="gray",
rotation=-60,
ha="right")
# Create offset transform by 5 points in x direction
dx = 10 / 72
dy = 0
offset = matplotlib.transforms.ScaledTranslation(
dx, dy, fig.dpi_scale_trans)
for label in ax.xaxis.get_majorticklabels():
label.set_transform(label.get_transform() + offset)
if highlight_cols is not None:
gridlines = ax.get_xgridlines()
for i, ticklabel in enumerate(xticklabels):
if i in highlight_cols:
ticklabel.set_color(highlight_colors[i][1])
gridlines[i].set_color(highlight_colors[i][0])
gridlines[i].set_alpha(0.5)
for col_ind in range(n_cols):
if highlight_cols is not None and col_ind in highlight_cols:
ax.scatter(
[col_ind for _ in range(n_rows)],
[i for i in range(n_rows)],
s=600 * (values_mat[:, col_ind] / max_val),
alpha=0.5,
linewidth=1,
color=highlight_colors[col_ind][0],
edgecolor=highlight_colors[col_ind][1],
)
else:
ax.scatter(
[col_ind for _ in range(n_rows)],
[i for i in range(n_rows)],
s=600 * (values_mat[:, col_ind] / max_val),
alpha=0.5,
linewidth=1,
color="lightgray",
edgecolor="gray",
)
_ = ax.set_xlim(left=-1, right=n_cols)
_ = ax.set_ylim(bottom=-1, top=n_rows)
ax.invert_yaxis() # otherwise, values/labels go from bottom to top
if save:
fig.savefig(save, bbox_inches="tight", dpi=100)
return ax
def plot_mean_residual_life(
ts: pd.Series,
thresholds=None,
extremes_type: str = "high",
alpha: float = 0.95,
figsize: tuple = (8, 5),
) -> tuple: # pragma: no cover
"""
Plot mean residual life for given threshold values.
The mean residual life plot should be approximately linear above a threshold
for which the Generalized Pareto Distribution model is valid.
The strategy is to select the smallest (largest for extremes_type='low')
threshold value immediately above (below for extremes_type='low')
which the plot is approximately linear.
Parameters
----------
ts : pandas.Series
Time series of the signal.
thresholds : array-like, optional
An array of thresholds for which the mean residual life plot is plotted.
If None (default), plots mean residual life for 100 equally-spaced thresholds
between 90th (10th if extremes_type='low') percentile
and 10th largest (smallest if extremes_type='low') value in the series.
extremes_type : str, optional
high (default) - extreme high values
low - extreme low values
alpha : float, optional
Confidence interval width in the range (0, 1), by default it is 0.95.
If None, then confidence interval is not shown.
figsize : tuple, optional
Figure size in inches in format (width, height).
By default it is (8, 5).
Returns
-------
figure : matplotlib.figure.Figure
Figure object.
axes : matplotlib.axes._axes.Axes
Axes object.
"""
# Get default thresholds
if thresholds is None:
thresholds = get_default_thresholds(
ts=ts,
extremes_type=extremes_type,
num=100,
)
# Calculate mean residual life for each threshold
mean_residual_lives, mrl_confidence = [], []
for threshold in thresholds:
if extremes_type == "high":
exceedances = ts.loc[ts > threshold] - threshold
elif extremes_type == "low":
exceedances = ts.loc[ts < threshold] - threshold
else:
raise ValueError(
f"invalid value in '{extremes_type}' for the 'extremes_type' argument"
)
mean_residual_lives.append(exceedances.mean())
if alpha is not None:
mrl_confidence.append(
scipy.stats.norm.interval(
alpha=alpha,
loc=exceedances.mean(),
scale=exceedances.std(ddof=1) / np.sqrt(len(exceedances)),
))
with plt.rc_context(rc=pyextremes_rc):
# Create figure and axes
fig, ax = plt.subplots(figsize=figsize, dpi=96)
ax.grid(False)
# Plotting central estimates of mean residual life
ax.plot(
thresholds,
mean_residual_lives,
color="#F85C50",
lw=2,
ls="-",
zorder=15,
)
# Plot confidence intervals
if alpha is not None:
for ci in np.transpose(mrl_confidence):
ax.plot(thresholds,
ci,
color="#5199FF",
lw=1,
ls="--",
zorder=10)
ax.fill_between(
thresholds,
*np.transpose(mrl_confidence),
facecolor="#5199FF",
edgecolor="None",
alpha=0.25,
zorder=5,
)
# Label axes
ax.set_xlabel("Threshold")
ax.set_ylabel("Mean excess")
return fig, ax
fig, ax = plt.subplots()
dots = np.arange(10) / 100. + .03
x, y = np.meshgrid(dots, dots)
data = [x.ravel(), y.ravel()]
ax.scatter(*data, c=data[1])
################################################################################
# Sometimes choosing evenly-distributed ticks results in strange tick numbers.
# If you'd like Matplotlib to keep ticks located at round numbers, you can
# change this behavior with the following rcParams value:
print(plt.rcParams['axes.autolimit_mode'])
# Now change this value and see the results
with plt.rc_context({'axes.autolimit_mode': 'round_numbers'}):
fig, ax = plt.subplots()
ax.scatter(*data, c=data[1])
################################################################################
# You can also alter the margins of the axes around the data by
# with ``axes.(x,y)margin``:
with plt.rc_context({'axes.autolimit_mode': 'round_numbers',
'axes.xmargin': .8,
'axes.ymargin': .8}):
fig, ax = plt.subplots()
ax.scatter(*data, c=data[1])
plt.show()
ax = fig.add_subplot(1,2,1).autoscale(tight=True)
# sys.exit()
ax=plt.subplot2grid((1,40), (0, 0), colspan=10, axisbg='white')
# fig.subplots_adjust(wspace=0, hspace=0)
ax1.set_title('Roary matrix\n(%d gene clusters)'%roary.shape[0])
if options.labels:
# changed font size to 3 for large trees.
fsize = 3
# fsize = 12 - 0.1*roary.shape[1]
# if fsize < 7:
# fsize = 7
with plt.rc_context({'font.size': fsize}):
Phylo.draw(t, axes=ax,
show_confidence=False,
# label_func=lambda x: str(x)[:10],
xticks=([],), yticks=([],),
ylabel=('',), xlabel=('',),
xlim=(-mdist*0.1,mdist+mdist*0.45-mdist*roary.shape[1]*0.001),
axis=('on',),
title=('Tree\n(%d strains)'%roary.shape[1],),
do_show=False,
)
else:
Phylo.draw(t, axes=ax,
show_confidence=False,
label_func=lambda x: None,
xticks=([],), yticks=([],),
aim -= int(line.replace('up ', ''))
yield x, y, aim
# plt.figure()
# plt.plot(DEPTH)
# x, y, a = map(np.asarray, zip(*plot_posv2()))
# dx, dy = map(np.asarray, zip(*plot_pos()))
# # plt.plot(x, y)
# plt.plot(dx, dy)
# plt.show()
n_frames = len(INPUT.splitlines())
with plt.rc_context({'axes.edgecolor': '#ffff66', 'xtick.color': '#ffff66', 'ytick.color': '#ffff66'}):
pos = plot_posv2()
fig, ax = plt.subplots(facecolor="#0f0f23")
ax.set_facecolor("#0f0f23")
ax.tick_params(color="#ffff66", which='both')
ax.xaxis.label.set_color("#ffff66")
ax.yaxis.label.set_color("#ffff66")
xdata, ydata = [], []
depthx, depthy = [], []
ln, = plt.plot([], [], color="#ffff66")
ln2, = plt.plot([], [], color="#ff4c4c")
arrow = plt.arrow(0, 0, 1, 0, color="#ffff66")
ax.set_xlim(0, 2007)
ax.set_ylim(0, 668080)
ax.invert_yaxis()
def newton_multi(request):
x, y, z, w = sympy.symbols('x y z w')
valores = request.POST
n = len(valores)
plt.rcParams.update(plt.rcParamsDefault)
plt.close('all')
if n == 5:
iteraciones = 10
resul = {'titulos': ['n', 'Vector Solución', 'f₁(x, y), f₂(x, y)'], 'filas': []}
f1 = sympy.sympify(valores['f1'])
x0 = float(valores['x0'])
f2 = sympy.sympify(valores['f2'])
y0 = float(valores['y0'])
# derivadas parciales
f1x = sympy.diff(f1, x)
f1y = sympy.diff(f1, y)
f2x = sympy.diff(f2, x)
f2y = sympy.diff(f2, y)
# vector de las funciones iniciales
v = sympy.Matrix([[f1], [f2]])
# inversa,de la jacobiana
j_inv = (sympy.Matrix([[f1x, f1y],
[f2x, f2y]])) ** -1
# lamdify de las matrices
jaco = sympy.lambdify([x, y], j_inv, 'numpy')
fxfy = sympy.lambdify([x, y], v, 'numpy')
solucion = np.array([[x0], [y0]])
for n in range(1, iteraciones + 1):
# Dandole formato a los valores
sol = fxfy(solucion[0][0], solucion[1][0])
xs = f'{solucion[0][0]:.6f}'
ys = f'{solucion[1][0]:.6f}'
fxn = f'{float(sol[0]):.6f}'
fyn = f'{float(sol[1]):.6f}'
resul['filas'].append([n, xs + ' | ' + ys, fxn + ' | ' + fyn])
j = jaco(solucion[0][0], solucion[1][0]).dot(fxfy(solucion[0][0], solucion[1][0]))
solucion = solucion - j
context = {'context': resul}
context["jaco"] = sympy.latex(sympy.Matrix([[f1x, f1y],
[f2x, f2y]])).replace("\left[", ' ').strip("\\right]").replace(
"matrix", "bmatrix")
# graficación
plt.rc_context({'axes.edgecolor': 'w', 'xtick.color': 'w', 'ytick.color': 'w'})
# plt.style.use("dark_background")
xs = solucion[0][0] # x solucion
ys = solucion[1][0] # y solucion
titulo = '\n' + estiliza_string(valores['f1']) + ', ' + estiliza_string(valores['f2']) + '\n'
plt.rc_context({'axes.edgecolor': 'gray', 'xtick.color': 'gray', 'ytick.color': 'gray'})
p = plot3d(f1, f2, (x, xs - 3, xs + 3), (y, ys - 3, ys + 3), title=titulo, nb_of_points_x=35, nb_of_points_y=35,
xlabel='X', ylabel='Y')
buf = BytesIO()
p._backend.fig.savefig(buf, format='jpg', quality=90, bbox_inches='tight', facecolor="#f3f2f1", dpi=150,
transparent=True)
buf.seek(0)
uri = 'data:image/png;base64,' + parse.quote(b64encode(buf.read()))
context['image'] = uri
p._backend.close()
elif n == 7:
iteraciones = 15
resul = {'titulos': ['n', 'Vector Solución', 'f₁ | f₂ | f₃'], 'filas': []}
f1 = sympy.sympify(valores['f1'])
x0 = float(valores['x0'])
f2 = sympy.sympify(valores['f2'])
y0 = float(valores['y0'])
f3 = sympy.sympify(valores['f3'])
z0 = float(valores['z0'])
# derivadas parciales
f1x = sympy.diff(f1, x)
f1y = sympy.diff(f1, y)
f1z = sympy.diff(f1, z)
f2x = sympy.diff(f2, x)
f2y = sympy.diff(f2, y)
f2z = sympy.diff(f2, z)
f3x = sympy.diff(f3, x)
f3y = sympy.diff(f3, y)
f3z = sympy.diff(f3, z)
# funciones iniciales
v = sympy.Matrix([[f1], [f2], [f3]])
# inversa jacobiana
j_inv = (sympy.Matrix([[f1x, f1y, f1z],
[f2x, f2y, f2z],
[f3x, f3y, f3z]])) ** -1
jaco = sympy.lambdify([x, y, z], j_inv, "numpy")
fxfyfz = sympy.lambdify([x, y, z], v, "numpy")
solucion = np.array([[x0], [y0], [z0]])
for n in range(1, iteraciones + 1):
# Dandole formato a los valores
sol = fxfyfz(solucion[0][0], solucion[1][0], solucion[2][0])
xs = f'{solucion[0][0]:.4f}'
ys = f'{solucion[1][0]:.4f}'
zs = f'{solucion[2][0]:.4f}'
fxn = f'{float(sol[0]):.4f}'
fyn = f'{float(sol[1]):.4f}'
fzn = f'{float(sol[2]):.4f}'
resul['filas'].append([n, xs + ' | ' + ys + ' | ' + zs, fxn + ' | ' + fyn + ' | ' + fzn])
j = jaco(solucion[0][0], solucion[1][0], solucion[2][0]).dot(
fxfyfz(solucion[0][0], solucion[1][0], solucion[2][0]))
solucion -= j
context = {'context': resul}
context["jaco"] = sympy.latex(sympy.Matrix([[f1x, f1y, f1z],
[f2x, f2y, f2z],
[f3x, f3y, f3z]])).replace("\left[", ' ').strip("\\right]").replace(
"matrix", "bmatrix")
context["inv"] = sympy.latex(j_inv).replace("\left[", ' ').strip("\\right]").replace("matrix", "bmatrix")
context["mat"] = sympy.latex(v).replace("\left[", ' ').strip("\\right]").replace("matrix", "bmatrix")
return render(request, "newton_calculado_multi.html", context)
def monitor(pid, logfile=None, plot=None, duration=None, interval=None,
include_children=False):
# We import psutil here so that the module can be imported even if psutil
# is not present (for example if accessing the version)
import psutil
pr = psutil.Process(pid)
# Record start time
start_time = time.time()
if logfile:
f = open(logfile, 'w')
f.write("# {0:12s} {1:12s} {2:12s} {3:12s}\n".format(
'Elapsed time'.center(12),
'CPU (%)'.center(12),
'Real (MB)'.center(12),
'Virtual (MB)'.center(12))
)
log = {}
log['times'] = []
log['cpu'] = []
log['mem_real'] = []
log['mem_virtual'] = []
try:
# Start main event loop
while True:
# Find current time
current_time = time.time()
try:
pr_status = pr.status()
except TypeError: # psutil < 2.0
pr_status = pr.status
except psutil.NoSuchProcess: # pragma: no cover
break
# Check if process status indicates we should exit
if pr_status in [psutil.STATUS_ZOMBIE, psutil.STATUS_DEAD]:
print("Process finished ({0:.2f} seconds)"
.format(current_time - start_time))
break
# Check if we have reached the maximum time
if duration is not None and current_time - start_time > duration:
break
# Get current CPU and memory
try:
current_cpu = get_percent(pr)
current_mem = get_memory(pr)
except Exception:
break
current_mem_real = current_mem.rss / 1024. ** 2
current_mem_virtual = current_mem.vms / 1024. ** 2
# Get information for children
if include_children:
for child in all_children(pr):
try:
current_cpu += get_percent(child)
current_mem = get_memory(child)
except Exception:
continue
current_mem_real += current_mem.rss / 1024. ** 2
current_mem_virtual += current_mem.vms / 1024. ** 2
if logfile:
f.write("{0:12.3f} {1:12.3f} {2:12.3f} {3:12.3f}\n".format(
current_time - start_time,
current_cpu,
current_mem_real,
current_mem_virtual))
f.flush()
if interval is not None:
time.sleep(interval)
# If plotting, record the values
if plot:
log['times'].append(current_time - start_time)
log['cpu'].append(current_cpu)
log['mem_real'].append(current_mem_real)
log['mem_virtual'].append(current_mem_virtual)
except KeyboardInterrupt: # pragma: no cover
pass
if logfile:
f.close()
if plot:
# Use non-interactive backend, to enable operation on headless machines
import matplotlib.pyplot as plt
with plt.rc_context({'backend': 'Agg'}):
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(log['times'], log['cpu'], '-', lw=1, color='r')
ax.set_ylabel('CPU (%)', color='r')
ax.set_xlabel('time (s)')
ax.set_ylim(0., max(log['cpu']) * 1.2)
ax2 = ax.twinx()
ax2.plot(log['times'], log['mem_real'], '-', lw=1, color='b')
ax2.set_ylim(0., max(log['mem_real']) * 1.2)
ax2.set_ylabel('Real Memory (MB)', color='b')
ax.grid()
fig.savefig(plot)
def plot_ruiplot(zvals,
i,
inputs,
labels,
outputs,
width=25,
ax=None,
styles=RUI_STYLES):
## mds print('zvals = ',zvals)
## mds print(' i = ',i)
## mds print(' inputs = ', inputs)
## mds print(' labels = ', labels)
## mds print(' outputs = ', outputs)
x_bins = np.round(zvals[i - width:i + width] - 0.05, 2)
## mds print('x_bins = ',x_bins)
y_kernel = inputs.squeeze()[i - width:i + width] * 2500
## mds print('y_kernel = ', y_kernel)
y_target = labels.squeeze()[i - width:i + width]
## mds print('y_target = ', y_target)
y_predicted = outputs.squeeze()[i - width:i + width]
## mds print('y_predicted = ', y_predicted)
with plt.rc_context(mystyle):
if ax is None:
fig, ax = plt.subplots(figsize=(12, 7))
ax.xaxis.set_major_formatter(FormatStrFormatter("%.2f"))
ax.set_xlim(zvals[i - width] - 0.05, zvals[i + width] - 0.05)
ax.set_xlabel("z values [mm]")
ax.bar(x_bins,
y_kernel,
width=0.1,
**styles["kernel"],
label="Kernel Density")
ax.legend(loc="upper left")
ax.set_ylim(0, max(y_kernel) * 1.2)
ax.set_ylabel("Kernel Density", color=get_color(styles["kernel"]))
ax_prob = ax.twinx()
p1 = ax_prob.bar(x_bins,
y_target,
width=0.1,
**styles["target"],
label="Target")
p2 = ax_prob.bar(x_bins,
y_predicted,
width=0.1,
**styles["predicted"],
label="Predicted")
#ax_prob.set_ylim(0, max(0.8, 1.2 * max(y_predicted)))
ax_prob.set_ylim(0, max(1.5,
1.2 * max(max(y_predicted), max(y_target))))
ax_prob.set_ylabel("Probability", color=get_color(styles["predicted"]))
if np.any(np.isnan(labels)):
grey_y = np.isnan(y_target) * 0.2
ax_prob.bar(x_bins,
grey_y,
width=0.1,
**styles["masked"],
label="Masked")
ax_prob.legend(loc="upper right")
return ax, ax_prob, y_kernel
'c': costs[low_:high_, 0].reshape(-1),
'brake': costs[low_:high_, -1].reshape(-1),
'lane': costs[low_:high_, 3].reshape(-1),
}
episodes.append(new_episode)
discounted_costs = np.array([[discounted_sum(x['c'],.95),discounted_sum(x['brake'],.95),discounted_sum(x['lane'],.95)] for x in episodes])
data = dd.io.load('car_policy_improvement.h5')
DQN = [-39.61397106365249, 7.703194041056963, 115.62071639160499]
LSPI = pd.read_csv('lspi_results.csv')
plt.rc('text', usetex=True)
lines, fill_betweens= [], []
plt.rc_context({'axes.edgecolor':'k'})
fig, ax1 = plt.subplots()
ax1.grid(alpha=.35)
max_iterations = 27
iterations = range(len(data['g_eval'][0][:max_iterations]))
colors = color_gen()
constraint_names = ['Braking', 'Center of Lane']
constraint_upper_bound = [5.8, 85.]#[1.5, 5.]
locations = ['lower left', 'lower center', 'lower right']
fontsize = 16
legend_fontsize = 16
legend_title_fontsize = 16
major_tick_mark_size = 14
def derandomize(data, constraints, min_iteration):
def clustermap(df, Zx=None, Zy=None, aw=3, ah=3, lw=1, vmin=None, vmax=None, cmap=plt.cm.Blues,
origin='lower', dendrogram_pos='top', ylabel_pos='left',
cohort_s=None, cohort_colors=None, #cohort_labels=None,
fontsize=10, clabel='', cfontsize=10, label_colors=None, colorbar_orientation='vertical',
method='average', metric='euclidean', optimal_ordering=False, value_labels=False,
rotation=-45, ha='left', va='top', tri=False, rasterized=False,
dl=1, dr=1, dt=0.2, lh=0.1, ls=0.01,
db=1.5, dd=0.4, ds=0.03, ch=1, cw=0.175, dc=0.1, dtc=0):
if cohort_s is not None:
if isinstance(cohort_s, pd.Series):
cohort_s = [cohort_s]
# cohort_labels = [cohort_labels]
n = len(cohort_s)
if cohort_colors is None:
cohort_colors = []
for k in range(n):
nc = len(np.unique(cohort_s[k]))
cohort_colors.append({i:j for i,j in zip(np.unique(cohort_s[k]), plt.cm.get_cmap('Spectral_r', nc)(np.arange(nc)))})
else:
n = 0
if Zx is None:
Zy = hierarchy.linkage(df, method=method, metric=metric, optimal_ordering=optimal_ordering)
Zx = hierarchy.linkage(df.T, method=method, metric=metric, optimal_ordering=optimal_ordering)
elif Zy is None:
Zy = Zx
fw = dl+aw+dr
fh = db+ah+ds+dd+dt+n*(lh+ls)
fig = plt.figure(figsize=(fw,fh))
if dendrogram_pos=='top':
ax = fig.add_axes([dl/fw, db/fh, aw/fw, ah/fh])
lax = []
for k in range(n):
lax.append(
fig.add_axes([dl/fw, (db+ah+(k+1)*ls+k*lh)/fh, aw/fw, lh/fh], sharex=ax)
)
dax = fig.add_axes([dl/fw, (db+ah+n*(ls+lh)+ds)/fh, aw/fw, dd/fh])
cax = fig.add_axes([(dl+aw+dc)/fw, (db+ah-ch-dtc)/fh, cw/fw, ch/fh])
axes = [ax, *lax, dax, cax]
else:
dax = fig.add_axes([dl/fw, db/fh, aw/fw, dd/fh])
ax = fig.add_axes([dl/fw, (db+dd+ds)/fh, aw/fw, ah/fh])
cax = fig.add_axes([(dl+aw+dc)/fw, (db+dd+ds)/fh, cw/fw, ch/fh])
axes = [ax, dax, cax]
if Zx is not None:
with plt.rc_context({'lines.linewidth': lw}):
z = hierarchy.dendrogram(Zx, ax=dax, orientation='top', link_color_func=lambda k: 'k')
ix = df.columns[hierarchy.leaves_list(Zx)]
iy = df.index[hierarchy.leaves_list(Zy)]
else:
ix = df.columns
dax.axis('off')
if dendrogram_pos=='bottom':
dax.invert_yaxis()
df = df.loc[iy, ix].copy()
if tri:
if dendrogram_pos=='top':
df.values[np.triu_indices(df.shape[0])] = np.NaN
elif dendrogram_pos=='bottom':
df.values[np.tril_indices(df.shape[0])] = np.NaN
if value_labels:
irange = np.arange(df.shape[0])
jrange = np.arange(df.shape[1])
for i in irange:
for j in jrange:
if not np.isnan(df.values[j,i]):
ax.text(i, j, f'{df.values[j,i]:.2f}', ha='center', va='center')
h = ax.imshow(df, origin=origin, cmap=cmap, vmin=vmin, vmax=vmax, rasterized=rasterized, aspect='auto')
ax.set_xticks(np.arange(df.shape[1]))
ax.set_yticks(np.arange(df.shape[0]))
ax.set_xticklabels(ix, rotation=rotation, fontsize=fontsize, ha=ha, va=va)
ax.set_yticklabels(iy, fontsize=fontsize)
# plot cohort labels
for k in range(n):
cohort_index_s = cohort_s[k].map({j:i for i,j in enumerate(cohort_s[k].unique())})
cmap2 = colors.ListedColormap([cohort_colors[k][j] for j in cohort_s[k].unique()], 'indexed')
lax[k].imshow(cohort_index_s[ix].values.reshape(1,-1), aspect='auto', origin='lower', cmap=cmap2)
# if cluster_labels is not None:
if ylabel_pos == 'left':
lax[k].set_ylabel(cohort_s[k].name, fontsize=10, rotation=0, va='center', ha='right')
elif ylabel_pos == 'right':
lax[k].yaxis.set_label_position(ylabel_pos)
lax[k].set_ylabel(cohort_s[k].name, fontsize=10, rotation=0, va='center', ha='left')
for i in lax[k].spines:
lax[k].spines[i].set_visible(False)
lax[k].set_xticks([])
lax[k].set_yticks([])
if dendrogram_pos=='bottom':
ax.yaxis.tick_right()
# else:
# ax.xaxis.tick_top()
if label_colors is not None: # plot label dots at bottom
s = 1.015
# xlim = ax.get_xlim()
# b = xlim[1] - s*np.diff(xlim)
# ax.set_xlim(xlim)
# ax.scatter([b]*df.shape[1], np.arange(df.shape[1]), s=48, c=label_colors[hierarchy.leaves_list(Zx)], clip_on=False)
# ax.tick_params(axis='y', pad=12)
# s = 1.02
# ylim = ax.get_ylim()
# b = ylim[1] - s*np.diff(ylim)
# ax.set_ylim(ylim)
# ax.scatter(np.arange(df.shape[1]), [b]*df.shape[1], s=36, c=label_colors[hierarchy.leaves_list(Zx)], clip_on=False)
# ax.tick_params(axis='x', pad=12)
cbar = plt.colorbar(h, cax=cax, orientation=colorbar_orientation)
cax.locator_params(nbins=4)
cbar.set_label(clabel, fontsize=cfontsize+2)
cax.tick_params(labelsize=cfontsize)
for i in ['left', 'top', 'right', 'bottom']:
ax.spines[i].set_visible(False)
ax.tick_params(length=0)
plt.sca(ax)
return axes
})
# %% [markdown]
# > Use pcolormesh to create maps of wind speed, U and V at 500, 6000 and 15000 geopotential meters
#
# xarray `FacetGrid` can easily create a figure with plots at different levels. But not for different variables.
# %%
levs = [500, 6000, 15000]
# colorbar overlays the plots if autolayout is used
# still can't see the colorbar label
# could set `add_colorbar` to False and add it manually in its own ax
# or pass `cbar_ax`...
# many options here: http://xarray.pydata.org/en/stable/generated/xarray.DataArray.plot.pcolormesh.html
with plt.rc_context({"figure.autolayout": False}):
ds.uh.sel(hgt=levs).plot.pcolormesh(row="hgt",
x="x",
y="y",
size=2.9,
aspect=1.3,
cbar_kwargs=dict(shrink=0.5,
fraction=0.2))
# note passing axes not supported with facted plots
# %%
# This is a hacky way to do this, probably there are easier ways, maybe with `mpl_toolkits.axes_grid1`
width_ratios = []
for _ in range(3):
width_ratios.extend(
[1, 0.05, 0.11,
def plot_td_waveform_resp(
params1, params2, ant=True, outPath='td-detector-res.pdf', resi=True, norm=True, xmin=None, xmax=None):
"""
Generate time domain plot of gw detector response
This function will produce a two column, two row plot of a two gw detector
responses based on a numerical relativity waveform. In each column the LHO
and LLO detector responses are plotted for the two cases. The individual
polarizations of the strain are also plotted as background.
This figure is designed to be ploted to compare polarizations and so the
titles of the columns display the polarizations, however there is no
restriction on the two parameter objects.
Parameters
----------
params1: object
The parameters of the waveform to plot in the left column. The fields of
this object correspond to the kwargs of the
`pycbc.waveform.get_td_waveform()` method and the positional arguments
of `pycbc.detector.Detector.antenna_pattern()`. For the later the fields
should be supplied as `params.ra`, `.dec`, `.polarization` and
`.geocentric_end_time`.
params2: object
The parameters of the waveform to plot in the right column. The fields
of this object correspond to the kwargs of the
`pycbc.waveform.get_td_waveform()` method and the positional arguments
of `pycbc.detector.Detector.antenna_pattern()`. For the later the fields
should be supplied as `params.ra`, `.dec`, `.polarization` and
`.geocentric_end_time`.
ant: boolean, optional
If True, plot Fp*hp and Fc*hc in the background. If False plot hp and
hc in the background.
outPath: string, optional
Image file path to which the plot can be written.
resi: boolean, optional
Plot the residuals of the two waveforms.
xmin: float, optional
Minimum x-axis limit.
xmax: float, optional
Maximum x-axis limit.
"""
# Custom configuration
with plt.rc_context(dict({},**{
'legend.fontsize':10,
'axes.labelsize':11,
'font.family':'serif',
'font.size':11,
'xtick.labelsize':11,
'ytick.labelsize':11,
'figure.figsize':(16,10),
'savefig.dpi':80,
'figure.subplot.bottom': 0.06,
'figure.subplot.left': 0.06,
'figure.subplot.right': 0.975,
'figure.subplot.top': 0.975,
'axes.unicode_minus': False
})):
# Prepare figure
fig = plt.figure()
gs_strain = plt.GridSpec(10, 2, hspace=0, wspace=0)
# Add axes
ax1H1 = fig.add_subplot(gs_strain[0:5,0:2])
ax1L1 = fig.add_subplot(gs_strain[5:10,0:2],sharex=ax1H1,sharey=ax1H1)
# Generate data
hp1, hc1, ps1 = get_td_waveform_resp(params1)
hp2, hc2, ps2 = get_td_waveform_resp(params2)
colors1 = [tableau20[0],tableau20[1]]
colors2 = [tableau20[6],tableau20[7]]
if resi:
# Plot H1 response
hResp1H1 = -1*(ps1['H1'].f_plus*hp1+ps1['H1'].f_cross*hc1)
hResp2H1 = -1*(ps2['H1'].f_plus*hp2+ps2['H1'].f_cross*hc2)
t0 = np.max((hp1.sample_times[0],hp2.sample_times[0]))
t1 = np.min((hp1.sample_times[-1],hp2.sample_times[-1]))
t = np.linspace(t0,t1,len(hp1))
hResp1H1 = IUS(hp1.sample_times,hResp1H1,k=5)
hResp2H1 = IUS(hp2.sample_times,hResp2H1,k=5)
hRespH1 = hResp2H1(t)-hResp1H1(t)
hRespH1 /= hResp1H1(t)/100.0 if norm else 1
ax1H1.plot(
t,
hRespH1 if not norm else np.abs(hRespH1),
color=colors1[0],
lw=1.5)
# Plot L1 response
hResp1L1 = -1*(ps1['L1'].f_plus*hp1+ps1['L1'].f_cross*hc1)
hResp2L1 = -1*(ps2['L1'].f_plus*hp2+ps2['L1'].f_cross*hc2)
t0 = np.max((hp1.sample_times[0],hp2.sample_times[0]))
t1 = np.min((hp1.sample_times[-1],hp2.sample_times[-1]))
t = np.linspace(t0,t1,len(hp1))
hResp1L1 = IUS(hp1.sample_times,hResp1L1,k=5)
hResp2L1 = IUS(hp2.sample_times,hResp2L1,k=5)
hRespL1 = hResp2L1(t)-hResp1L1(t)
hResp1L1 = hResp1L1(t)
mask = hResp1L1 == 0
hResp1L1[mask] = 1
hRespL1 /= hResp1L1/100.0 if norm else 1
ax1L1.plot(
t,
hRespL1 if not norm else np.abs(hRespL1),
color=colors1[0],
lw=1.5)
# Prepare H1 gridlines
ax1H1.grid(alpha=0.3)
ax1H1.xaxis.set_minor_locator(AutoMinorLocator(2))
ax1H1.grid(False)
# Prepare L1 gridlines
ax1L1.grid(alpha=0.3)
ax1L1.xaxis.set_minor_locator(AutoMinorLocator(2))
ax1L1.grid(False)
# Prepare strain range
ymax = np.max((np.mean(np.abs(hRespH1)),np.mean(np.abs(hRespH1))))*2 if norm else np.max((np.abs(hRespH1).max(),np.abs(hRespL1).max()))
ymax *= 1.25
ax1H1.set_ylim(0 if norm else -ymax,ymax)
else:
# Plot left and right columns
columns = (
(ax1H1,ax1L1,hp1,hc1,ps1,params1,colors1),
(ax1H1,ax1L1,hp2,hc2,ps2,params2,colors2))
for axH1,axL1,hp,hc,ps,params,colors in columns:
# Plot h+
axH1.plot(
hp.get_sample_times(),
ps['H1'].f_plus*hp if ant else hp,
color=colors[1],
ls='-',
label='$F_+h_+$' if ant else '$h_+$')
# Plot hx
axH1.plot(
hc.get_sample_times(),
ps['H1'].f_cross*hc if ant else hc,
color=colors[1],
ls='--',dashes=(2,2),
label='$F_{\\times}h_{\\times}$' if ant else '$h_{\\times}$')
# Plot H1 response
axH1.plot(
hc.get_sample_times(),
-1*(ps['H1'].f_plus*hp+ps['H1'].f_cross*hc),
color=colors[0],
label='$\\psi={0:.0f}^{{\circ}}$'.format((180.0/np.pi)*params.polarization),
lw=1.5)
# Plot h+
axL1.plot(
hp.get_sample_times(),
ps['L1'].f_plus*hp if ant else hp,
color=colors[1],
ls='-',
label='$F_+h_+$' if ant else '$h_+$')
# Plot hx
axL1.plot(
hc.get_sample_times(),
ps['L1'].f_cross*hc if ant else hc,
color=colors[1],
ls='--',dashes=(2,2),
label='$F_{\\times}h_{\\times}$' if ant else '$h_{\\times}$')
# Plot L1 response
axL1.plot(
hc.get_sample_times(),
ps['L1'].f_plus*hp+ps['L1'].f_cross*hc,
color=colors[0],
label='$\\psi={0:.0f}^{{\circ}}$'.format((180.0/np.pi)*params.polarization),
lw=1.5)
# Prepare H1 gridlines
axH1.grid(alpha=0.3)
axH1.xaxis.set_minor_locator(AutoMinorLocator(2))
axH1.grid(False)
# Prepare L1 gridlines
axL1.grid(alpha=0.3)
axL1.xaxis.set_minor_locator(AutoMinorLocator(2))
axL1.grid(False)
# Prepare strain range
if ant:
ymax = np.max((
np.max(np.abs(ps1['H1'].f_plus*hp1.data)),
np.max(np.abs(ps1['H1'].f_cross*hc1.data)),
np.max(np.abs(ps1['L1'].f_plus*hp1.data)),
np.max(np.abs(ps1['L1'].f_cross*hc1.data)),
np.max(np.abs(ps2['H1'].f_plus*hp2.data)),
np.max(np.abs(ps2['H1'].f_cross*hc2.data)),
np.max(np.abs(ps2['L1'].f_plus*hp2.data)),
np.max(np.abs(ps2['L1'].f_cross*hc2.data))))
else:
ymax = np.max((
np.max(np.abs(hp1.data)),
np.max(np.abs(hc1.data)),
np.max(np.abs(hp2.data)),
np.max(np.abs(hc2.data))))
ymax *= 1.25
ax1H1.set_ylim(-ymax,ymax)
# Prepare time range
# xmin = (hp1.get_sample_times()[0]) if xmin == None else xmin
# xmax = (hp1.get_sample_times()[-1])/5 if xmax == None else xmax
xmin = -0.18; xmax = 0.18
ax1H1.set_xlim(xmin,xmax)
# Condition yticks
tickTol = ax1H1.get_ylim()[1]
ticks = ax1H1.get_yticks()
ticks = [e for e in ticks if (np.abs(e)-(4./5.)*tickTol) < 0]
ax1H1.set_yticks(ticks)
ax1L1.set_yticks(ticks)
# Prepare Strain label
yH1 = ax1H1.get_yaxis()
offset = yH1.major.formatter \
.format_data_short(ax1H1.get_yticks()[-1]).split('e')
exponent = '0' if len(offset)==1 else offset[1].rstrip()
ax1H1.set_ylabel(
"Residual (%)" if norm else "Strain $\mathregular{{(10^{{{0:s}}})}}$".format(exponent),x=0,y=0)
# Prepare Time label
ax1L1.set_xlabel('Time (s)',x=0.5,y=0)
# Prepare polarization labels
titleStr = (
'$\\iota_{{1}}={0:.2f}^{{\circ}}$\t$\\iota_{{2}}={1:.2f}^{{\circ}}$\n'
'$\\psi_{{1}}={2:.2f}^{{\circ}}$\t$\\psi_{{2}}={3:.2f}^{{\circ}}$\n'
'$\\phi_{{1}}={4:.2f}^{{\circ}}$\t\t$\\phi_{{2}}={5:.2f}^{{\circ}}$')
iota1 = (180.0/np.pi)*params1.inclination
iota2 = (180.0/np.pi)*params2.inclination
psi1 = (180.0/np.pi)*params1.polarization
psi2 = (180.0/np.pi)*params2.polarization
phi1 = (180.0/np.pi)*params1.coa_phase
phi2 = (180.0/np.pi)*params2.coa_phase
ax1H1Pos = ax1H1.get_position()
fig.text(
ax1H1Pos.x1-0.01,
ax1H1Pos.y1-0.01,
titleStr.format(iota1,iota2,psi1,psi2,phi1,phi2),
va="top",
ha="right")
# Remove offset text from yaxes
for ax in (ax1H1,ax1L1):
ax.get_yaxis().get_offset_text().set_visible(False)
# Remove ticks from shared axes
plt.setp(ax1H1.get_xticklabels(), visible=False)
# Dump plot
fig.savefig(outPath)
# Kill figure
plt.show()
plt.close(fig)
def main():
"""Test Options"""
FILENAME = 'scott_reef_analysis.py'
T_SEED = sea.io.parse('-tseed', 250)
Q_SEED = sea.io.parse('-qseed', 500)
UNIQUE = sea.io.parse('-unique', False)
U_SEED = sea.io.parse('-useed', 100)
N_TRAIN = sea.io.parse('-ntrain', 200)
N_QUERY = sea.io.parse('-nquery', 100000)
NOTRAIN = sea.io.parse('-skiptrain', False)
MODEL_ONLY = sea.io.parse('-model-only', False)
LONG_SCALE_ONLY = sea.io.parse('-long-scale', False)
BATCH_START = sea.io.parse('-batch-start', 'on')
MISSION_LENGTH = sea.io.parse('-mission-length', 0)
METHOD = sea.io.parse('-method', 'LMDE')
GREEDY = sea.io.parse('-greedy', False)
N_TRIALS = sea.io.parse('-ntrials', 200)
START_POINT1 = sea.io.parse('-start', 375000.0, arg = 1)
START_POINT2 = sea.io.parse('-start', 8440000.0, arg = 2)
H_STEPS = sea.io.parse('-hsteps', 30)
HORIZON = sea.io.parse('-horizon', 5000.0)
CHAOS = sea.io.parse('-chaos', False)
M_STEP = sea.io.parse('-mstep', 1)
N_DRAWS = sea.io.parse('-ndraws', 500)
DEPTH_PENALTY = sea.io.parse('-depth-penalty', False)
SKIP_FEATURE_PLOT = sea.io.parse('-skip-feature-plot', False)
TWO_COLORBAR = sea.io.parse('-two-colorbar', False)
FIXED_TYPE = sea.io.parse('-fixed-type', '')
FONTSIZE = 50
FONTNAME = 'Sans Serif'
TICKSIZE = 24
SAVE_TRIALS = 25
"""Model Options"""
SAVE_RESULTS = True
approxmethod = 'laplace'
multimethod = 'OVA'
fusemethod = 'EXCLUSION'
responsename = 'probit'
batchstart = True if (BATCH_START == 'on') else False
batchlearn = False
walltime = 3600.0
train = not NOTRAIN
white_fn = pre.standardise
n_train = N_TRAIN
n_query = N_QUERY
"""Visualisation Options"""
mycmap = cm.get_cmap(name = 'jet', lut = None)
vis_fix_range = True
vis_x_min = 360000
vis_x_max = 390000
vis_y_min = 8430000
vis_y_max = 8450000
vis_range = (vis_x_min, vis_x_max, vis_y_min, vis_y_max)
colorcenter_analysis = 'mean'
colorcenter_lde = colorcenter_analysis
y_names_all = [ 'None',
'Under-Exposed',
'Under-Exposed',
'Barron Sand 1',
'Low Density Coral 1',
'Sand Biota 1',
'Low Density Coral 2',
'Dense Coral 1',
'Dense Coral 2',
'Dense Coral 3',
'Sand Biota 2',
'Low Density Coral 3',
'Low Density Coral 4',
'Patch 1',
'Patch 2',
'Patch 3',
'Barron Sand 2',
'Sand Biota 3',
'Over-Exposed',
'Barron Sand 3',
'Under-Exposed',
'Under-Exposed',
'Sand Biota 4',
'Misc',
'Under-Exposed']
assert len(y_names_all) == 25
rcparams = {
'backend': 'pdf',
'axes.labelsize': TICKSIZE,
'text.fontsize': FONTSIZE,
'legend.fontsize': FONTSIZE,
'xtick.labelsize': TICKSIZE,
'ytick.labelsize': TICKSIZE,
'text.usetex': True,
'figure.figsize': sea.vis.fig_size(350.0)
}
plt.rc_context(rcparams)
map_kwargs = {'marker': 'x', 's': 5}
"""Initialise Result Logging"""
if SAVE_RESULTS:
home_directory = "../../../Results/scott-reef/"
save_directory = "t%d_q%d_ts%d_qs%d_method_%s%s%s_start%.1f%.1f_"\
"hsteps%d_horizon%.1f/" % (N_TRAIN, N_QUERY, T_SEED, Q_SEED,
METHOD, '_GREEDY' if GREEDY else '',
('_FTYPE_%s' % FIXED_TYPE) if FIXED_TYPE else '',
START_POINT1, START_POINT2, H_STEPS, HORIZON)
full_directory = gp.classifier.utils.create_directories(
save_directory,
home_directory = home_directory, append_time = True)
textfilename = '%slog.txt' % full_directory
"""Logging Options"""
logging.basicConfig(level = logging.DEBUG,
format = '%(asctime)s %(name)-12s '\
'%(levelname)-8s %(message)s',
datefmt = '%m-%d %H:%M',
filename = textfilename,
filemode = 'a')
gp.classifier.set_multiclass_logging_level(logging.DEBUG)
# Define a Handler which writes INFO messages or higher to the sys.stderr
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
# Set a format which is simpler for console use
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
# Tell the handler to use this format
console.setFormatter(formatter)
# Add the handler to the root logger
logging.getLogger().addHandler(console)
"""Process Options"""
test_options = { 'T_SEED': T_SEED,
'Q_SEED': Q_SEED,
'UNIQUE': UNIQUE,
'U_SEED': U_SEED,
'N_TRAIN': N_TRAIN,
'N_QUERY': N_QUERY,
'NOTRAIN': NOTRAIN,
'MODEL_ONLY': MODEL_ONLY,
'LONG_SCALE_ONLY': LONG_SCALE_ONLY,
'BATCH_START': BATCH_START,
'MISSION_LENGTH': MISSION_LENGTH,
'METHOD': METHOD,
'GREEDY': GREEDY,
'N_TRIALS': N_TRIALS,
'START_POINT1': START_POINT1,
'START_POINT2': START_POINT2,
'H_STEPS': H_STEPS,
'HORIZON': HORIZON,
'CHAOS': CHAOS,
'M_STEP': M_STEP,
'N_DRAWS': N_DRAWS,
'DEPTH_PENALTY': DEPTH_PENALTY,
'SKIP_FEATURE_PLOT': SKIP_FEATURE_PLOT,
'TWO_COLORBAR': TWO_COLORBAR,
'FIXED_TYPE': FIXED_TYPE,}
model_options = { 'approxmethod': approxmethod,
'multimethod': multimethod,
'fusemethod': fusemethod,
'responsename': responsename,
'batchstart': batchstart,
'batchlearn': batchlearn,
'walltime': walltime,
'train': train}
logging.info(sys.argv)
logging.info(test_options)
logging.info(model_options)
"""File Locations"""
directory_data = '../../../Data/'
filename_training_data = 'training_data_unmerged.npz'
filename_query_points = 'query_points.npz'
filename_truth = directory_data + 'truthmodel_t800_q100000_ts250_qs500.npz'
filename_start = directory_data + 'finalmodel_t200_q100000_ts250_qs500'\
'_method_LMDE_start377500_8440000_hsteps30_horizon5000.npz'
"""Sample Training Data and Query Points"""
if LONG_SCALE_ONLY:
i_features = [0, 3, 4]
feature_names = [ 'Bathymetry (Depth)',
'Aspect (Long Scale)',
'Rugosity (Long Scale)']
kerneldef = sea.model.kerneldef3
else:
i_features = [0, 1, 2, 3, 4]
feature_names = [ 'Bathymetry (Depth)',
'Aspect (Short Scale)',
'Rugosity (Short Scale)',
'Aspect (Long Scale)',
'Rugosity (Long Scale)']
kerneldef = sea.model.kerneldef5
X, F, y, Xq, Fq, i_train, i_query = \
sea.io.sample(*sea.io.load(directory_data,
filename_training_data, filename_query_points),
n_train = n_train, n_query = n_query,
t_seed = T_SEED, q_seed = Q_SEED,
features = i_features, unique_labels = UNIQUE, unique_seed = U_SEED)
start_indices = np.random.choice(np.arange(Xq.shape[0]),
size = 2500, replace = False)
yq_truth = sea.io.load_ground_truth(filename_truth,
assert_query_seed = Q_SEED)
y_unique = np.unique(y)
assert y_unique.shape[0] == 17
logging.info('There are %d unique labels' % y_unique.shape[0])
y_names = [y_names_all[i] for i in y_unique.astype(int)]
logging.info('Habitat Labels: {0}'.format(y_names))
"""Whiten the feature space"""
logging.info('Applying whitening on training and query features...')
feature_fn = sea.feature.compose(Xq, Fq, white_fn)
Fw, white_params = white_fn(F)
Fqw = white_fn(Fq, params = white_params)
k_features = F.shape[1]
logging.info('Whitening Parameters:')
logging.info(white_params)
if not SKIP_FEATURE_PLOT:
"""Visualise Sampled Training Locations"""
fig = plt.figure(figsize = (19.2, 10.8))
plt.scatter(
X[:, 0], X[:, 1],
marker = 'x', c = y,
vmin = y_unique[0], vmax = y_unique[-1],
cmap = mycmap)
sea.vis.describe_plot(title = '(a) Training Labels',
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Habitat Labels', cticks = y_unique, cticklabels = y_names,
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE, axis_scale = 1e3)
if TWO_COLORBAR:
plt.scatter(
X[:, 0], X[:, 1],
marker = 'x', c = y,
vmin = y_unique[0], vmax = y_unique[-1],
cmap = mycmap)
sea.vis.describe_plot(title = '(a) Training Labels',
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Habitat Labels', cticks = y_unique, cticklabels = y_unique,
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE, axis_scale = 1e3)
fig.tight_layout()
"""Visualise Features at Sampled Query Locations"""
letters = ['b', 'c', 'd', 'e', 'f']
feature_labels = ['Depth', 'Aspect', 'Rugosity', 'Aspect', 'Rugosity']
feature_units = ['$\mathrm{m}$', '$\mathrm{m}$/$\mathrm{m}$', '$\mathrm{m}^{2}$/$\mathrm{m}^{2}$', '$\mathrm{m}$/$\mathrm{m}$', '$\mathrm{m}^{2}$/$\mathrm{m}^{2}$']
for k in range(k_features):
fig = plt.figure(figsize = (19.2, 10.8))
sea.vis.scatter(
Xq[:, 0], Xq[:, 1],
c = Fq[:, k], colorcenter = 'mean', cmap = mycmap, **map_kwargs)
sea.vis.describe_plot(
title = '(%s) Feature: %s' % (letters[k], feature_names[k]),
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = '%s (%s)' % (feature_labels[k], feature_units[k]),
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE, axis_scale = 1e3)
if TWO_COLORBAR:
sea.vis.scatter(
Xq[:, 0], Xq[:, 1],
c = Fqw[:, k], colorcenter = 'mean', cmap = mycmap, **map_kwargs)
sea.vis.describe_plot(
title = '(%s) Feature: %s' % (letters[k], feature_names[k]),
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Whitened %s' % feature_labels[k],
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE, axis_scale = 1e3)
fig.tight_layout()
logging.info('Plotted feature map for: %s' % feature_names[k])
"""Classifier Training"""
logging.info('===Begin Classifier Training===')
logging.info('Number of training points: %d' % n_train)
optimiser_config = gp.OptConfig()
optimiser_config.sigma = gp.auto_range(kerneldef)
optimiser_config.walltime = walltime
# User can choose to batch start each binary classifier with different
# initial hyperparameters for faster training
if batchstart:
if LONG_SCALE_ONLY:
initial_hyperparams = \
[ [138.04629034049745, 1.3026163180402612, 2.0609539037086777, 13.662777662608923], \
[22.688174688988205, 0.85939961064783144, 3.1849018302605145, 16.259612437640932], \
[4.9644266771973573, 12.863027059688255, 9.6883729945945429, 11.298947254002099], \
[2.8722041026032517, 1.7551920752264887, 3.2957930714865951, 2.0261411106598501], \
[1.95985751313864, 1.7015679970507851, 3.8989285686128072, 3.0227232782849662], \
[4.5387717477104914, 6.1923651207093151, 2.6865876299919011, 1.2053732599769598], \
[1.4406689190161075, 0.84772066855527117, 1.5917366549768182, 2.2383935939629236], \
[1.5227503435926373, 2.3834299628669449, 1.8308476182313158, 1.3574417717717639], \
[2.6346222397798864, 1.5157083797833799, 3.584415559552045, 3.6937042394472979], \
[24.187203476683973, 2.4970022673408536, 2.7272769326695716, 5.14139220925684], \
[3.1383721252068657, 3.7387409500864055, 5.4078774438507038, 2.6037751359723482], \
[8.4478301876452306, 5.0320403406718492, 2.8834212079291985, 2.9415227772920427], \
[3.1426495531487646, 4.0212439378901861, 0.60134852594003851, 1.7306126149977454], \
[15.635374455133983, 3.2520409675251392, 0.48800515908613024, 6.194364208177519], \
[79.02112152577908, 1.6997190910449294, 4.7100928164230398, 18.54561945000215], \
[2.4147686613391968, 4.77983081183657, 5.6427304713913555, 3.6184518253194233], \
[5.0053135736819581, 7.5224457127374018, 10.501213860336557, 14.976120894135667] ]
else:
# 200 training points
initial_hyperparams = \
[ [158.04660629989138, 1.2683731889725351, 66.115010215389162, 49.467620758110257, 2.1003587537731203, 148.19413243571267], \
[65.998503029331715, 0.96182325466796015, 76.537506649529078, 8.7072874430795792, 2.7122005803599105, 31.811834175256053], \
[7.2059309204166064, 248.71972897462479, 640.00239325817472, 168.88943619928102, 90.693076836996767, 262.04071654280534], \
[6.0223358705627561, 5.7983854605769629, 7.151322371121573, 98.235863530785863, 108.97929055450719, 3.4049522081768151], \
[2.8661028631425438, 202.71822125606951, 71.427958520531689, 67.841056622412466, 396.4966008975731, 8.7928316190417863], \
[4.2274366302519937, 2.6787248415957619, 155.52642217518203, 12.902809348832989, 78.595731986539263, 91.408564485980548], \
[1.9655515448696013, 1.0078459070165113, 47.264505099891736, 90.096628012215518, 39.449679781547545, 12.422258217851045], \
[3.1222954891045123, 2.4207646445523401, 238.89962477023275, 110.82548792960249, 96.535214824647056, 13.310640119621617], \
[4.9184407605671376, 2.2582428037913012, 220.5347539837725, 98.366730030395019, 51.082771850913375, 29.11755699767917], \
[46.140309605544743, 3.4122114646182515, 66.780957403339869, 56.618087864345419, 3.4707008796589727, 8.5854627686410119], \
[4.3654723196710217, 4.8059179997026096, 190.44003623250873, 122.8813398402322, 95.879994772087869, 3.3765033232957848], \
[4.4788217098193668, 10.934823441369865, 123.33728936692876, 382.04572230065276, 227.51098327130356, 79.977071466413577], \
[4.2294957554111283, 1.3726514772357896, 208.19938841666934, 174.7937853783985, 10.037269529873239, 127.83511529606474], \
[27.075374606311115, 1.814069988416549, 7.7469247716502938, 170.97327917010006, 40.037475847074973, 56.043993677737269], \
[83.400751642781657, 1.6747947434483126, 17.596540717504126, 112.41698370483411, 4.6137167168846629, 42.078275936624557], \
[3.0901973040826474, 12.319455336644344, 70.719245134201159, 140.9221718578234, 224.77657336458043, 4.57995836705937], \
[7.0310415618402358, 211.04475504456954, 202.37890056818438, 261.95210773212585, 156.94082106951919, 511.27885698486267] ]
# 17 training points
initial_hyperparams = \
[ [195.98487106074634, 6.7545874303906324, 329.16664672945632, 31.504964572830737, 1.9724700463442919, 21.940669950105065], \
[95.829408268109617, 1.7949030403189434, 35.784549991952147, 1.8075392976819478, 10.31753783934046, 27.645539145569355], \
[2.4679367048563332, 275.24358705136979, 636.92711361596116, 168.68139572408469, 87.432840499884747, 258.97633592547965], \
[2.3420253385025367, 22.62310001101493, 20.298926088403892, 212.56013373337302, 209.02779685614902, 15.565081046326867], \
[2.9748867112646384, 200.28885691135244, 1.1710790148367796, 52.732688292649328, 350.37993600980144, 6.3245982727950123], \
[4.3591136780785931, 16.744013045345845, 111.84371029836002, 2.6271052576644083, 102.14193905175958, 143.95163894287077], \
[2.6009968687635978, 7.8504445946888541, 279.91377309872604, 571.13535376074287, 51.648328357923504, 57.43636247986246], \
[2.4669769583966881, 31.401111683458542, 1270.673818203853, 337.26773045092648, 368.74473748301619, 75.987016939102659], \
[3.192504460520428, 4.0107134770438648, 266.75067564837178, 100.4706686565055, 2.2156505927398489, 46.563261471015231], \
[2.7471255292767269, 5.9252925255696667, 66.230363001377597, 29.189047727296355, 4.7635337732844629, 9.4122327461445128], \
[3.7276325071593375, 14.779658802248324, 197.5161462630272, 262.24241780595895, 101.47737618311446, 2.008726905058027], \
[56.268937406820683, 2.4305349403533811, 199.24414072357104, 2050.7935600821183, 254.31421742040177, 419.97964986565347], \
[2.1187879592937864, 7.151426051051188, 673.33446347673043, 367.65295120249033, 18.135417989990003, 55.041101285874831], \
[94.324177544164343, 9.5192423889915716, 2.4718983405006063, 126.99001654949174, 28.768268229786504, 130.52935833526666], \
[2.1644252127344439, 3.7891115623661094, 25.035857452933165, 150.28115119268051, 6.1879295261351688, 63.966209357387271], \
[6.6898343574716925, 1.8055110508489738, 44.732688365789286, 12.947694755847623, 71.881458838567767, 7.7704768954169774], \
[2.4864586001908822, 214.54661462714421, 223.8076780527073, 248.81280629025022, 153.15645218324957, 515.19782558493819] ]
batch_config = gp.batch_start(optimiser_config, initial_hyperparams)
logging.info('Using Batch Start Configuration')
else:
batch_config = optimiser_config
# Obtain the response function
responsefunction = gp.classifier.responses.get(responsename)
# Train the classifier!
logging.info('Learning...')
if batchlearn:
previous_history = np.load(filename_start)
learned_classifier = list(previous_history['learned_classifier'])
white_params = previous_history['white_params']
batch_config = \
gp.classifier.batch_start(optimiser_config, learned_classifier)
Fqw = white_fn(Fq, white_params)
else:
learned_classifier = gp.classifier.learn(Fw, y,
kerneldef, responsefunction, batch_config,
multimethod = multimethod, approxmethod = approxmethod,
train = train, ftol = 1e-10)
# Print the learnt kernel with its hyperparameters
print_function = gp.describer(kerneldef)
gp.classifier.utils.print_learned_kernels(print_function,
learned_classifier, y_unique)
# Print the matrix of learned classifier hyperparameters
logging.info('Matrix of learned hyperparameters')
gp.classifier.utils.print_hyperparam_matrix(learned_classifier)
"""Classifier Prediction"""
yq_pred, yq_mie, yq_lde = sea.model.predictions(learned_classifier, Fqw,
fusemethod = fusemethod)
yq_esd = gp.classifier.equivalent_standard_deviation(yq_lde)
miss_ratio = sea.model.miss_ratio(yq_pred, yq_truth)
yq_lde_mean = yq_lde.mean()
yq_mie_mean = yq_mie.mean()
yq_pred_hist, _ = np.histogram(yq_pred, bins = np.arange(23), density = True)
logging.info('Miss Ratio: {0:.2f}%'.format(100 * miss_ratio))
logging.info('Average Marginalised Linearised Model Differential Entropy: '\
'{0:.2f}'.format(yq_lde_mean))
logging.info('Average Marginalised Information Entropy: '\
'{0:.2f}'.format(yq_mie_mean))
"""Visualise Query Prediction and Entropy"""
fig = plt.figure(figsize = (19.2, 10.8))
sea.vis.scatter(
Xq[:, 0], Xq[:, 1],
c = yq_truth, vmin = y_unique[0], vmax = y_unique[-1], cmap = mycmap,
**map_kwargs)
sea.vis.describe_plot(title = 'Ground Truth Benthic Habitat Map',
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Habitat Labels', cticks = y_unique, cticklabels = y_names,
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE,
axis_scale = 1e3)
fig.tight_layout()
fig = plt.figure(figsize = (19.2, 10.8))
sea.vis.scatter(
Xq[:, 0], Xq[:, 1],
c = yq_pred, vmin = y_unique[0], vmax = y_unique[-1], cmap = mycmap,
**map_kwargs)
sea.vis.describe_plot(
title = 'Prediction Map [Miss Ratio: {0:.2f}\%]'.format(100 * miss_ratio),
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Habitat Labels', cticks = y_unique, cticklabels = y_names,
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE,
axis_scale = 1e3)
fig.tight_layout()
fig = plt.figure(figsize = (19.2, 10.8))
sea.vis.scatter(
Xq[:, 0], Xq[:, 1],
c = yq_mie, cmap = cm.coolwarm, colorcenter = 'none',
**map_kwargs)
sea.vis.describe_plot(title = 'Prediction Information Entropy',
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Information Entropy',
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE,
axis_scale = 1e3)
fig.tight_layout()
fig = plt.figure(figsize = (19.2, 10.8))
sea.vis.scatter(
Xq[:, 0], Xq[:, 1],
c = np.log(yq_mie), cmap = cm.coolwarm, colorcenter = 'none',
**map_kwargs)
sea.vis.describe_plot(title = 'Log Prediction Information Entropy',
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Information Entropy',
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE,
axis_scale = 1e3)
fig.tight_layout()
fig = plt.figure(figsize = (19.2, 10.8))
sea.vis.scatter(
Xq[:, 0], Xq[:, 1],
c = yq_lde, cmap = cm.coolwarm, colorcenter = colorcenter_lde,
**map_kwargs)
sea.vis.describe_plot(title = 'Linearised Model Differential Entropy',
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Differential Entropy',
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE,
axis_scale = 1e3)
fig.tight_layout()
fig = plt.figure(figsize = (19.2, 10.8))
sea.vis.scatter(
Xq[:, 0], Xq[:, 1],
c = yq_esd, cmap = cm.coolwarm, colorcenter = colorcenter_analysis,
**map_kwargs)
sea.vis.describe_plot(title = 'Equivalent Standard Deviation',
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Standard Deviation',
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE,
axis_scale = 1e3)
fig.tight_layout()
# fig = plt.figure(figsize = (8.0, 6.0))
# plt.bar()
"""Save Results"""
if SAVE_RESULTS:
gp.classifier.utils.save_all_figures(full_directory,
axis_equal = True, extension = 'eps', rcparams = rcparams)
shutil.copy2('./%s' % FILENAME , full_directory)
np.savez('%sinitialmodel.npz' % full_directory,
learned_classifier = learned_classifier,
t_seed = T_SEED, q_seed = Q_SEED,
n_train = n_train, n_query = n_query,
i_train = i_train, i_query = i_query,
yq_pred = yq_pred, yq_mie = yq_mie, yq_lde = yq_lde,
white_params = white_params)
if MODEL_ONLY:
plt.show()
return
"""Informative Seafloor Exploration: Setup"""
xq_now = feature_fn.closest_locations(np.array([[START_POINT1, START_POINT2]]))
horizon = HORIZON
h_steps = H_STEPS
if GREEDY or (METHOD == 'RANDOM') or (METHOD == 'FIXED'):
horizon /= h_steps
h_steps /= h_steps
theta_bound = np.deg2rad(40)
theta_bounds = theta_bound * np.ones(h_steps)
theta_stack_low = -theta_bounds
theta_stack_high = +theta_bounds
xtol_rel = 1e-2
ftol_rel = 1e-3
ctol = 1e-10
theta_stack_init = np.deg2rad(0) * np.ones(h_steps)
theta_stack_init[0] = np.deg2rad(180)
theta_stack_low[0] = np.deg2rad(0)
theta_stack_high[0] = np.deg2rad(360)
r = horizon/h_steps
choice_walltime = 1500.0
k_step = 1
m_step = 1
bound = 100
assert k_step == 1
"""Informative Seafloor Exploration: Initialisation"""
# The observed data till now
X_now = X.copy()
y_now = y.copy()
# Observe the current location
i_observe = sea.feature.closest_indices(xq_now, Xq)
yq_now = yq_truth[i_observe]
# Add the observed data to the training set
X_now = np.concatenate((X_now, xq_now[[-1]]), axis = 0)
y_now = np.append(y_now, yq_now)
# Add the new location to the array of travelled coordinates
xq1_nows = xq_now[:, 0]
xq2_nows = xq_now[:, 1]
yq_nows = yq_now.copy()
# Plot the current situation
fig1 = plt.figure(figsize = (19.2, 10.8))
fig2 = plt.figure(figsize = (19.2, 10.8))
fig3 = plt.figure(figsize = (19.2, 10.8))
fig4 = plt.figure(figsize = (19.2, 10.8))
# Start exploring
i_trials = 0
n_trials = N_TRIALS
miss_ratio_array = np.nan * np.ones(n_trials)
yq_mie_mean_array = np.nan * np.ones(n_trials)
yq_lde_mean_array = np.nan * np.ones(n_trials)
entropy_opt_array = np.nan * np.ones(n_trials)
yq_esd_mean_array = np.nan * np.ones(n_trials)
if METHOD == 'FIXED':
if FIXED_TYPE == 'curves':
turns = np.random.normal(loc = 0, scale = np.deg2rad(30), size = n_trials)
elif FIXED_TYPE == 'lines':
turns = np.zeros(n_trials)
n_turns = 5
turns[(np.arange(n_turns) * n_trials / n_turns).astype(int)] = np.random.normal(loc = 0, scale = np.deg2rad(30), size = n_turns)
elif FIXED_TYPE == 'spiral':
if MISSION_LENGTH > 0:
turns = np.array([np.linspace(np.deg2rad(30), np.deg2rad(0), num = MISSION_LENGTH) for i in np.arange(n_trials/MISSION_LENGTH)]).flatten()
else:
turns = np.linspace(np.deg2rad(30), np.deg2rad(0), num = n_trials)
else:
raise TypeError('No such FIXED method as %s' % METHOD)
while i_trials < n_trials:
if MISSION_LENGTH > 0:
if ((i_trials + 1) % MISSION_LENGTH == 0):
if METHOD in ['LMDE', 'MCPIE', 'AMPIE']:
acquisition_name = METHOD
xq_now = sea.explore.compute_new_starting_location(start_indices, Xq, Fqw,
learned_classifier, acquisition = acquisition_name)
else:
xq_now = Xq[np.random.choice(start_indices, size = 1, replace = False)]
if METHOD == 'FIXED':
theta_stack_init[0] += turns[i_trials]
theta_stack_init[0] = np.mod(theta_stack_init[0], 2 * np.pi)
# Propose a path
if m_step <= k_step:
if METHOD == 'RANDOM':
xq_path, theta_stack_opt, entropy_opt = \
sea.explore.random_path(theta_stack_init, r, xq_now[-1],
learned_classifier, feature_fn, white_params,
bound = bound,
chaos = CHAOS)
elif METHOD == 'FIXED':
xq_path, theta_stack_opt, entropy_opt = \
sea.explore.fixed_path(theta_stack_init, r, xq_now[-1],
learned_classifier, feature_fn, white_params,
bound = bound,
current_step = i_trials,
turns = turns)
else:
xq_path, theta_stack_opt, entropy_opt = \
sea.explore.optimal_path(theta_stack_init, r, xq_now[-1],
learned_classifier, feature_fn, white_params,
objective = METHOD,
turn_limit = theta_bound,
bound = bound,
theta_stack_low = theta_stack_low,
theta_stack_high = theta_stack_high,
walltime = choice_walltime,
xtol_rel = xtol_rel,
ftol_rel = ftol_rel,
ctol = ctol,
globalopt = False,
n_draws = N_DRAWS,
depth_penalty = DEPTH_PENALTY)
logging.info('Optimal Joint Entropy: %.5f' % entropy_opt)
m_step = M_STEP
logging.info('Taking %d steps' % m_step)
else:
m_step -= 1
theta_stack_opt = theta_stack_init.copy()
xq_path = sea.explore.forward_path_model(theta_stack_init,
r, xq_now[-1])
logging.info('%d steps left' % m_step)
# Path steps into the proposed path
xq_now = xq_path[:k_step]
# Initialise the next path angles
theta_stack_init = sea.explore.shift_path(theta_stack_opt,
k_step = k_step, theta_bounds = theta_bounds)
np.clip(theta_stack_init,
theta_stack_low + 1e-4, theta_stack_high - 1e-4,
out = theta_stack_init)
# Observe the current location
i_observe = sea.feature.closest_indices(xq_now, Xq)
yq_now = yq_truth[i_observe]
# Add the observed data to the training set
X_now = np.concatenate((X_now, xq_now), axis = 0)
y_now = np.append(y_now, yq_now)
# Add the new location to the array of travelled coordinates
xq1_nows = np.append(xq1_nows, xq_now[:, 0])
xq2_nows = np.append(xq2_nows, xq_now[:, 1])
yq_nows = np.append(yq_nows, yq_now)
# Update that into the model
Fw_now, white_params = feature_fn(X_now)
logging.info('Learning Classifier...')
batch_config = \
gp.classifier.batch_start(optimiser_config, learned_classifier)
try:
learned_classifier = gp.classifier.learn(Fw_now, y_now,
kerneldef, responsefunction, batch_config,
multimethod = multimethod, approxmethod = approxmethod,
train = True, ftol = 1e-6)
except Exception as e:
logging.warning('Training failed: {0}'.format(e))
try:
learned_classifier = gp.classifier.learn(Fw_now, y_now,
kerneldef, responsefunction, batch_config,
multimethod = multimethod, approxmethod = approxmethod,
train = False, ftol = 1e-6)
except Exception as e:
logging.warning('Learning also failed: {0}'.format(e))
pass
logging.info('Finished Learning')
# This is the finite horizon optimal route
fqw_path = feature_fn(xq_path, white_params)
xq1_path = xq_path[:, 0][k_step:]
xq2_path = xq_path[:, 1][k_step:]
yq_path = gp.classifier.classify(gp.classifier.predict(fqw_path,
learned_classifier), y_unique)[k_step:]
""" Computing Analysis Maps """
Fqw = white_fn(Fq, white_params)
yq_pred, yq_mie, yq_lde = \
sea.model.predictions(learned_classifier, Fqw,
fusemethod = fusemethod)
yq_esd = gp.classifier.equivalent_standard_deviation(yq_lde)
miss_ratio = sea.model.miss_ratio(yq_pred, yq_truth)
yq_mie_mean = yq_mie.mean()
yq_lde_mean = yq_lde.mean()
yq_esd_mean = yq_esd.mean()
logging.info('Miss Ratio: {0:.2f}%'.format(100 * miss_ratio))
logging.info('Average Marginalised Linearised Model Differential Entropy: '\
'{0:.2f}'.format(yq_lde_mean))
logging.info('Average Marginalised Information Entropy: '\
'{0:.2f}'.format(yq_mie_mean))
""" Save history """
miss_ratio_array[i_trials] = miss_ratio
yq_mie_mean_array[i_trials] = yq_mie_mean
yq_lde_mean_array[i_trials] = yq_lde_mean
yq_esd_mean_array[i_trials] = yq_esd_mean
entropy_opt_array[i_trials] = entropy_opt
# Find the bounds of the entropy predictions
vmin1 = yq_lde.min()
vmax1 = yq_lde.max()
vmin2 = yq_mie.min()
vmax2 = yq_mie.max()
vmin3 = yq_esd.min()
vmax3 = yq_esd.max()
logging.info('Plotting...')
if ((i_trials + 1) % MISSION_LENGTH == 0) or ((i_trials + 2) % MISSION_LENGTH == 0) or (i_trials <= 10) or (((i_trials + 1) % SAVE_TRIALS) == 0):
SAVE_EPS = True
else:
SAVE_EPS = False
""" Linearised Entropy Map """
# Prepare Figure 1
plt.figure(fig1.number)
plt.clf()
sea.vis.scatter(
Xq[:, 0], Xq[:, 1],
c = yq_lde, cmap = cm.coolwarm, colorcenter = colorcenter_lde,
**map_kwargs)
sea.vis.describe_plot(title = 'Linearised Model Differential Entropy',
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Differential Entropy',
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE,
axis_scale = 1e3)
# Plot the path on top
sea.vis.scatter(xq1_nows, xq2_nows, c = yq_nows, s = 60,
facecolors = 'none',
vmin = y_unique[0], vmax = y_unique[-1],
cmap = mycmap)
if MISSION_LENGTH == 0:
sea.vis.plot(xq1_nows, xq2_nows, c = 'k', linewidth = 2)
else:
sea.vis.plot(xq1_nows, xq2_nows, c = 'k', linestyle = '--', linewidth = 1)
xq1_nows_split = sea.vis.split_array(xq1_nows, MISSION_LENGTH)
xq2_nows_split = sea.vis.split_array(xq2_nows, MISSION_LENGTH)
[sea.vis.plot(xq1_nows_split[i], xq2_nows_split[i], c = 'k', linewidth = 2) for i in range(xq1_nows_split.shape[0])]
sea.vis.scatter(xq_now[:, 0], xq_now[:, 1], c = yq_now, s = 120,
vmin = y_unique[0], vmax = y_unique[-1],
cmap = mycmap)
# Plot the horizon
gp.classifier.utils.plot_circle(xq_now[-1], horizon, c = 'k',
linewidth = 2, marker = '.')
plt.gca().arrow(xq_now[-1][0], xq_now[-1][1] + r, 0, -r/4,
head_width = r/4, head_length = r/4, fc = 'k', ec = 'k')
# Save the plot
fig1.tight_layout()
plt.gca().set_aspect('equal', adjustable = 'box')
plt.savefig('%slde%d.png'
% (full_directory, i_trials + 1))
if SAVE_EPS:
plt.savefig('%slde%d.eps'
% (full_directory, i_trials + 1))
# Plot the proposed path
sea.vis.scatter(xq1_path, xq2_path, c = yq_path,
s = 60, marker = 'D',
vmin = y_unique[0], vmax = y_unique[-1], cmap = mycmap)
sea.vis.plot(xq1_path, xq2_path, c = 'k', linewidth = 2)
# Save the plot
fig1.tight_layout()
plt.gca().set_aspect('equal', adjustable = 'box')
plt.savefig('%slde_propose%d.png'
% (full_directory, i_trials + 1))
if SAVE_EPS:
plt.savefig('%slde_propose%d.eps'
% (full_directory, i_trials + 1))
""" True Entropy Map """
# Prepare Figure 3
plt.figure(fig2.number)
plt.clf()
sea.vis.scatter(
Xq[:, 0], Xq[:, 1],
c = yq_mie, cmap = cm.coolwarm, colorcenter = colorcenter_analysis,
**map_kwargs)
sea.vis.describe_plot(title = 'Prediction Information Entropy',
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Information Entropy',
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE,
axis_scale = 1e3)
# Plot the path on top
sea.vis.scatter(xq1_nows, xq2_nows, c = yq_nows, s = 60,
facecolors = 'none',
vmin = y_unique[0], vmax = y_unique[-1],
cmap = mycmap)
if MISSION_LENGTH == 0:
sea.vis.plot(xq1_nows, xq2_nows, c = 'k', linewidth = 2)
else:
sea.vis.plot(xq1_nows, xq2_nows, c = 'k', linestyle = '--', linewidth = 1)
xq1_nows_split = sea.vis.split_array(xq1_nows, MISSION_LENGTH)
xq2_nows_split = sea.vis.split_array(xq2_nows, MISSION_LENGTH)
[sea.vis.plot(xq1_nows_split[i], xq2_nows_split[i], c = 'k', linewidth = 2) for i in range(xq1_nows_split.shape[0])]
sea.vis.scatter(xq_now[:, 0], xq_now[:, 1], c = yq_now, s = 120,
vmin = y_unique[0], vmax = y_unique[-1],
cmap = mycmap)
# Plot the horizon
gp.classifier.utils.plot_circle(xq_now[-1], horizon, c = 'k',
linewidth = 2, marker = '.')
plt.gca().arrow(xq_now[-1][0], xq_now[-1][1] + r, 0, -r/4,
head_width = r/4, head_length = r/4, fc = 'k', ec = 'k')
# Save the plot
fig2.tight_layout()
plt.gca().set_aspect('equal', adjustable = 'box')
plt.savefig('%smie%d.png'
% (full_directory, i_trials + 1))
if SAVE_EPS:
plt.savefig('%smie%d.eps'
% (full_directory, i_trials + 1))
# Plot the proposed path
sea.vis.scatter(xq1_path, xq2_path, c = yq_path,
s = 60, marker = 'D',
vmin = y_unique[0], vmax = y_unique[-1], cmap = mycmap)
sea.vis.plot(xq1_path, xq2_path, c = 'k', linewidth = 2)
# Save the plot
fig2.tight_layout()
plt.gca().set_aspect('equal', adjustable = 'box')
plt.savefig('%smie_propose%d.png'
% (full_directory, i_trials + 1))
if SAVE_EPS:
plt.savefig('%smie_propose%d.eps'
% (full_directory, i_trials + 1))
""" Class Prediction Map """
# Prepare Figure 4
plt.figure(fig3.number)
plt.clf()
sea.vis.scatter(
Xq[:, 0], Xq[:, 1],
c = yq_pred, vmin = y_unique[0], vmax = y_unique[-1], cmap = mycmap,
**map_kwargs)
sea.vis.describe_plot(
title = 'Prediction Map [Miss Ratio: {0:.2f}\%]'.format(
100 * miss_ratio),
xlabel = 'x [Eastings (km)]', ylabel = 'y [Northings (km)]',
clabel = 'Habitat Labels', cticks = y_unique, cticklabels = y_names,
vis_range = vis_range, aspect_equal = True,
fontsize = FONTSIZE, fontname = FONTNAME, ticksize = TICKSIZE,
axis_scale = 1e3)
# Plot the path on top
sea.vis.scatter(xq1_nows, xq2_nows, c = yq_nows, s = 60,
facecolors = 'none',
vmin = y_unique[0], vmax = y_unique[-1],
cmap = mycmap)
if MISSION_LENGTH == 0:
sea.vis.plot(xq1_nows, xq2_nows, c = 'k', linewidth = 2)
else:
sea.vis.plot(xq1_nows, xq2_nows, c = 'k', linestyle = '--', linewidth = 1)
xq1_nows_split = sea.vis.split_array(xq1_nows, MISSION_LENGTH)
xq2_nows_split = sea.vis.split_array(xq2_nows, MISSION_LENGTH)
[sea.vis.plot(xq1_nows_split[i], xq2_nows_split[i], c = 'k', linewidth = 2) for i in range(xq1_nows_split.shape[0])]
sea.vis.scatter(xq_now[:, 0], xq_now[:, 1], c = yq_now, s = 120,
vmin = y_unique[0], vmax = y_unique[-1],
cmap = mycmap)
# Plot the horizon
gp.classifier.utils.plot_circle(xq_now[-1], horizon, c = 'k',
linewidth = 2, marker = '.')
plt.gca().arrow(xq_now[-1][0], xq_now[-1][1] + r, 0, -r/4,
head_width = r/4, head_length = r/4, fc = 'k', ec = 'k')
# Save the plot
fig3.tight_layout()
plt.gca().set_aspect('equal', adjustable = 'box')
plt.savefig('%spred%d.png'
% (full_directory, i_trials + 1))
if SAVE_EPS:
plt.savefig('%spred%d.eps'
% (full_directory, i_trials + 1))
# Plot the proposed path
sea.vis.scatter(xq1_path, xq2_path, c = yq_path,
s = 60, marker = 'D',
vmin = y_unique[0], vmax = y_unique[-1], cmap = mycmap)
sea.vis.plot(xq1_path, xq2_path, c = 'k', linewidth = 2)
# Save the plot
fig3.tight_layout()
plt.gca().set_aspect('equal', adjustable = 'box')
plt.savefig('%spred_propose%d.png'
% (full_directory, i_trials + 1))
if SAVE_EPS:
plt.savefig('%spred_propose%d.eps'
% (full_directory, i_trials + 1))
# Prepare Figure 5
plt.figure(fig4.number)
plt.clf()
fontsize = 24
ticksize = 14
steps_array = np.arange(i_trials + 1) + 1
ax = plt.subplot(4, 1, 1)
plt.plot(steps_array, 100 * miss_ratio_array[:(i_trials + 1)])
plt.title('Percentage of Prediction Misses', fontsize = fontsize)
plt.ylabel('Misses (\%)', fontsize = fontsize)
ax.set_xticklabels( () )
ax = plt.subplot(4, 1, 2)
plt.plot(steps_array, yq_lde_mean_array[:(i_trials + 1)])
plt.title('Average Marginalised Differential Entropy',
fontsize = fontsize)
plt.ylabel('Entropy (nats)', fontsize = fontsize)
ax.set_xticklabels( () )
ax = plt.subplot(4, 1, 3)
plt.plot(steps_array, yq_mie_mean_array[:(i_trials + 1)])
plt.title('Average Marginalised Information Entropy',
fontsize = fontsize)
plt.ylabel('Entropy (nats)', fontsize = fontsize)
ax.set_xticklabels( () )
ax = plt.subplot(4, 1, 4)
plt.gca().get_xaxis().get_major_formatter().set_useOffset(False)
plt.plot(steps_array, entropy_opt_array[:(i_trials + 1)])
plt.title('Entropy Metric of Proposed Path', fontsize = fontsize)
plt.ylabel('Entropy (nats)', fontsize = fontsize)
plt.xlabel('Steps', fontsize = fontsize)
for tick in plt.gca().xaxis.get_major_ticks():
tick.label.set_fontsize(ticksize)
for tick in plt.gca().yaxis.get_major_ticks():
tick.label.set_fontsize(ticksize)
# Save the plot
fig4.tight_layout()
plt.savefig('%shistory%d.png'
% (full_directory, i_trials + 1))
logging.info('Plotted and Saved Iteration')
# Move on to the next step
i_trials += 1
np.savez('%shistory%d.npz' % (full_directory, i_trials),
learned_classifier = learned_classifier,
miss_ratio_array = miss_ratio_array,
yq_lde_mean_array = yq_lde_mean_array,
yq_mie_mean_array = yq_mie_mean_array,
entropy_opt_array = entropy_opt_array,
yq_esd_mean_array = yq_esd_mean_array,
t_seed = T_SEED, q_seed = Q_SEED,
n_train = n_train, n_query = n_query,
i_train = i_train, i_query = i_query,
yq_lde = yq_lde,
yq_mie = yq_mie,
yq_pred = yq_pred,
white_params = white_params,
X_now = X_now,
Fw_now = Fw_now,
y_now = y_now,
xq1_path = xq1_path,
xq2_path = xq2_path,
fqw_path = fqw_path,
yq_path = yq_path,
xq1_nows = xq1_nows,
xq2_nows = xq2_nows,
yq_nows = yq_nows,
vis_range = vis_range,
colorcenter_analysis = colorcenter_analysis,
colorcenter_lde = colorcenter_lde,
y_unique = y_unique,
mycmap = mycmap,
i_trials = i_trials,
theta_stack_opt = theta_stack_opt,
theta_stack_init = theta_stack_init,
xq_path = xq_path,
xq_now = xq_now,
yq_now = yq_now,
i_observe = i_observe,
horizon = horizon,
h_steps = h_steps,
r = r,
y_names = y_names,
FONTSIZE = FONTSIZE,
FONTNAME = FONTNAME,
TICKSIZE = TICKSIZE,
SAVE_TRIALS = SAVE_TRIALS)
logging.info('White Params: {0}'.format(white_params))
np.savez('%shistory.npz' % full_directory,
learned_classifier = learned_classifier,
miss_ratio_array = miss_ratio_array,
yq_lde_mean_array = yq_lde_mean_array,
yq_mie_mean_array = yq_mie_mean_array,
entropy_opt_array = entropy_opt_array,
yq_esd_mean_array = yq_esd_mean_array,
t_seed = T_SEED, q_seed = Q_SEED,
n_train = n_train, n_query = n_query,
i_train = i_train, i_query = i_query,
yq_lde = yq_lde,
yq_mie = yq_mie,
yq_pred = yq_pred,
white_params = white_params,
X_now = X_now,
Fw_now = Fw_now,
y_now = y_now,
xq1_path = xq1_path,
xq2_path = xq2_path,
fqw_path = fqw_path,
yq_path = yq_path,
xq1_nows = xq1_nows,
xq2_nows = xq2_nows,
yq_nows = yq_nows,
vis_range = vis_range,
colorcenter_analysis = colorcenter_analysis,
colorcenter_lde = colorcenter_lde,
y_unique = y_unique,
mycmap = mycmap,
i_trials = i_trials,
theta_stack_opt = theta_stack_opt,
theta_stack_init = theta_stack_init,
xq_path = xq_path,
xq_now = xq_now,
yq_now = yq_now,
i_observe = i_observe,
horizon = horizon,
h_steps = h_steps,
r = r,
y_names = y_names,
FONTSIZE = FONTSIZE,
FONTNAME = FONTNAME,
TICKSIZE = TICKSIZE,
SAVE_TRIALS = SAVE_TRIALS)
plt.show()
ax1.set_yticks([])
ax1.set_xticks([])
ax1.axis("off")
ax = fig.add_subplot(1, 2, 1)
ax = plt.subplot2grid((1, 40), (0, 0), colspan=10, axisbg="white")
fig.subplots_adjust(wspace=0, hspace=0)
ax1.set_title("Roary matrix\n(%d gene clusters)" % roary.shape[0])
if options.labels:
fsize = 12 - 0.1 * roary.shape[1]
if fsize < 7:
fsize = 7
with plt.rc_context({"font.size": fsize}):
Phylo.draw(
t,
axes=ax,
show_confidence=False,
label_func=lambda x: str(x)[:10],
xticks=([],),
yticks=([],),
ylabel=("",),
xlabel=("",),
xlim=(-mdist * 0.1, mdist + mdist * 0.45 - mdist * roary.shape[1] * 0.001),
axis=("off",),
title=("Tree\n(%d strains)" % roary.shape[1],),
do_show=False,
)
else:
def draw_termite_plot(values_mat, col_labels, row_labels,
highlight_cols=None, highlight_colors=None,
save=False):
"""
Make a "termite" plot, typically used for assessing topic models with a tabular
layout that promotes comparison of terms both within and across topics.
Args:
values_mat (``np.ndarray`` or matrix): matrix of values with shape
(# row labels, # col labels) used to size the dots on the grid
col_labels (seq[str]): labels used to identify x-axis ticks on the grid
row_labels(seq[str]): labels used to identify y-axis ticks on the grid
highlight_cols (int or seq[int], optional): indices for columns
to visually highlight in the plot with contrasting colors
highlight_colors (tuple of 2-tuples): each 2-tuple corresponds to a pair
of (light/dark) matplotlib-friendly colors used to highlight a single
column; if not specified (default), a good set of 6 pairs are used
save (str, optional): give the full /path/to/fname on disk to save figure
Returns:
``matplotlib.axes.Axes.axis``: axis on which termite plot is plotted
Raises:
ValueError: if more columns are selected for highlighting than colors
or if any of the inputs' dimensions don't match
References:
.. Chuang, Jason, Christopher D. Manning, and Jeffrey Heer. "Termite:
Visualization techniques for assessing textual topic models."
Proceedings of the International Working Conference on Advanced
Visual Interfaces. ACM, 2012.
.. seealso:: :func:`TopicModel.termite_plot <textacy.tm.TopicModel.termite_plot>`
"""
try:
plt
except NameError:
raise ImportError(
'matplotlib is not installed, so textacy.viz won\'t work; install it \
individually, or along with textacy via `pip install textacy[viz]`')
n_rows, n_cols = values_mat.shape
max_val = np.max(values_mat)
if n_rows != len(row_labels):
msg = "values_mat and row_labels dimensions don't match: {} vs. {}".format(
n_rows, len(row_labels))
raise ValueError(msg)
if n_cols != len(col_labels):
msg = "values_mat and col_labels dimensions don't match: {} vs. {}".format(
n_cols, len(col_labels))
raise ValueError(msg)
if highlight_colors is None:
highlight_colors = COLOR_PAIRS
if highlight_cols is not None:
if isinstance(highlight_cols, int):
highlight_cols = (highlight_cols,)
elif len(highlight_cols) > len(highlight_colors):
msg = 'no more than {} columns may be highlighted at once'.format(
len(highlight_colors))
raise ValueError(msg)
highlight_colors = {hc: COLOR_PAIRS[i]
for i, hc in enumerate(highlight_cols)}
with plt.rc_context(RC_PARAMS):
fig, ax = plt.subplots(figsize=(pow(n_cols, 0.8), pow(n_rows, 0.66)))
_ = ax.set_yticks(range(n_rows))
yticklabels = ax.set_yticklabels(row_labels,
fontsize=14, color='gray')
if highlight_cols is not None:
for i, ticklabel in enumerate(yticklabels):
max_tick_val = max(values_mat[i, hc] for hc in highlight_cols)
for hc in highlight_cols:
if max_tick_val > 0 and values_mat[i, hc] == max_tick_val:
ticklabel.set_color(highlight_colors[hc][1])
ax.get_xaxis().set_ticks_position('top')
_ = ax.set_xticks(range(n_cols))
xticklabels = ax.set_xticklabels(col_labels,
fontsize=14, color='gray',
rotation=30, ha='left')
if highlight_cols is not None:
gridlines = ax.get_xgridlines()
for i, ticklabel in enumerate(xticklabels):
if i in highlight_cols:
ticklabel.set_color(highlight_colors[i][1])
gridlines[i].set_color(highlight_colors[i][0])
gridlines[i].set_alpha(0.5)
for col_ind in range(n_cols):
if highlight_cols is not None and col_ind in highlight_cols:
ax.scatter([col_ind for _ in range(n_rows)],
[i for i in range(n_rows)],
s=600 * (values_mat[:, col_ind] / max_val),
alpha=0.5, linewidth=1,
color=highlight_colors[col_ind][0],
edgecolor=highlight_colors[col_ind][1])
else:
ax.scatter([col_ind for _ in range(n_rows)],
[i for i in range(n_rows)],
s=600 * (values_mat[:, col_ind] / max_val),
alpha=0.5, linewidth=1,
color='lightgray', edgecolor='gray')
_ = ax.set_xlim(left=-1, right=n_cols)
_ = ax.set_ylim(bottom=-1, top=n_rows)
ax.invert_yaxis() # otherwise, values/labels go from bottom to top
if save:
fig.savefig(save, bbox_inches='tight', dpi=100)
return ax
def create_icon_axes(fig, ax_position, lw_bars, lw_grid, lw_border, rgrid):
"""
Create a polar axes containing the Matplotlib radar plot.
Parameters
----------
fig : matplotlib.figure.Figure
The figure to draw into.
ax_position : (float, float, float, float)
The position of the created Axes in figure coordinates as
(x, y, width, height).
lw_bars : float
The linewidth of the bars.
lw_grid : float
The linewidth of the grid.
lw_border : float
The linewidth of the Axes border.
rgrid : array-like
Positions of the radial grid.
Returns
-------
ax : matplotlib.axes.Axes
The created Axes.
"""
with plt.rc_context({
'axes.edgecolor': MPL_BLUE,
'axes.linewidth': lw_border
}):
ax = fig.add_axes(ax_position, projection='polar')
ax.set_axisbelow(True)
N = 7
arc = 2. * np.pi
theta = np.arange(0.0, arc, arc / N)
radii = np.array([2, 6, 8, 7, 4, 5, 8])
width = np.pi / 4 * np.array([0.4, 0.4, 0.6, 0.8, 0.2, 0.5, 0.3])
bars = ax.bar(theta,
radii,
width=width,
bottom=0.0,
align='edge',
edgecolor='0.3',
lw=lw_bars)
for r, bar in zip(radii, bars):
color = *cm.jet(r / 10.)[:3], 0.6 # color from jet with alpha=0.6
bar.set_facecolor(color)
ax.tick_params(labelbottom=False,
labeltop=False,
labelleft=False,
labelright=False)
ax.grid(lw=lw_grid, color='0.9')
ax.set_rmax(9)
ax.set_yticks(rgrid)
# The actual visible background - extends a bit beyond the axis
ax.add_patch(
Rectangle((0, 0),
arc,
9.58,
facecolor='white',
zorder=0,
clip_on=False,
in_layout=False))
return ax
def plot_data(directory, *args, ncolors = 1, descript = '', label_font_size = 24, ncol = 4):
L = 0.0
colors = cm.rainbow(np.linspace(0 + L, 1 - L, num = ncolors))
fontsize = 64
axis_tick_font_size = 30
params = {
'backend': 'ps',
# 'axes.labelsize': 10,
# 'text.fontsize': 10,
# 'legend.fontsize': 10,
# 'xtick.labelsize': 8,
# 'ytick.labelsize': 8,
'text.usetex': True,
'figure.figsize': fig_size(350.0)
}
plt.rc_context(params)
fig = plt.figure(figsize = (20, 15))
ax1 = fig.add_subplot(211)
# ax2 = fig.add_subplot(312)
ax3 = fig.add_subplot(212)
mission_starts = np.array([40, 80, 120, 160, 199]) * (5000.0/30.0)
[ax1.axvline(x, color = 'k', linestyle = '--') for x in mission_starts]
[ax3.axvline(x, color = 'k', linestyle = '--') for x in mission_starts]
percentages = np.arange(0, 100, 10)
[ax1.axhline(y, color = 'k', linestyle = '--') for y in percentages]
entropies = np.arange(1.0, 2.8, 0.2)
[ax3.axhline(y, color = 'k', linestyle = '--') for y in entropies]
for arg in args:
miss_ratio_array, yq_lde_mean_array, yq_mie_mean_array, info = arg
iterations = np.arange(miss_ratio_array.shape[0]) + 1
color = colors[info['index']]
label = info['label']
steps = info['steps']
if 'linestyle' in info:
linestyle = info['linestyle']
else:
linestyle = 'solid'
iterations_plt = np.append(0, iterations[:steps]) * (5000.0/30.0)
miss_ratio_plt = np.append(99.39, 100 * miss_ratio_array[:steps])
yq_lde_plt = np.append(-0.20, yq_lde_mean_array[:steps])
yq_mie_plt = np.append(2.56, yq_mie_mean_array[:steps])
ax1.plot(iterations_plt, miss_ratio_plt, c = color, label = label, linewidth = 2.0, linestyle = linestyle)
ax1.set_ylim((0, 100))
# ax2.plot(iterations_plt, yq_lde_plt, c = color, label = label, linewidth = 2.0, linestyle = linestyle)
ax3.plot(iterations_plt, yq_mie_plt, c = color, label = label, linewidth = 2.0, linestyle = linestyle)
ax1.legend(bbox_to_anchor = (0., 0.0, 1., .05), loc = 3,
ncol = ncol, borderaxespad = 0., fontsize = label_font_size)
ax1.set_title('Percentage of Map Prediction Misses', fontsize = fontsize)
ax1.set_ylabel('Misses (\%)', fontsize = fontsize)
ax1.set_xticklabels( () )
# ax2.set_title('Average Marginalised L. Model Differential Entropy', fontsize = fontsize)
# ax2.set_ylabel('Entropy (nats)', fontsize = fontsize)
# ax2.set_xticklabels( () )
ax3.set_title('Avg. Marg. Prediction Information Entropy', fontsize = fontsize)
ax3.set_ylabel('Entropy (nats)', fontsize = fontsize)
ax3.get_xaxis().get_major_formatter().set_useOffset(False)
ax3.set_xlabel('Distance Traveled (km)', fontsize = fontsize)
for tick in ax1.yaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
# for tick in ax2.yaxis.get_major_ticks():
# tick.label.set_fontsize(axis_tick_font_size)
for tick in ax3.xaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
for tick in ax3.yaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
# ticks = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(x/1e3))
# ax3.xaxis.set_major_formatter(ticks)
# ax3.yaxis.set_major_formatter(ticks)
# Save the plot
fig.tight_layout()
fig.savefig('%sserial_compare_%s.eps' % (directory, descript))
def decorator(*args, **kwargs):
with plt.rc_context():
return func(*args, **kwargs)
def main():
FONTSIZE = 50
FONTNAME = 'Sans Serif'
TICKSIZE = 24
rcparams = {
'backend': 'pdf',
'axes.labelsize': TICKSIZE,
'text.fontsize': FONTSIZE,
'legend.fontsize': FONTSIZE,
'xtick.labelsize': TICKSIZE,
'ytick.labelsize': TICKSIZE,
'text.usetex': True,
}
plt.rc_context(rcparams)
"""
Demostration Options
"""
logging.basicConfig(level = logging.DEBUG)
# If using parallel functionality, you must call this to set the appropriate
# logging level
gp.classifier.set_multiclass_logging_level(logging.DEBUG)
np.random.seed(100)
# Feature Generation Parameters and Demonstration Options
SAVE_OUTPUTS = True # We don't want to make files everywhere for a demo.
SHOW_RAW_BINARY = True
test_range_min = -2.5
test_range_max = +2.5
test_ranges = (test_range_min, test_range_max)
n_train = 500
n_query = 1000
n_dims = 2 # <- Must be 2 for vis
n_cores = None # number of cores for multi-class (None -> default: c-1)
walltime = 300.0
approxmethod = 'laplace' # 'laplace' or 'pls'
multimethod = 'OVA' # 'AVA' or 'OVA', ignored for binary problem
fusemethod = 'EXCLUSION' # 'MODE' or 'EXCLUSION', ignored for binary
responsename = 'probit' # 'probit' or 'logistic'
batch_start = False
entropy_threshold = None
n_draws = 6
n_draws_est = 2500
rows_subplot = 2
cols_subplot = 3
assert rows_subplot * cols_subplot >= n_draws
# Decision boundaries
db1 = lambda x1, x2: (((x1 - 1)**2 + x2**2/4) *
(0.9*(x1 + 1)**2 + x2**2/2) < 1.6) & \
((x1 + x2) < 1.5)
db2 = lambda x1, x2: (((x1 - 1)**2 + x2**2/4) *
(0.9*(x1 + 1)**2 + x2**2/2) > 0.3)
db3 = lambda x1, x2: ((x1 + x2) < 2) & ((x1 + x2) > -2.2)
db4 = lambda x1, x2: ((x1 - 0.75)**2 + (x2 + 0.8)**2 > 0.3**2)
db5 = lambda x1, x2: ((x1/2)**2 + x2**2 > 0.3)
db6 = lambda x1, x2: (((x1)/8)**2 + (x2 + 1.5)**2 > 0.2**2)
db7 = lambda x1, x2: (((x1)/8)**2 + ((x2 - 1.4)/1.25)**2 > 0.2**2)
db4a = lambda x1, x2: ((x1 - 1.25)**2 + (x2 - 1.25)**2 > 0.5**2) & ((x1 - 0.75)**2 + (x2 + 1.2)**2 > 0.6**2) & ((x1 + 0.75)**2 + (x2 + 1.2)**2 > 0.3**2) & ((x1 + 1.3)**2 + (x2 - 1.3)**2 > 0.4**2)
db5a = lambda x1, x2: ((x1/2)**2 + x2**2 > 0.3) & (x1 > 0)
db5b = lambda x1, x2: ((x1/2)**2 + x2**2 > 0.3) & (x1 < 0) & ((x1 + 0.75)**2 + (x2 - 1.2)**2 > 0.6**2)
db1a = lambda x1, x2: (((x1 - 1)**2 + x2**2/4) *
(0.9*(x1 + 1)**2 + x2**2/2) < 1.6) & \
((x1 + x2) < 1.6) | ((x1 + 0.75)**2 + (x2 + 1.2)**2 < 0.6**2)
db1b = lambda x1, x2: (((x1 - 1)**2 + x2**2/4) *
(0.9*(x1 + 1)**2 + x2**2/2) < 1.6) & ((x1/2)**2 + (x2)**2 > 0.4**2) & \
((x1 + x2) < 1.5) | ((x1 + 0.75)**2 + (x2 - 1.5)**2 < 0.4**2) | ((x1 + x2) > 2.1) & (x1 < 1.8) & (x2 < 1.8) # | (((x1 + 0.25)/4)**2 + (x2 + 1.5)**2 < 0.32**2) # & (((x1 + 0.25)/4)**2 + (x2 + 1.5)**2 > 0.18**2)
db1c = lambda x1, x2: (((x1 - 1)**2 + x2**2/4) *
(0.9*(x1 + 1)**2 + x2**2/2) < 1.6) & ((x1/2)**2 + (x2)**2 > 0.4**2) & \
((x1 + x2) < 1.5) | ((x1 + 0.75)**2 + (x2 - 1.5)**2 < 0.4**2) | ((x1 + x2) > 2.1) & (x1 < 1.8) & (x2 < 1.8) | (((x1 + 0.25)/4)**2 + (x2 + 1.75)**2 < 0.32**2) & (((x1 + 0.25)/4)**2 + (x2 + 1.75)**2 > 0.18**2)
db8 = lambda x1, x2: (np.sin(2*x1 + 3*x2) > 0) | (((x1 - 1)**2 + x2**2/4) *
(0.9*(x1 + 1)**2 + x2**2/2) < 1.4) & \
((x1 + x2) < 1.5) | (x1 < -1.9) | (x1 > +1.9) | (x2 < -1.9) | (x2 > +1.9) | ((x1 + 0.75)**2 + (x2 - 1.5)**2 < 0.3**2)
# db9 = lambda x1, x2: ((x1)**2 + (x2)**2 < 0.3**2) | ((x1)**2 + (x2)**2 > 0.5**2) |
decision_boundary = [db5b, db1c, db4a] # db1b # [db5b, db1c, db4a] # [db5b, db1c, db4a, db8, db6, db7]
"""
Data Generation
"""
X = np.random.uniform(test_range_min + 0.5, test_range_max - 0.5,
size = (n_train, n_dims))
x1 = X[:, 0]
x2 = X[:, 1]
Xw, whitenparams = pre.whiten(X)
n_train = X.shape[0]
logging.info('Training Points: %d' % n_train)
# Training Labels
y = gp.classifier.utils.make_decision(X, decision_boundary)
y_unique = np.unique(y)
assert y_unique.dtype == int
if y_unique.shape[0] == 2:
mycmap = cm.get_cmap(name = 'bone', lut = None)
mycmap2 = cm.get_cmap(name = 'BrBG', lut = None)
else:
mycmap = cm.get_cmap(name = 'gist_rainbow', lut = None)
mycmap2 = cm.get_cmap(name = 'gist_rainbow', lut = None)
"""
Classifier Training
"""
# Training
fig = plt.figure()
gp.classifier.utils.visualise_decision_boundary(plt.gca(),
test_range_min, test_range_max, decision_boundary)
plt.scatter(x1, x2, c = y, marker = 'x', cmap = mycmap)
plt.title('Training Labels')
plt.xlabel('$x_{1}$')
plt.ylabel('$x_{2}$')
cbar = plt.colorbar()
cbar.set_ticks(y_unique)
cbar.set_ticklabels(y_unique)
plt.xlim((test_range_min, test_range_max))
plt.ylim((test_range_min, test_range_max))
plt.gca().patch.set_facecolor('gray')
print('Plotted Training Set')
plt.show()
# Training
print('===Begin Classifier Training===')
optimiser_config = gp.OptConfig()
optimiser_config.sigma = gp.auto_range(kerneldef)
optimiser_config.walltime = walltime
# User can choose to batch start each binary classifier with different
# initial hyperparameters for faster training
if batch_start:
if y_unique.shape[0] == 2:
initial_hyperparams = [100, 0.1, 0.1]
elif multimethod == 'OVA':
initial_hyperparams = [ [356.468, 0.762, 0.530], \
[356.556, 0.836, 0.763], \
[472.006, 1.648, 1.550], \
[239.720, 1.307, 0.721] ]
elif multimethod == 'AVA':
initial_hyperparams = [ [14.9670, 0.547, 0.402], \
[251.979, 1.583, 1.318], \
[420.376, 1.452, 0.750], \
[780.641, 1.397, 1.682], \
[490.353, 2.299, 1.526], \
[73.999, 1.584, 0.954]]
else:
raise ValueError
batch_config = gp.batch_start(optimiser_config, initial_hyperparams)
else:
batch_config = optimiser_config
# Obtain the response function
responsefunction = gp.classifier.responses.get(responsename)
# Train the classifier!
learned_classifier = gp.classifier.learn(Xw, y, kerneldef,
responsefunction, batch_config,
multimethod = multimethod, approxmethod = approxmethod,
train = True, ftol = 1e-6, processes = n_cores)
# Print learned kernels
print_function = gp.describer(kerneldef)
gp.classifier.utils.print_learned_kernels(print_function,
learned_classifier, y_unique)
# Print the matrix of learned classifier hyperparameters
logging.info('Matrix of learned hyperparameters')
gp.classifier.utils.print_hyperparam_matrix(learned_classifier)
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
THE GAP BETWEEN ANALYSIS AND PLOTS
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
"""
Classifier Prediction Results (Plots)
"""
logging.info('Plotting... please wait')
Xq = gp.classifier.utils.query_map(test_ranges, n_points = 250)
Xqw = pre.whiten(Xq, whitenparams)
yq_truth = gp.classifier.utils.make_decision(Xq, decision_boundary)
fig = plt.figure(figsize = (19.2, 10.8))
ax1 = fig.add_subplot(231)
ax2 = fig.add_subplot(232)
ax3 = fig.add_subplot(233)
ax4 = fig.add_subplot(234)
ax5 = fig.add_subplot(235)
ax6 = fig.add_subplot(236)
fontsize = 20
axis_tick_font_size = 14
"""
Plot: Ground Truth
"""
# Training
gp.classifier.utils.visualise_map(ax1, yq_truth, test_ranges, cmap = mycmap)
ax1.set_title('Ground Truth', fontsize = fontsize)
ax1.set_xlabel('$x_{1}$', fontsize = fontsize)
ax1.set_ylabel('$x_{2}$', fontsize = fontsize)
cbar = plt.colorbar()
cbar.set_ticks(y_unique)
cbar.set_ticklabels(y_unique)
gp.classifier.utils.visualise_decision_boundary(ax1,
test_range_min, test_range_max, decision_boundary)
logging.info('Plotted Prediction Labels')
plt.gca().set_aspect('equal', adjustable = 'box')
for tick in plt.gca().xaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
for tick in plt.gca().yaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
"""
Plot: Training Set
"""
# Training
gp.classifier.utils.visualise_decision_boundary(ax2,
test_range_min, test_range_max, decision_boundary)
plt.scatter(x1, x2, c = y, marker = 'x', cmap = mycmap)
ax2.set_title('Training Labels', fontsize = fontsize)
ax2.set_xlabel('$x_{1}$', fontsize = fontsize)
ax2.set_ylabel('$x_{2}$', fontsize = fontsize)
cbar = plt.colorbar()
cbar.set_ticks(y_unique)
cbar.set_ticklabels(y_unique)
ax2.set_xlim((test_range_min, test_range_max))
ax2.set_ylim((test_range_min, test_range_max))
plt.gca().patch.set_facecolor('gray')
logging.info('Plotted Training Set')
plt.gca().set_aspect('equal', adjustable = 'box')
for tick in plt.gca().xaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
for tick in plt.gca().yaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
"""
Plot: Query Computations
"""
# Compute Linearised and True Entropy for plotting
logging.info('Plot: Caching Predictor...')
predictor = gp.classifier.query(learned_classifier, Xqw)
logging.info('Plot: Computing Expectance...')
exp = gp.classifier.expectance(learned_classifier, predictor)
logging.info('Plot: Computing Variance...')
var = gp.classifier.variance(learned_classifier, predictor)
logging.info('Plot: Computing Linearised Entropy...')
start_time = time.clock()
yq_lmde = gp.classifier.linearised_model_differential_entropy(
exp, var, learned_classifier)
time_lmde = time.clock() - start_time
logging.info('Plot: Computing Equivalent Standard Deviation')
eqsd = gp.classifier.equivalent_standard_deviation(yq_lmde)
logging.info('Plot: Computing Prediction Probabilities...')
yq_prob = gp.classifier.predict_from_latent(exp, var, learned_classifier,
fusemethod = fusemethod)
logging.info('Plot: Computing True Entropy...')
start_time = time.clock()
yq_pie = gp.classifier.entropy(yq_prob)
time_pie = time.clock() - start_time
n_draws_low = 25
n_draws_med = 250
n_draws_high = 2500
logging.info('Plot: Computing MCPIE with %d samples' % n_draws_low)
start_time = time.clock()
yq_mcpie_low = gp.classifier.monte_carlo_prediction_information_entropy(exp, var, learned_classifier, n_draws = n_draws_low)
time_mcpie_low = time.clock() - start_time
logging.info('Plot: Computing MCPIE with %d samples' % n_draws_med)
start_time = time.clock()
yq_mcpie_med = gp.classifier.monte_carlo_prediction_information_entropy(exp, var, learned_classifier, n_draws = n_draws_med)
time_mcpie_med = time.clock() - start_time
logging.info('Plot: Computing MCPIE with %d samples' % n_draws_high)
start_time = time.clock()
yq_mcpie_high = gp.classifier.monte_carlo_prediction_information_entropy(exp, var, learned_classifier, n_draws = n_draws_high)
time_mcpie_high = time.clock() - start_time
logging.info('Plot: Computing Class Predicitons')
yq_pred = gp.classifier.classify(yq_prob, y_unique)
mistake_ratio = (yq_truth - yq_pred).nonzero()[0].shape[0] / yq_truth.shape[0]
timing = { 'time_lmde': time_lmde,
'time_pie': time_pie,
'time_mcpie_low': time_mcpie_low,
'time_mcpie_med': time_mcpie_med,
'time_mcpie_high': time_mcpie_high}
logging.info(timing)
# """
# THIS SECTION IS EXTRA FOR COLLECTING TIME COMPLEXITY DATA
# PLEASE COMMENT OUT UNDER NORMAL CIRCUMSTANCES
# """
# # Compute Linearised and True Entropy for plotting
# Xq = np.random.rand(1000, 2)
# Xqw = pre.whiten(Xq, whitenparams)
# logging.info('Plot: Caching Predictor...')
# predictor = gp.classifier.query(learned_classifier, Xqw)
# logging.info('Plot: Computing Expectance...')
# exp = gp.classifier.expectance(learned_classifier, predictor)
# logging.info('Plot: Computing Variance...')
# cov = gp.classifier.covariance(learned_classifier, predictor)
# logging.info('Plot: Computing Linearised Entropy...')
# start_time = time.clock()
# yq_lmde = gp.classifier.linearised_model_differential_entropy(
# exp, cov, learned_classifier)
# time_lmde = time.clock() - start_time
# logging.info('Plot: Computing Equivalent Standard Deviation')
# eqsd = gp.classifier.equivalent_standard_deviation(yq_lmde)
# logging.info('Plot: Computing Prediction Probabilities...')
# yq_prob = gp.classifier.predict_from_latent(exp, cov, learned_classifier,
# fusemethod = fusemethod)
# logging.info('Plot: Computing True Entropy...')
# start_time = time.clock()
# yq_pie = gp.classifier.entropy(yq_prob)
# time_pie = time.clock() - start_time
# n_draws_low = 25
# n_draws_med = 250
# n_draws_high = 2500
# logging.info('Plot: Computing MCPIE with %d samples' % n_draws_low)
# start_time = time.clock()
# yq_mcpie_low = gp.classifier.monte_carlo_prediction_information_entropy(exp, cov, learned_classifier, n_draws = n_draws_low)
# time_mcpie_low = time.clock() - start_time
# logging.info('Plot: Computing MCPIE with %d samples' % n_draws_med)
# start_time = time.clock()
# yq_mcpie_med = gp.classifier.monte_carlo_prediction_information_entropy(exp, cov, learned_classifier, n_draws = n_draws_med)
# time_mcpie_med = time.clock() - start_time
# logging.info('Plot: Computing MCPIE with %d samples' % n_draws_high)
# start_time = time.clock()
# yq_mcpie_high = gp.classifier.monte_carlo_prediction_information_entropy(exp, cov, learned_classifier, n_draws = n_draws_high)
# time_mcpie_high = time.clock() - start_time
# logging.info('Plot: Computing Class Predicitons')
# yq_pred = gp.classifier.classify(yq_prob, y_unique)
# timing = { 'time_lmde': time_lmde,
# 'time_pie': time_pie,
# 'time_mcpie_low': time_mcpie_low,
# 'time_mcpie_med': time_mcpie_med,
# 'time_mcpie_high': time_mcpie_high}
# logging.info(timing)
# print(yq_mcpie_high, yq_lmde)
# return
# """
# Plot: Prediction Labels
# """
# Query (Prediction Map)
gp.classifier.utils.visualise_map(ax3, yq_pred, test_ranges,
boundaries = True, cmap = mycmap)
ax3.set_title('Prediction [Miss Ratio: %.1f %s]' % (100 * mistake_ratio, '\%'), fontsize = fontsize)
ax3.set_xlabel('$x_{1}$', fontsize = fontsize)
ax3.set_ylabel('$x_{2}$', fontsize = fontsize)
cbar = plt.colorbar()
cbar.set_ticks(y_unique)
cbar.set_ticklabels(y_unique)
logging.info('Plotted Prediction Labels')
plt.gca().set_aspect('equal', adjustable = 'box')
for tick in plt.gca().xaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
for tick in plt.gca().yaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
"""
Plot: Prediction Information Entropy onto Training Set
"""
gp.classifier.utils.visualise_map(ax4, yq_pie, test_ranges,
threshold = entropy_threshold, cmap = cm.coolwarm)
ax4.set_title('Prediction Information Entropy', fontsize = fontsize)
ax4.set_xlabel('$x_{1}$', fontsize = fontsize)
ax4.set_ylabel('$x_{2}$', fontsize = fontsize)
plt.colorbar()
ax4.scatter(x1, x2, c = y, marker = 'x', cmap = mycmap)
ax4.set_xlim((test_range_min, test_range_max))
ax4.set_ylim((test_range_min, test_range_max))
logging.info('Plotted Prediction Information Entropy on Training Set')
plt.gca().set_aspect('equal', adjustable = 'box')
for tick in plt.gca().xaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
for tick in plt.gca().yaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
"""
Plot: Monte Carlo Prediction Information Entropy onto Training Set
"""
gp.classifier.utils.visualise_map(ax5, yq_mcpie_high, test_ranges,
threshold = entropy_threshold, cmap = cm.coolwarm)
ax5.set_title('M.C. Prediction Information Entropy', fontsize = fontsize, x = 0.45)
ax5.set_xlabel('$x_{1}$', fontsize = fontsize)
ax5.set_ylabel('$x_{2}$', fontsize = fontsize)
plt.colorbar()
ax5.scatter(x1, x2, c = y, marker = 'x', cmap = mycmap)
ax5.set_xlim((test_range_min, test_range_max))
ax5.set_ylim((test_range_min, test_range_max))
logging.info('Plotted Monte Carlo Prediction Information Entropy on Training Set')
plt.gca().set_aspect('equal', adjustable = 'box')
for tick in plt.gca().xaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
for tick in plt.gca().yaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
"""
Plot: Linearised Model Differential Entropy onto Training Set
"""
yq_lmde_min = yq_lmde.min()
yq_lmde_max = yq_lmde.max()
gp.classifier.utils.visualise_map(ax6, yq_lmde, test_ranges,
threshold = entropy_threshold, cmap = cm.coolwarm,
vmin = -yq_lmde_max, vmax = yq_lmde_max)
ax6.set_title('L. Model Differential Entropy', fontsize = fontsize)
ax6.set_xlabel('$x_{1}$', fontsize = fontsize)
ax6.set_ylabel('$x_{2}$', fontsize = fontsize)
plt.colorbar()
ax6.scatter(x1, x2, c = y, marker = 'x', cmap = mycmap)
ax6.set_xlim((test_range_min, test_range_max))
ax6.set_ylim((test_range_min, test_range_max))
logging.info('Plotted Linearised Model Differential Entropy on Training Set')
plt.gca().set_aspect('equal', adjustable = 'box')
for tick in plt.gca().xaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
for tick in plt.gca().yaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
# plt.show()
fig.tight_layout()
sea.vis.savefig(fig, './mcpie_lmde_comparison/mcpie_lmde_comparison.eps')
fig = plt.figure(figsize = (19.2, 10.8/2))
ax1 = fig.add_subplot(131)
ax2 = fig.add_subplot(132)
ax3 = fig.add_subplot(133)
gp.classifier.utils.visualise_map(ax1, yq_mcpie_low, test_ranges,
threshold = entropy_threshold, cmap = cm.coolwarm)
ax1.set_title('MCPIE with %d Samples' % n_draws_low, fontsize = fontsize)
ax1.set_xlabel('$x_{1}$', fontsize = fontsize)
ax1.set_ylabel('$x_{2}$', fontsize = fontsize)
plt.colorbar()
ax1.scatter(x1, x2, c = y, marker = 'x', cmap = mycmap)
ax1.set_xlim((test_range_min, test_range_max))
ax1.set_ylim((test_range_min, test_range_max))
logging.info('Plotted MCPIE with %d Samples on Training Set' % n_draws_low)
plt.gca().set_aspect('equal', adjustable = 'box')
for tick in plt.gca().xaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
for tick in plt.gca().yaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
gp.classifier.utils.visualise_map(ax2, yq_mcpie_med, test_ranges,
threshold = entropy_threshold, cmap = cm.coolwarm)
ax2.set_title('MCPIE with %d Samples' % n_draws_med, fontsize = fontsize)
ax2.set_xlabel('$x_{1}$', fontsize = fontsize)
ax2.set_ylabel('$x_{2}$', fontsize = fontsize)
plt.colorbar()
ax2.scatter(x1, x2, c = y, marker = 'x', cmap = mycmap)
ax2.set_xlim((test_range_min, test_range_max))
ax2.set_ylim((test_range_min, test_range_max))
logging.info('Plotted MCPIE with %d Samples on Training Set' % n_draws_med)
plt.gca().set_aspect('equal', adjustable = 'box')
for tick in plt.gca().xaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
for tick in plt.gca().yaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
gp.classifier.utils.visualise_map(ax3, yq_mcpie_high, test_ranges,
threshold = entropy_threshold, cmap = cm.coolwarm)
ax3.set_title('MCPIE with %d Samples' % n_draws_high, fontsize = fontsize)
ax3.set_xlabel('$x_{1}$', fontsize = fontsize)
ax3.set_ylabel('$x_{2}$', fontsize = fontsize)
plt.colorbar()
ax3.scatter(x1, x2, c = y, marker = 'x', cmap = mycmap)
ax3.set_xlim((test_range_min, test_range_max))
ax3.set_ylim((test_range_min, test_range_max))
logging.info('Plotted MCPIE with %d Samples on Training Set' % n_draws_high)
plt.gca().set_aspect('equal', adjustable = 'box')
for tick in plt.gca().xaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
for tick in plt.gca().yaxis.get_major_ticks():
tick.label.set_fontsize(axis_tick_font_size)
# plt.show()
fig.tight_layout()
sea.vis.savefig(fig, './mcpie_lmde_comparison/mcpie_accuracy.eps')
logging.info(timing)
plt.show()
# Prepare Plot
threshold = 1.7
fig = plt.figure(figsize=(25, 5))
plt.title("Gold Tree", fontsize=26)
plt.yticks([])
plt.tick_params(labelsize=16)
n = 18
mh = 2
color_list = ['c', 'c', 'c', 'c', 'g', 'k', 'r', 'r', 'r', 'r', 'm', 'm', 'm', 'm', 'k', 'k']
p = 30
orientation = 'top'
no_labels = False
print("Plotting")
plt.tight_layout()
with plt.rc_context({'lines.linewidth': 2.0}):
_plot_dendrogram(icoord, dcoord, ivl, p, n, mh, orientation,
no_labels, color_list,
leaf_font_size=26.,
leaf_rotation=None,
contraction_marks=None,
ax=None,
above_threshold_color="k")
plt.savefig(save_dir + "goldtree_sentences" + str(int(threshold * 100)) + ".png")
# Rabinovych tree
# Coordinates for the tree
#
icoord = [[5.0, 5.0, 15.0, 15.0], [10.0, 10.0, 25.0, 25.0], [17.5, 17.5, 35.0, 35.0], [45.0, 45.0, 55.0, 55.0],
[50.0, 50.0, 65.0, 65.0], [26.25, 26.25, 57.5, 57.5], [75.0, 75.0, 85.0, 85.0],
def plot_snotel_comparison_one_site(
driver, science_test_data_dir,
compare_data_dict,
result_dir, plot_dir,
plots_to_make,
plot_variables, context, style, filename):
print(plots_to_make)
# get lat/lng from filename
file_split = re.split('_', filename)
lng = file_split[3].split('.txt')[0]
lat = file_split[2]
print('Plotting {} {}'.format(lat, lng))
# loop over data to compare
data = {}
for key, items in compare_data_dict.items():
# read in data
if key == "snotel":
data[key] = read_snotel_swe_obs(filename,
science_test_data_dir,
items)
elif key == "VIC.4.2.d":
data[key] = read_vic_42_output(lat, lng,
science_test_data_dir,
items)
else:
data[key] = read_vic_5_output(lat, lng,
result_dir,
items)
# loop over variables to plot
for plot_variable, units in plot_variables.items():
if 'water_year' in plots_to_make:
with plt.rc_context(dict(sns.axes_style(style),
**sns.plotting_context(context))):
fig, ax = plt.subplots(figsize=(10, 10))
df = pd.DataFrame({key: d[plot_variable] for key, d in
data.items() if plot_variable in d})
for key, series in df.iteritems():
series.plot(
use_index=True,
linewidth=compare_data_dict[key]['linewidth'],
ax=ax,
color=compare_data_dict[key]['color'],
linestyle=compare_data_dict[key]
['linestyle'],
zorder=compare_data_dict[key]['zorder'])
ax.legend(loc='upper left')
ax.set_ylabel("%s [%s]" % (plot_variable, units))
# save figure
os.makedirs(os.path.join(plot_dir, plot_variable),
exist_ok=True)
plotname = '%s_%s.png' % (lat, lng)
savepath = os.path.join(plot_dir, plot_variable, plotname)
plt.savefig(savepath, bbox_inches='tight')
print(savepath)
plt.clf()
plt.close()
def styled_fig_ax(size='wide',
font_size=10.0,
zero_lines=True,
y_axis_grid=True,
seaborn=False,
subplots_rows=None,
subplots_columns=None,
subplots_kwargs=None,
x_formatter=None,
y_formatter=None,
other_rc_params=None):
""" Context manager for a styled axis.
:param size: accepts 'wide' (top/bottom of slide), 'tall' (left side of slide),
'tallest' (left side of slide, lots of text)
:param font_size: the main font size; some sizes are set relative to this; overridden on tallest.
:param zero_lines: strong lines at x=0 and y=0
:param other_rc_params: any custom rcParams to include
:param subplots_rows: the number of rows in the subplot (default=None)
:param subplots_columns: the number of columns in the subplot (default=None)
:param subplots_kwargs: dict of kwargs for subplots call (e.g., sharex=True) (default={})
:param x_formatter: Formatter to use for major ticks on x axis
:param y_formatter: Formatter to use for major ticks on y axis
"""
subplots_kwargs = {} if subplots_kwargs is None else subplots_kwargs
other_rc_params = {} if other_rc_params is None else other_rc_params
sizes = {
'quarter': (6.8, 3.7),
'wide': (9.75, 3.6),
'tall': (6., 7.5),
'tallest': (6, 8.5),
'square': (6., 6.),
'custom': other_rc_params.get('figure.figsize', None),
}
figure_size = sizes[size]
original_params = plt.rcParams.copy()
if sizes == 'tallest':
plt.rcParams['savefig.pad_inches'] = 0.0
plt.rcParams['savefig.pad_inches'] = 0.0
if font_size > 6.0:
font_size = 6.0
# set globally here since this seems ignored by rc_context.....
# apologies for side effects.
plt.rcParams['axes.titlesize'] = 1.25 * font_size
plt.rcParams['figure.dpi'] = 196
plt.rcParams['savefig.dpi'] = 196
plt.rcParams['legend.frameon'] = False
plt.rcParams['legend.fontsize'] = 0.8 * font_size
rc_params = {
'figure.figsize': figure_size,
# font
'font.family': 'Verdana',
'font.size': font_size,
'axes.labelsize': font_size,
'xtick.labelsize': 0.8 * font_size,
'ytick.labelsize': 0.8 * font_size,
# remove extras
'xtick.major.size': 0, # major tick size in points
'xtick.minor.size': 0, # minor tick size in points
'ytick.major.size': 0, # major tick size in points
'ytick.minor.size': 0, # minor tick size in points
# colors
'axes.prop_cycle': cycler('color', get_palette(dict=False, hex=True)),
# grid
'axes.facecolor': 'white',
'axes.edgecolor': '.8',
'axes.grid': False,
'grid.linestyle': '-',
'grid.linewidth': 0.25,
'grid.color': '#a3a3a3',
'axes.linewidth': 0.0,
}
rc_params.update(other_rc_params)
def _adjust_figure_inplace(fig, ax):
# set just x axis grid lines
ax.grid(True)
ax.xaxis.grid(False)
if not y_axis_grid:
ax.yaxis.grid(False)
ax.set_axisbelow(True)
if zero_lines:
ax.axvline(x=0, c='k', linestyle='-', lw=0.7, alpha=0.5)
ax.axhline(y=0, c='k', linestyle='-', lw=0.7, alpha=0.5)
if x_formatter:
ax.xaxis.set_major_formatter(x_formatter)
if y_formatter:
ax.yaxis.set_major_formatter(y_formatter)
fig.tight_layout()
if seaborn:
with sns.axes_style(rc=rc_params):
sns.set_palette(get_palette())
yield
fig = plt.gcf()
fig.set_size_inches(figure_size)
# hack for joint plots (looks like main plot is always first)
ax = plt.gcf().get_axes()[0]
_adjust_figure_inplace(fig, ax)
else:
with plt.rc_context(rc_params):
if xor((subplots_rows is not None),
(subplots_columns is not None)):
raise ValueError(
"Must pass both subplots_rows and subplots_columns or neither."
)
if subplots_rows is not None:
fig, axes = plt.subplots(subplots_rows,
subplots_columns,
figsize=figure_size,
**subplots_kwargs)
for ax in axes:
_adjust_figure_inplace(fig, ax)
yield axes
else:
fig, ax = plt.subplots(figsize=figure_size)
_adjust_figure_inplace(fig, ax)
yield ax
# reset after context manager is closed
for k, v in original_params.items():
plt.rcParams[k] = v
def Dendrogram(table,
distance_metric="correlation",
linkage_method="complete",
axis=1,
lw=1.,
n_clust=None,
optimal_row_ordering=True,
optimal_col_ordering=True,
ax=None):
"""Function that plots a dendrogram on axis 0 (rows), or axis 1
(columns) of a :class:`pandas.DataFrame`.
:param table: Data matrix used to calculate dendrograms.
:type table: :class:`pandas.DataFrame`
:param distance_metric: Distance metric used to determine distance between
two vectors. The distance function can be either of 'braycurtis',
'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'dice',
'euclidean', 'hamming', 'jaccard', 'jensenshannon', 'kulsinski',
'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto', 'russellrao',
'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule',
defaults to 'correlation'.
:type distance_metric: str, optional
:param linkage_method: Methods for calculating the distance between the
newly formed cluster u and each v. Possible methods are, 'single',
'complete', 'average', 'weighted', and 'centroid', defaults to
'complete'.
:type linkage_method: str, optional
:param axis: Axis of table used for plotting dendrogram (0 = rows,
1 = columns), defaults to 1.
:type axis: int, optional
:param lw: Width of the lines (in points) defining the dengrogram, defaults
to 1.
:type lw: float, optional
:param n_clust: Number of clusters in which the dendrogram should be cut.
Note: Dendrogram cutting makes use of scipy.cluster.hierarchy.cut_tree
function, defaults to None.
:type n_clust: int, optional
:param optimal_row_ordering: If True, the rows will be ordered optimally
with regards to the cluster separation. Be careuful: Can take a long
time, depending on the number of rows, defaults to True.
:type optimal_row_ordering: bool, optional
:param optimal_col_ordering: If True, the columns will be ordered optimally
with regards to the cluster separation. Be careuful: Can take a long
time, depending on the number of columns, defaults to True.
:type optimal_col_ordering: bool, optional
:param ax: Axes n which to plot the dendrogram, defaults to None.
:type ax: :class:`matplotlib.axes._subplots.AxesSubplot`
:return: Tuple containing the following entries:
1. Resulting dictionary from scipy.cluster.hierarchy.dendrogram
function.
2. linkage matrix, that is returned from
scipy.cluster.hierarchy.linkage function
3. dictionary containing the row_ids, (in case of axis = 0), or
column_ids (in case of axis = 1) that are assigned to different
clusters. Only makes sense if n_clust is not None.
:rtype: dict
"""
ax = ax if ax is not None else plt.gca()
ids = None
dendrogram_dict = None
linkage_matrix = None
cluster_dict = None
color_threshold = 0
if (axis == 0):
ids = list(table.index)
distance_matrix = pdist(table, metric=distance_metric)
linkage_matrix = linkage(distance_matrix,
metric=distance_metric,
method=linkage_method,
optimal_ordering=optimal_row_ordering)
if (not n_clust is None):
cluster_dict = {}
color_threshold = linkage_matrix[-1 * (n_clust - 1), 2]
grouping = cut_tree(linkage_matrix, n_clusters=n_clust)
for i in range(len(grouping)):
group = grouping[i, 0]
if (not (group in cluster_dict)):
cluster_dict[group] = [ids[i]]
else:
cluster_dict[group] += [ids[i]]
with plt.rc_context({'lines.linewidth': lw}):
dendrogram_dict = dendrogram(linkage_matrix,
orientation="left",
color_threshold=color_threshold)
elif (axis == 1):
ids = table.columns
distance_matrix = pdist(table.T, metric=distance_metric)
linkage_matrix = linkage(distance_matrix,
metric=distance_metric,
method=linkage_method,
optimal_ordering=optimal_col_ordering)
if (not n_clust is None):
cluster_dict = {}
color_threshold = linkage_matrix[-1 * (n_clust - 1), 2]
grouping = cut_tree(linkage_matrix, n_clusters=n_clust)
for i in range(len(grouping)):
group = grouping[i, 0]
if (not (group in cluster_dict)):
cluster_dict[group] = [ids[i]]
else:
cluster_dict[group] += [ids[i]]
with plt.rc_context({'lines.linewidth': lw}):
dendrogram_dict = dendrogram(linkage_matrix,
color_threshold=color_threshold)
ax.spines["left"].set_visible(False)
ax.spines["right"].set_visible(False)
ax.spines["bottom"].set_visible(False)
ax.spines["top"].set_visible(False)
plt.xticks([], [])
plt.yticks([], [])
return dendrogram_dict, linkage_matrix, cluster_dict
# Set some colors
aocText = "#CCCCCC"
aocBackground = "#0F0F23"
aocGold = "#FFFF66"
aocSilver = "#9999CC"
# Set background color
fig = plt.figure()
fig.patch.set_facecolor(aocBackground)
# Do some of the styling
with plt.rc_context({
"axes.edgecolor": aocText,
"xtick.color": aocText,
"ytick.color": aocText,
"figure.facecolor": aocBackground,
"axes.facecolor": aocBackground
}):
# These variables will get set to some values via scraping the info from the leaderboard in a future update
days = [1, 2, 3, 4, 5, 6]
goldStars = [114000, 96000, 79000, 63000, 55000, 48000]
silverStars = [7600, 2600, 2400, 8000, 1100, 1950]
leaderboard = leaderboardUtils.getLeaderboard()
#print( leaderboard)
days = []
for item in leaderboard:
days.append(int(item[0]))
