def plot_confusion_matrix(cm,
labels,
cmap=plt.cm.Blues,
ax=None,
colorbar_label=None,
discrete=False):
if ax is None:
ax = plt.gca()
if discrete:
ax, cbar = discrete_matshow(cm, cmap=cmap, ax=ax)
else:
h = ax.pcolormesh(cm, cmap=cmap)
cbar = plt.colorbar(h)
if colorbar_label:
cbar.set_label(colorbar_label)
tick_marks = np.arange(len(labels)) + .5
plt.xticks(tick_marks, labels, rotation=45)
plt.yticks(tick_marks, labels)
plt.tight_layout()
plt.xlabel('True label')
plt.ylabel('Predicted label')
sns.despine(ax=ax)
return ax
def plot_lung_on_subplot(self,
ax,
x_index,
y_index,
lung,
skip_n = 1, # skip n - 1 points when plotting lung dots
lung_color = blue,
lung_alpha = 0.0058,
lung_markersize = 2,
rasterize_lung = True, # allows pdfs to not save every single point
rasterize_order = 0,# no idea what this does
hide_axes = [True, True, False, False]): # [top, right, left, bottom]
ax.plot(lung[::skip_n, x_index],
lung[::skip_n, y_index],
'.',
color = lung_color,
alpha = lung_alpha,
markersize = lung_markersize)
ax.set_rasterized(rasterize_lung)
ax.set_rasterization_zorder(rasterize_order)
ax.tick_params(labelsize=icra.label_fontsize)
ax.set_xlim(min(lung[:,x_index]), max(lung[:,x_index]))
ax.set_ylim(min(lung[:,y_index]), max(lung[:,y_index]))
ax.set_aspect('equal')
ax.invert_yaxis()
top, right, left, bottom = hide_axes
sns.despine(ax = ax, top = top, right = right, left = left, bottom = bottom)
def plot_results(name, results, fractions, in_figures=False):
from matplotlib import pyplot as plt
import seaborn.apionly as sns
fig, ax = plt.subplots(
figsize=[plotinfo.TEXTWIDTH_1_2_IN, plotinfo.TEXTWIDTH_1_2_IN * .75])
ax.plot([0, 1], [0, 1], c=plotinfo.color_blue, zorder=0)
ax.scatter(results,
fractions,
s=16,
lw=1,
edgecolor='k',
c=plotinfo.color_red,
zorder=1)
ax.set_ylim(-.04, 1.04)
ax.set_xlim(-.04, 1.04)
ax.grid(False)
ax.set_xlabel('Human labeled')
ax.set_ylabel('Automatic prediction')
sns.despine(ax=ax, trim=True)
fig.tight_layout()
directory = ('figures/' if in_figures else 'outputs/')
mkdir_p(directory)
fig.savefig('{}/{}.eps'.format(directory, name))
fig.savefig('{}/{}.pdf'.format(directory, name))
plt.close(fig)
def plot_enrichment(ax, enrichment, color, title='', rad=True):
ax.plot(range(9), np.mean(enrichment, axis=0), color=color)
ax.plot(range(9),
np.percentile(enrichment, 5, axis=0),
ls='--',
color=color)
ax.plot(range(9),
np.percentile(enrichment, 95, axis=0),
ls='--',
color=color)
ax.fill_between(range(9),
np.percentile(enrichment, 5, axis=0),
np.percentile(enrichment, 95, axis=0),
facecolor=color,
alpha=0.5)
sns.despine(ax=ax)
ax.tick_params(length=3, pad=2, direction='out')
ax.set_xlim(-0.5, 8.5)
if rad:
ax.set_ylim(-0.15, 0.5)
ax.set_ylabel('Enrichment (rad)')
else:
ax.set_ylim(-0.15, 0.10 * 2 * np.pi)
y_ticks = np.array(['0', '0.05', '0.10'])
ax.set_yticks(y_ticks.astype('float') * 2 * np.pi)
ax.set_yticklabels(y_ticks)
ax.set_ylabel('Enrichment (fraction of belt)')
ax.set_xlabel("Iteration ('session' #)")
ax.set_title(title)
def plot(rs):
from matplotlib import pyplot as plt
import seaborn.apionly as sns
import plotinfo
rh2 = np.corrcoef(rs.T[0],rs.T[1])[0,1]**2
real,alt,_ = rs.T
q2 = 1.-np.dot(real-alt,real-alt)/np.dot(real-real.mean(),real-real.mean())
w = plotinfo.TEXTWIDTH_1_2_IN
fig,ax = plt.subplots(figsize=[w, w* 0.75])
ax.text(.2, .84, r'$R^2: {}\%$'.format(int(np.round(rh2*100))), fontsize=14)
ax.text(.2, .70, r'$Q^2: {}\%$'.format(int(np.round(q2*100))), fontsize=14)
ax.set_xlabel(r'${}$Human labeler 1 (fraction assigned to NET)${}$')
ax.set_ylabel(r'${}$Human labeler 2 (fraction assigned to NET)${}$')
ax.set_ylim(-.04,1.04)
ax.set_xlim(-.04,1.04)
ax.scatter(rs.T[0], rs.T[1], s=16, lw=1, edgecolor='k', c=plotinfo.color_red, zorder=1)
ax.plot([rs.T[:2].min(), rs.T[:2].max()], [rs.T[:2].min(), rs.T[:2].max()], c=plotinfo.color_blue, zorder=0)
fig.tight_layout()
sns.despine(ax=ax, offset=True, trim=True)
fig.savefig('figures/human-comparison.pdf')
fig.savefig('figures/human-comparison.eps')
fig.savefig('figures/human-comparison.png', dpi=1200)
def ft_ax(ax=None,
y=1.03,
yy=1.1,
title=None,
subtitle=None,
source=None,
add_box=False,
left_axis=False):
"""
Format either a desired axis or the current axis as an FT plot.
"""
if ax is None:
ax = plt.gca()
ax.set_axisbelow(True)
if title is not None:
title = plt.title(title, y=y, loc='left')
if subtitle is not None:
plt.annotate(subtitle, xy=title.get_position(),
xycoords='axes fraction', xytext=(0,-11),
textcoords='offset points', size='large')
if source is not None:
src = plt.annotate(source, xy=(0,0),
xycoords='axes fraction', xytext=(0,-35),
textcoords='offset points', ha='left', va='top', size='small')
# axes and grid-lines
plt.grid(axis='y', linewidth=.5)
sns.despine(left=True)
if not left_axis:
ax.yaxis.tick_right()
ax.yaxis.set_label_position('right')
ax.yaxis.set_label_coords(1,yy)
ax.yaxis.get_label().set_rotation(0)
ax.tick_params('y', length=0)
plt.tight_layout()
if add_box:
ax2 = plt.axes(ax.get_position().bounds, facecolor=(1,1,1,0))
ax2.xaxis.set_visible(False)
ax2.yaxis.set_visible(False)
x,y = np.array([[.01, 0.15], [y+.12, y+.12]])
line = matplotlib.lines.Line2D(x, y, lw=6., color='k')
ax2.add_line(line)
line.set_clip_on(False)
if add_box and source is not None:
return (line, src)
elif not add_box and source is not None:
return (src,)
elif add_box and source is None:
return (line,)
else:
return []
def plot_final_results(results):
import numpy as np
from matplotlib import pyplot as plt
import seaborn.apionly as sns
results = {k: (100 * v.q2) for k, v in results.iteritems()}
methods = [m for m, _ in FEATURES]
methods.sort(key=lambda m: results[m + '.origins'])
methods.append('average.loo')
color0 = plotinfo.color_red
color1 = plotinfo.color_blue
fig, ax = plt.subplots(
figsize=[plotinfo.TEXTWIDTH_1_2_IN, plotinfo.TEXTWIDTH_1_2_IN / 1.6])
ax.bar(np.arange(len(methods)) + .4,
[results[m + '.origins'] for m in methods],
width=.4,
color=color0,
label='Corrected')
ax.bar(np.arange(len(methods) - 1),
[results[m + '.origins.raw'] for m in methods[:-1]],
width=.4,
color=color1,
label='Raw')
ax.set_ylim(40, 100)
ax.set_xlabel('Method')
ax.set_ylabel(r'$Q^2 (\%)$')
ax.set_xticks(np.arange(len(methods)) + .4)
ax.set_xticklabels(methods[:-1] + ['avg'], fontsize=7)
ax.grid(False)
for i, m in enumerate(methods[:-1]):
v = results[m + '.origins.raw']
plt.text(i + .2,
v + 0.5,
'{}'.format(int(np.round(v))),
fontsize=8,
horizontalalignment='center')
for i, m in enumerate(methods):
v = results[m + '.origins']
ax.text(i + .6,
v + 0.5,
'{}'.format(int(np.round(v))),
fontsize=8,
horizontalalignment='center')
sns.despine(ax=ax)
ax.legend(loc='upper left', fontsize=7)
fig.tight_layout()
fig.savefig('figures/final-plot.pdf')
fig.savefig('figures/final-plot.svg')
fig.savefig('figures/final-plot.eps')
def parallel_coordinates(dataframe, hue, cols=None, palette=None, **subplot_kws):
""" Produce a parallel coordinates plot from a dataframe.
Parameters
----------
dataframe : pandas.DataFrame
The data to be plotted.
hue : string
The column used to the determine assign the lines' colors.
cols : list of strings, optional
The non-hue columns to include. If None, all other columns are
used.
palette : string, optional
Name of the seaborn color palette to use.
**subplot_kws : keyword arguments
Options passed directly to plt.subplots()
Returns
-------
fig : matplotlib Figure
"""
# get the columsn to plot
if cols is None:
cols = dataframe.select(lambda c: c != hue, axis=1).columns.tolist()
# subset the data
final_cols = copy.copy(cols)
final_cols.append(hue)
data = dataframe[final_cols]
# these plots look ridiculous in anything other than 'ticks'
with seaborn.axes_style('ticks'):
fig, axes = plt.subplots(ncols=len(cols), **subplot_kws)
hue_vals = dataframe[hue].unique()
colors = seaborn.color_palette(name=palette, n_colors=len(hue_vals))
color_dict = dict(zip(hue_vals, colors))
for col, ax in zip(cols, axes):
data_limits =[(0, dataframe[col].min()), (0, dataframe[col].max())]
ax.set_xticks([0])
ax.update_datalim(data_limits)
ax.set_xticklabels([col])
ax.autoscale(axis='y')
ax.tick_params(axis='y', direction='inout')
ax.tick_params(axis='x', direction='in')
for row in data.values:
for n, (ax1, ax2) in enumerate(zip(axes[:-1], axes[1:])):
line = _connect_spines(ax1, ax2, row[n], row[n+1], color=color_dict[row[-1]])
fig.subplots_adjust(wspace=0)
seaborn.despine(fig=fig, bottom=True, trim=True)
return fig
def _plotTrackingPercentage(plotData):
figure = plt.figure(figsize=(figureWidth, halfPageHeight), dpi=600)
sns.set_style(style='white')
ax = figure.gca()
minTracking = 100.
lambdaPhiSet = set()
trackingPercentageList = []
for j, (P_d, d1) in enumerate(plotData.items()):
for i, (N, d2) in enumerate(d1.items()):
x = []
y = []
for lambda_phi, trackingPercentage in d2.items():
x.append(lambda_phi)
y.append(trackingPercentage)
minTracking = min(minTracking, trackingPercentage)
lambdaPhiSet.add(lambda_phi)
x = np.array(x)
y = np.array(y)
x, y = (list(t) for t in zip(*sorted(zip(x, y))))
trackingPercentageList.append((P_d, N, x, y))
trackingPercentageList.sort(key=lambda tup: float(tup[1]), reverse=True)
trackingPercentageList.sort(key=lambda tup: float(tup[0]), reverse=True)
pdSet = set()
nSet = set()
for P_d, N, x, y in trackingPercentageList:
if P_d not in pdSet:
nSet.clear()
pdSet.add(P_d)
nSet.add(N)
ax.plot(x, y,
label="$P_D$={0:}, N={1:.0f}".format(P_d, N),
c=colors[len(nSet) - 1],
linestyle=linestyleList[len(pdSet) - 1],
linewidth=linewidth,
marker='*' if len(x)==1 else None)
lambdaPhiList = list(lambdaPhiSet)
lambdaPhiList.sort()
ax.legend(loc=0, ncol=len(pdSet), fontsize=legendFontsize)
ax.set_xlabel("$\lambda_{\phi}$", fontsize=labelFontsize)
ax.set_ylabel("\nAverage tracking percentage", fontsize=labelFontsize)
ax.xaxis.set_major_formatter(FormatStrFormatter('%.1e'))
ax.set_ylim(0.0, 100.01)
ax.tick_params(labelsize=labelFontsize)
sns.despine(ax=ax, offset=0)
ax.xaxis.set_ticks(lambdaPhiList)
figure.tight_layout(pad=0.8, h_pad=0.8, w_pad=0.8)
return figure
def multi_colorbar(cmaps, vmins, vmaxs, ax=None, orientation='vertical'):
"""
plots multiple colorbars with different vmins and vmaxs on the same axis
elect_colors = ('blue', 'red', 'green')
vmins=(.5, -.5, .5)
vmaxs=(3., 3., 2.)
cmaps = [sns.light_palette(ecolor, as_cmap=True) for ecolor in elect_colors]
multi_colorbar(cmaps, vmins, vmaxs, orientation='horizontal')
"""
if orientation not in ('vertical', 'horizontal'):
raise ValueError('orientation must be either vertical or horizontal')
if not (len(cmaps) == len(vmins) and (len(cmaps) == len(vmaxs))):
raise ValueError(
'cmaps, vmins, and vmaxs must all be iterables of the same length')
if ax is None:
if orientation == 'horizontal':
figsize = (3, 1)
else:
figsize = (1, 3)
fig, ax = plt.subplots(figsize=figsize)
maxmax = max(vmaxs)
minmin = min(vmins)
if orientation == 'vertical':
extent = [-.5, len(cmaps) - .5, maxmax, minmin]
else:
extent = [minmin, maxmax, -.5, len(cmaps) - .5]
im = []
for cmap, vmin, vmax in zip(cmaps, vmins, vmaxs):
yy = np.linspace(minmin, maxmax, 100)
colors = cmap((yy - vmin) / (vmax - vmin))
im.append(colors)
im = np.array(im)
if orientation == 'vertical':
im = np.array(im).swapaxes(0, 1)
ax.imshow(im, interpolation='nearest', extent=extent)
ax.invert_yaxis()
plt.axis('tight')
if orientation == 'vertical':
ax.set_xticks([])
else:
ax.set_yticks([])
sns.despine(ax=ax)
return ax
def plot_angle(data,
N=50,
title=None,
ax1=None,
ax2=None,
color=None,
wrap=True):
if ax1 is None or ax2 is None:
gs = gridspec.GridSpec(2, 6)
ax1 = plt.subplot(gs[:1, :2], polar=True)
ax2 = plt.subplot(gs[:1, 2:])
if wrap:
vf = np.vectorize(wrapAngle)
else:
vf = np.vectorize(constrainAngle)
x = vf(data)
sns.distplot(x, bins=N, ax=ax2, color=color, kde=True)
radii, theta = np.histogram(x, bins=N, normed=True)
ax1.set_yticklabels([])
if wrap:
ax1ticks = [0, 45, 90, 135, 180, -135, -90, -45]
ax2ticks = list(range(-180, 180 + 45, 45))
ax1.set_xticklabels(['{}°'.format(x) for x in ax1ticks])
ax2.set_xlim(-180, 180)
ax2.set_xticks(ax2ticks)
ax2.set_xticklabels(['{}°'.format(x) for x in ax2ticks])
else:
ax2ticks = list(range(0, 360 + 45, 45))
ax2.set_xlim(0, 360)
ax2.set_xticks(ax2ticks)
ax2.set_xticklabels(['{}°'.format(x) for x in ax2ticks])
ax2.set_yticks([])
ax2.set(xlabel='Angle', ylabel='Density')
sns.despine(ax=ax2)
width = (2 * np.pi) / N
ax1.bar(np.deg2rad(theta[1:]), radii, width=width, color=color, alpha=.5)
if title is not None:
plt.suptitle(title)
plt.tight_layout()
f = plt.gcf()
return f, (ax1, ax2)
def make_map(state2poly, states, label, figsize=(12, 9)):
"""
Draw a cloropleth map, that maps data onto the United States
Inputs
-------
state2poly: state geometry dictionary
states : Column of a DataFrame
The value for each state, to display on a map
label : str
Label of the color bar
Returns
--------
The map
"""
fig = plt.figure(figsize=figsize) # create a figure
ax = plt.gca() # get axes from the figure
if states.max() < 2: # colormap for election probabilities
cmap = cm.RdBu
vmin, vmax = 0, 1
else: # colormap for electoral votes, or other values
cmap = cm.binary
vmin, vmax = 0, states.min(), states.max()
norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
skip = set([
'National', 'District of Columbia', 'Guam', 'Puerto Rico',
'Virgin Islands', 'American Samoa', 'Northern Mariana Islands'
])
for state in states_abbrev.values():
if state in skip:
continue
color = cmap(norm(states.loc[state]))
draw_state(ax, state2poly[state], color=color)
#add an inset colorbar
ax1 = fig.add_axes([0.45, 0.70, 0.4, 0.02])
cb1 = mpl.colorbar.ColorbarBase(ax1,
cmap=cmap,
norm=norm,
orientation='horizontal')
ax1.set_title(label)
ax.set_xticks([])
ax.set_yticks([])
ax.set_xlim(-180, -60)
ax.set_ylim(15, 75)
sns.despine(left=True, bottom=True)
return ax
def plot_waveform(wf_header, wf_data,\
fig=None,savename=None,\
use_mv_and_ns=True,\
color=None):
"""
Make a plot of a single acquisition
Args:
wf_header (dict): custom waveform header
wf_data (np.ndarray): waveform data
Keyword Args:
fig (pylab.figure): A figure instance
savename (str): where to save the figure (full path)
use_mv_and_ns (bool): use mV and ns instead of V and s
Returns:
pylab.fig
"""
if color is None:
color = sb.color_palette("dark")[0]
if fig is None:
fig = p.figure()
ax = fig.gca()
# if remove_empty_bins:
# bmin = min(bincenters[bincontent > 0])
# bmax = max(bincenters[bincontent > 0])
# bincenters = bincenters[np.logical_and(bincenters >= bmin, bincenters <= bmax)]
# bincontent = bincontent[np.logical_and(bincenters >= bmin, bincenters <= bmax)]
xlabel = wf_header["xunit"]
ylabel = wf_header["yunit"]
xs = copy(wf_header["xs"])
ys = copy(wf_data)
if xlabel == "s" and ylabel == "V" and use_mv_and_ns:
xs *= 1e9
ys *= 1e3
xlabel = "ns"
ylabel = "mV"
ax.plot(xs, ys, color=color)
ax.grid()
sb.despine(fig)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
p.tight_layout()
if savename is not None:
fig.savefig(savename)
return fig
def main():
expts = lab.ExperimentSet(
os.path.join(df.metadata_path, 'expt_metadata.xml'),
behaviorDataPath=os.path.join(df.data_path, 'behavior'),
dataPath=os.path.join(df.data_path, 'imaging'))
sal_grp = lab.classes.HiddenRewardExperimentGroup.from_json(
sal_json, expts, label='saline to muscimol')
mus_grp = lab.classes.HiddenRewardExperimentGroup.from_json(
mus_json, expts, label='muscimol to saline')
fig = plt.figure(figsize=(8.5, 11))
gs = plt.GridSpec(1, 1, top=0.9, bottom=0.7, left=0.1, right=0.4)
ax = fig.add_subplot(gs[0, 0])
for expt in mus_grp:
if 'saline' in expt.get('drug'):
expt.attrib['drug_condition'] = 'reversal'
elif 'muscimol' in expt.get('drug'):
expt.attrib['drug_condition'] = 'learning'
for expt in sal_grp:
if 'saline' in expt.get('drug'):
expt.attrib['drug_condition'] = 'learning'
elif 'muscimol' in expt.get('drug'):
expt.attrib['drug_condition'] = 'reversal'
plotting.plot_metric(
ax, [sal_grp, mus_grp], metric_fn=ra.fraction_licks_in_reward_zone,
label_groupby=False, plotby=['X_drug_condition'],
plot_method='swarm', rotate_labels=False,
activity_label='Fraction of licks in reward zone',
colors=sns.color_palette('deep'), plot_bar=True)
ax.set_yticks([0, 0.1, 0.2, 0.3, 0.4])
ax.set_ylim(top=0.4)
ax.set_xticklabels(['Days 1-3', 'Day 4'])
sns.despine(fig)
ax.set_title('')
ax.set_xlabel('')
misc.save_figure(
fig, filename, save_dir=save_dir)
plt.close('all')
def make_samplefig(self, **figkwargs):
""" Generate a matplotlib figure showing the hyetograph,
hydrograph, and timing of water quality samples
Parameters
----------
figkwargs : keyward arguments
Plotting options passed directly to Storm.summaryPlot
Writes
------
Saves a .png and .pdf of the figure
Returns
-------
fig : matplotlib.figure
The instance of the figure.
"""
serieslabels = {
self.storm.outflowcol: 'Effluent (L/s)',
self.storm.precipcol: '10-min Precip Depth (mm)'
}
fig, artists, labels = self.storm.summaryPlot(inflow=False, showLegend=False,
figopts=figkwargs,
serieslabels=serieslabels)
rug = self.plot_ts(ax=fig.axes[1], isFocus=True, asrug=False)
fig.axes[0].set_ylabel('Precip (mm)')
fig.axes[1].set_ylabel('BMP Effluent (L/s)')
seaborn.despine(ax=fig.axes[1])
seaborn.despine(ax=fig.axes[0], bottom=True, top=False)
artists.extend([rug])
labels.extend(['Samples'])
leg = fig.axes[0].legend(artists, labels, fontsize=7, ncol=1,
markerscale=0.75, frameon=False,
loc='lower right')
leg.get_frame().set_zorder(25)
viz.savefig(fig, self.storm_figure, extra='Storm', asPDF=True)
return fig
def plot_final_results(results):
import numpy as np
from matplotlib import pyplot as plt
import seaborn.apionly as sns
results = {k:(100*v.q2) for k,v in results.iteritems()}
methods = [m for m,_ in FEATURES]
methods.sort(key=lambda m: results[m+'.origins'])
methods.append('average.loo')
color0 = plotinfo.color_red
color1 = plotinfo.color_blue
fig,ax = plt.subplots(figsize=[plotinfo.TEXTWIDTH_1_2_IN, plotinfo.TEXTWIDTH_1_2_IN/1.6])
ax.bar(np.arange(len(methods))+.4, [results[m + '.origins'] for m in methods], width=.4, color=color0, label='Corrected')
ax.bar(np.arange(len(methods)-1), [results[m + '.origins.raw'] for m in methods[:-1]], width=.4, color=color1, label='Raw')
ax.set_ylim(40, 100)
ax.set_xlabel('Method')
ax.set_ylabel(r'$Q^2 (\%)$')
ax.set_xticks(np.arange(len(methods))+.4)
ax.set_xticklabels(methods[:-1] + ['avg'], fontsize=7)
ax.grid(False)
for i, m in enumerate(methods[:-1]):
v = results[m + '.origins.raw']
plt.text(i +.2, v + 0.5, '{}'.format(int(np.round(v))), fontsize=8, horizontalalignment='center')
for i, m in enumerate(methods):
v = results[m + '.origins']
ax.text(i + .6, v + 0.5, '{}'.format(int(np.round(v))), fontsize=8, horizontalalignment='center')
sns.despine(ax=ax)
ax.legend(loc='upper left', fontsize=7)
fig.tight_layout()
fig.savefig('figures/final-plot.pdf')
fig.savefig('figures/final-plot.svg')
fig.savefig('figures/final-plot.eps')
def plot_results(name, results, fractions, in_figures=False):
from matplotlib import pyplot as plt
import seaborn.apionly as sns
fig,ax = plt.subplots(figsize=[plotinfo.TEXTWIDTH_1_2_IN, plotinfo.TEXTWIDTH_1_2_IN*.75])
ax.plot([0,1], [0,1], c=plotinfo.color_blue, zorder=0)
ax.scatter(results, fractions, s=16, lw=1, edgecolor='k', c=plotinfo.color_red, zorder=1)
ax.set_ylim(-.04,1.04)
ax.set_xlim(-.04,1.04)
ax.grid(False)
ax.set_xlabel('Human labeled')
ax.set_ylabel('Automatic prediction')
sns.despine(ax=ax, trim=True)
fig.tight_layout()
directory = ('figures/' if in_figures else 'outputs/')
mkdir_p(directory)
fig.savefig('{}/{}.eps'.format(directory, name))
fig.savefig('{}/{}.pdf'.format(directory, name))
plt.close(fig)
def plot(rs):
from matplotlib import pyplot as plt
import seaborn.apionly as sns
import plotinfo
rh2 = np.corrcoef(rs.T[0], rs.T[1])[0, 1]**2
real, alt, _ = rs.T
q2 = 1. - np.dot(real - alt, real - alt) / np.dot(real - real.mean(),
real - real.mean())
w = plotinfo.TEXTWIDTH_1_2_IN
fig, ax = plt.subplots(figsize=[w, w * 0.75])
ax.text(.2,
.84,
r'$R^2: {}\%$'.format(int(np.round(rh2 * 100))),
fontsize=14)
ax.text(.2,
.70,
r'$Q^2: {}\%$'.format(int(np.round(q2 * 100))),
fontsize=14)
ax.set_xlabel(r'${}$Human labeler 1 (fraction assigned to NET)${}$')
ax.set_ylabel(r'${}$Human labeler 2 (fraction assigned to NET)${}$')
ax.set_ylim(-.04, 1.04)
ax.set_xlim(-.04, 1.04)
ax.scatter(rs.T[0],
rs.T[1],
s=16,
lw=1,
edgecolor='k',
c=plotinfo.color_red,
zorder=1)
ax.plot([rs.T[:2].min(), rs.T[:2].max()], [rs.T[:2].min(), rs.T[:2].max()],
c=plotinfo.color_blue,
zorder=0)
fig.tight_layout()
sns.despine(ax=ax, offset=True, trim=True)
fig.savefig('figures/human-comparison.pdf')
fig.savefig('figures/human-comparison.eps')
fig.savefig('figures/human-comparison.png', dpi=1200)
def plot_lung_cloud(self,
x_index,
y_index,
ax = plt.subplot(111),
color = blue,
alpha = 0.002,
slice_index = 2,
slice_max = 1e3,
slice_min = -1e3,
do_slice = False,# pass in reduced lung if wanted
skip_n = 1):
if do_slice:
lung = self.lung[(self.lung[:,slice_index] < slice_max) & (self.lung[:,slice_index] > slice_min)]
else:
lung = self.lung
ax.plot(lung[::skip_n, x_index], lung[::skip_n, y_index], '.', color = color, alpha = alpha, markersize = 3)
ax.set_aspect('equal')
ax.invert_yaxis()
ax.invert_xaxis()
sns.despine(ax = ax, top=True, right=True, left=False, bottom=False)
return ax
def plot_histogram(bincenters,bincontent,\
fig=None,savename="test.png",\
remove_empty_bins=True):
"""
Plot a histogram returned by TektronixDPO4104B.get_histogram
Use pylab.plot
Args:
bincenters (np.ndarray); bincenters (x)
bincontent (np.ndarray): bincontent (y)
Keyword Args:
fig (pylab.figure): A figure instance
savename (str): where to save the figure (full path)
remove_empty_bins (bool): Cut away preceeding and trailing zero bins
"""
if fig is None:
fig = p.figure()
ax = fig.gca()
if remove_empty_bins:
bmin = min(bincenters[bincontent > 0])
bmax = max(bincenters[bincontent > 0])
bincenters = bincenters[np.logical_and(bincenters >= bmin,
bincenters <= bmax)]
bincontent = bincontent[np.logical_and(bincenters >= bmin,
bincenters <= bmax)]
ax.plot(bincenters, bincontent, color=sb.color_palette("dark")[0])
ax.grid()
sb.despine(fig)
ax.set_xlabel("amplitude")
ax.set_ylabel("log nevents ")
p.tight_layout()
fig.savefig(savename)
return fig
def calculate_peak_to_valley_ratio(bestfitmodel,
mu_ped,
mu_spe,
control_plot=False):
"""
Calculate the peak to valley ratio
Args:
bestfitmodel (fit.Model): A fitted model to charge response data
mu_ped (float): The x value of the fitted pedestal
mu_spe (flota): The x value of the fitted spe peak
Keyword Args:
control_plot (bool): Show control plot to see if correct values are found
"""
tmpdata = bestfitmodel.prediction(bestfitmodel.xs)
valley = min(tmpdata[np.logical_and(bestfitmodel.xs > mu_ped,\
bestfitmodel.xs < mu_spe)])
valley_x = bestfitmodel.xs[tmpdata == valley]
peak = max(tmpdata[bestfitmodel.xs > valley_x])
peak_x = bestfitmodel.xs[tmpdata == peak]
peak_v_ratio = (peak / valley)
if control_plot:
fig = p.figure()
ax = fig.gca()
ax.plot(bestfitmodel.xs, tmpdata)
ax.scatter(valley_x, valley, marker="o")
ax.scatter(peak_x, peak, marker="o")
ax.set_ylim(ymin=1e-4)
ax.set_yscale("log")
ax.grid(1)
sb.despine()
return peak_v_ratio
def _plotTimeLog(plotData):
figure = plt.figure(figsize=(figureWidth, halfPageHeight), dpi=600)
ax = figure.gca()
sns.set_style(style='white')
nSet = set()
for j, P_d in enumerate(sorted(plotData, reverse=True)):
d1 = plotData[P_d]
for i, lambda_phi in enumerate(sorted(d1)):
d2 = d1[lambda_phi]
x = []
y = []
for N, (meanRuntime, percentiles) in d2.items():
x.append(N)
y.append(meanRuntime)
nSet.add(N)
x = np.array(x)
y = np.array(y)
x, y = (list(t) for t in zip(*sorted(zip(x, y))))
ax.plot(x,y, linestyle=linestyleList[i], color=colors[j],
label="$P_D$={0:}, $\lambda_\phi$={1:}".format(P_d, lambda_phi),
linewidth=linewidth)
ax.set_xlim(ax.get_xlim()[0]-0.5, ax.get_xlim()[1]+0.5)
ax.set_ylim(0,1)
ax.set_title("Tracking iteration runtime", fontsize=titleFontsize)
ax.set_xlabel("N", fontsize=labelFontsize, labelpad=0)
ax.set_ylabel("Average iteration time [s]", fontsize=labelFontsize)
ax.xaxis.set_ticks(sorted(list(nSet)))
ax.tick_params(labelsize=labelFontsize)
ax.legend(loc=0, fontsize=legendFontsize)
ax.grid(False)
sns.despine(ax=ax)
figure.tight_layout(pad=0.5, h_pad=0.5, w_pad=0.5)
return figure
def plot_rmsf(data, resid_data):
col = ['#8c96c6', '#8856a7', '#810f7c']
plt.style.use('ggplot')
sns.set_style('ticks')
ax = plt.subplot(111)
ax.plot(resid_data.resids, data, '-', linewidth=1, color=col[-1])
ax.fill_between(resid_data.resids, data, alpha=0.1, color=col[-1])
sns.despine(ax=ax, offset=2.5)
ax.set_xlabel("Residue number")
ax.set_ylabel(r"RMSF ($\AA$)")
#ax.set_ylim(top=9.5)
#ax.axvspan(4, 9, alpha=0.1, color='red') # mark the hydophobic patch region
# ax.axvspan(127, 132, alpha=0.5, color='red')
# ax.axvspan(250, 255, alpha=0.5, color='red')
plt.legend()
plt.savefig('rmsf.svg', format='svg')
plt.show()
def cornerplot(datas,
labels=None,
interact_plot=None,
lims=(-.1, .2),
highlight=None):
if interact_plot is None:
def interact_plot(data2, data1):
plt.plot(data2, data1, '.')
if highlight is not None:
plt.plot(data2[highlight], data1[highlight], 'r.')
plt.plot(plt.xlim(), plt.xlim(), '--', color='grey')
sns.despine(ax=plt.gca())
fig, axs = plt.subplots(len(datas), len(datas), figsize=(8, 8))
plt.subplots_adjust(hspace=.3, wspace=.3)
for i, data1 in enumerate(datas):
if labels:
axs[i, 0].set_ylabel(labels[i])
for j, data2 in enumerate(datas):
if labels and i == (len(datas) - 1):
axs[len(datas) - 1, j].set_xlabel(labels[j])
if i == j:
axs[i, j].hist(data1)
if lims is not None:
axs[i, j].set_xlim(lims)
sns.despine(ax=axs[i, j])
elif i > j:
plt.sca(axs[i, j])
interact_plot(data2, data1)
if lims is not None:
axs[i, j].set_xlim(lims)
axs[i, j].set_ylim(lims)
elif j > i:
axs[i, j].axis('off')
def show_parameters(axs, model, enrich, color='b'):
positions = np.linspace(-np.pi, np.pi, 1000)
bs, ks = model.shift_mean_var(positions)
recur = model.recur_by_position(positions)
axs[0].plot(positions, recur, color=color)
axs[0].axvline(ls='--', color='0.4', lw=0.5)
axs[0].set_xlim(-np.pi, np.pi)
axs[0].set_xticks([-np.pi, -np.pi / 2, 0, np.pi / 2, np.pi])
axs[0].set_xticklabels(['-0.50', '-0.25', '0', '0.25', '0.50'])
axs[0].set_ylim(-0.3, 1.3)
axs[0].set_yticks([0, 0.5, 1])
axs[0].tick_params(length=3, pad=1, top=False)
axs[0].set_xlabel('Distance from reward (fraction of belt)')
axs[0].set_ylabel('Recurrence probability')
axs[1].plot(positions, bs, color=color)
axs[1].axvline(ls='--', color='0.4', lw=0.5)
axs[1].axhline(ls='--', color='0.4', lw=0.5)
axs[1].tick_params(length=3, pad=1, top=False)
axs[1].set_xlim(-np.pi, np.pi)
axs[1].set_xticks([-np.pi, -np.pi / 2, 0, np.pi / 2, np.pi])
axs[1].set_xticklabels(['-0.50', '-0.25', '0', '0.25', '0.50'])
axs[1].set_ylim(-0.10 * 2 * np.pi, 0.10 * 2 * np.pi)
y_ticks = np.array(['-0.10', '-0.05', '0', '0.05', '0.10'])
axs[1].set_yticks(y_ticks.astype('float') * 2 * np.pi)
axs[1].set_yticklabels(y_ticks)
axs[1].set_xlabel('Initial distance from reward (fraction of belt)')
axs[1].set_ylabel(r'$\Delta$ position (fraction of belt)')
axs[2].plot(positions, 1 / ks, color=color)
axs[2].axvline(ls='--', color='0.4', lw=0.5)
axs[2].tick_params(length=3, pad=1, top=False)
axs[2].set_xlim(-np.pi, np.pi)
axs[2].set_xticks([-np.pi, -np.pi / 2, 0, np.pi / 2, np.pi])
axs[2].set_xticklabels(['-0.50', '-0.25', '0', '0.25', '0.50'])
axs[2].set_ylim(0, 1)
y_ticks = np.array(['0', '0.005', '0.010', '0.015', '0.020', '0.025'])
axs[2].set_yticks(y_ticks.astype('float') * (2 * np.pi)**2)
axs[2].set_yticklabels(y_ticks)
axs[2].set_xlabel('Initial distance from reward (fraction of belt)')
axs[2].set_ylabel(r'$\Delta$ position variance')
axs[3].plot(range(9), np.mean(enrich, axis=0), color=color)
axs[3].plot(range(9),
np.percentile(enrich, 5, axis=0),
ls='--',
color=color)
axs[3].plot(range(9),
np.percentile(enrich, 95, axis=0),
ls='--',
color=color)
axs[3].fill_between(range(9),
np.percentile(enrich, 5, axis=0),
np.percentile(enrich, 95, axis=0),
facecolor=color,
alpha=0.5)
axs[3].axhline(0, ls='--', color='0.4', lw=0.5)
sns.despine(ax=axs[3])
axs[3].tick_params(length=3, pad=2, direction='out')
axs[3].set_xlabel("Iteration ('session' #)")
axs[3].set_ylabel('Enrichment (fraction of belt)')
axs[3].set_xlim(-0.5, 8.5)
axs[3].set_xticks([0, 2, 4, 6, 8])
axs[3].set_ylim(-0.15, 0.10 * 2 * np.pi)
y_ticks = np.array(['0', '0.05', '0.10'])
axs[3].set_yticks(y_ticks.astype('float') * 2 * np.pi)
axs[3].set_yticklabels(y_ticks)
def plot_benchs():
output_dir = join(trace_dir, 'benches')
fig = plt.figure()
fig.subplots_adjust(right=.9)
fig.subplots_adjust(top=.905)
fig.subplots_adjust(bottom=.12)
fig.subplots_adjust(left=.06)
fig.set_figheight(fig.get_figheight() * 0.66)
gs = gridspec.GridSpec(1, 3, width_ratios=[1, 1, 1.5])
ylims = {'100k': [.90, .96], '1m': [.864, .915], '10m': [.80, .868],
'netflix': [.93, .99]}
xlims = {'100k': [0.0001, 10], '1m': [0.1, 20], '10m': [1, 400],
'netflix': [30, 3000]}
names = {'dl_partial': 'Proposed \n(partial projection)',
'dl': 'Proposed \n(full projection)',
'cd': 'Coordinate descent'}
zorder = {'cd': 10,
'dl': 1,
'dl_partial': 5}
for i, version in enumerate(['1m', '10m', 'netflix']):
try:
with open(join(output_dir, 'results_%s.json' % version), 'r') as f:
results = json.load(f)
except IOError:
continue
ax_time = fig.add_subplot(gs[0, i])
ax_time.grid()
sns.despine(fig, ax_time)
ax_time.spines['left'].set_color((.6, .6, .6))
ax_time.spines['bottom'].set_color((.6, .6, .6))
ax_time.xaxis.set_tick_params(color=(.6, .6, .6), which='both')
ax_time.yaxis.set_tick_params(color=(.6, .6, .6), which='both')
for tick in ax_time.xaxis.get_major_ticks():
tick.label.set_fontsize(7)
tick.label.set_color('black')
for tick in ax_time.yaxis.get_major_ticks():
tick.label.set_fontsize(7)
tick.label.set_color('black')
if i == 0:
ax_time.set_ylabel('RMSE on test set')
if i == 2:
ax_time.set_xlabel('CPU time')
ax_time.xaxis.set_label_coords(1.14, -0.06)
ax_time.grid()
palette = sns.cubehelix_palette(3, start=0, rot=.5, hue=1, dark=.3,
light=.7,
reverse=False)
color = {'dl_partial': palette[2], 'dl': palette[1], 'cd': palette[0]}
for idx in sorted(OrderedDict(results).keys()):
this_result = results[idx]
ax_time.plot(this_result['timings'], this_result['rmse'],
label=names[idx], color=color[idx],
linewidth=2,
linestyle='-' if idx != 'cd' else '--',
zorder=zorder[idx])
if version == 'netflix':
ax_time.legend(loc='upper left', bbox_to_anchor=(.65, 1.1),
numpoints=1,
frameon=False)
ax_time.set_xscale('log')
ax_time.set_ylim(ylims[version])
ax_time.set_xlim(xlims[version])
if version == '1m':
ax_time.set_xticks([.1, 1, 10])
ax_time.set_xticklabels(['0.1 s', '1 s', '10 s'])
elif version == '10m':
ax_time.set_xticks([1, 10, 100])
ax_time.set_xticklabels(['1 s', '10 s', '100 s'])
else:
ax_time.set_xticks([100, 1000])
ax_time.set_xticklabels(['100 s', '1000 s'])
ax_time.annotate(
'MovieLens %s' % version.upper() if version != 'netflix' else 'Netflix (140M)',
xy=(.5 if version != 'netflix' else .4, 1),
xycoords='axes fraction', ha='center', va='bottom')
plt.savefig(join(trace_dir, 'bench.pdf'))
def plot_learning_rate():
output_dir = join(trace_dir, 'learning_rate')
fig = plt.figure()
fig.subplots_adjust(bottom=0.33)
fig.subplots_adjust(top=0.99)
fig.subplots_adjust(right=0.98)
fig.set_figwidth(3.25653379549)
fig.set_figheight(1.25)
ax = {}
gs = gridspec.GridSpec(1, 2)
palette = sns.cubehelix_palette(10, start=0, rot=3, hue=1, dark=.3,
light=.7,
reverse=False)
for j, version in enumerate(['10m', 'netflix']):
with open(join(output_dir, 'results_%s.json' % version), 'r') as f:
data = json.load(f)
ax[j] = fig.add_subplot(gs[j])
learning_rates = sorted(data, key=lambda t: float(t))
for i, learning_rate in enumerate(learning_rates):
this_data = data[str(learning_rate)]
n_epochs = _get_hyperparams()['dl_partial'][version]['n_epochs']
ax[j].plot(np.linspace(0, n_epochs, len(this_data['rmse'])),
this_data['rmse'],
label='%.2f' % float(learning_rate),
color=palette[i],
zorder=int(100 * float(learning_rate)))
ax[j].set_xscale('log')
sns.despine(fig, ax)
ax[j].spines['left'].set_color((.6, .6, .6))
ax[j].spines['bottom'].set_color((.6, .6, .6))
ax[j].xaxis.set_tick_params(color=(.6, .6, .6), which='both')
ax[j].yaxis.set_tick_params(color=(.6, .6, .6), which='both')
ax[j].tick_params(axis='y', labelsize=6)
ax[0].set_ylabel('RMSE on test set')
ax[0].set_xlabel('Epoch', ha='left', va='top')
ax[0].xaxis.set_label_coords(-.18, -0.055)
ax[0].set_xlim([.1, 40])
ax[0].set_xticks([1, 10, 40])
ax[0].set_xticklabels(['1', '10', '40'])
ax[1].set_xlim([.1, 25])
ax[1].set_xticks([.1, 1, 10, 20])
ax[1].set_xticklabels(['.1', '1', '10', '20'])
ax[0].annotate('MovieLens 10M', xy=(.95, .9), ha='right',
xycoords='axes fraction', zorder=100)
ax[1].annotate('Netflix', xy=(.95, .9), ha='right',
xycoords='axes fraction', zorder=100)
ax[0].set_ylim([0.795, 0.877])
ax[1].set_ylim([0.93, .999])
ax[0].legend(ncol=4, loc='upper left', bbox_to_anchor=(-0.09, -.13),
fontsize=7, numpoints=1, columnspacing=.3, frameon=False)
ax[0].annotate('Learning rate $\\beta$', xy=(1.6, -.38),
xycoords='axes fraction')
ltext = ax[0].get_legend().get_texts()
plt.setp(ltext, fontsize=7)
plt.savefig(join(trace_dir, 'learning_rate.pdf'))
def main():
all_grps = df.loadExptGrps('GOL')
WT_expt_grp = all_grps['WT_place_set']
Df_expt_grp = all_grps['Df_place_set']
expt_grps = [WT_expt_grp, Df_expt_grp]
if MALES_ONLY:
for expt_grp in expt_grps:
expt_grp.filter(lambda expt: expt.parent.get('sex') == 'M')
WT_label = WT_expt_grp.label()
Df_label = Df_expt_grp.label()
fig = plt.figure(figsize=(8.5, 11))
gs1 = plt.GridSpec(2,
5,
left=0.1,
right=0.3,
top=0.90,
bottom=0.67,
hspace=0.2)
gs1_2 = plt.GridSpec(2,
5,
left=0.3,
right=0.5,
top=0.90,
bottom=0.67,
hspace=0.2)
WT_1_heatmap_ax = fig.add_subplot(gs1[0, :-1])
WT_3_heatmap_ax = fig.add_subplot(gs1_2[0, :-1])
Df_1_heatmap_ax = fig.add_subplot(gs1[1, :-1])
Df_3_heatmap_ax = fig.add_subplot(gs1_2[1, :-1])
gs_cbar = plt.GridSpec(2,
10,
left=0.3,
right=0.5,
top=0.90,
bottom=0.67,
hspace=0.2)
WT_colorbar_ax = fig.add_subplot(gs_cbar[0, -1])
Df_colorbar_ax = fig.add_subplot(gs_cbar[1, -1])
gs2 = plt.GridSpec(1, 10, left=0.1, right=0.5, top=0.6, bottom=0.45)
pf_close_fraction_ax = fig.add_subplot(gs2[0, :4])
pf_close_behav_corr_ax = fig.add_subplot(gs2[0, 5:])
frac_near_range_2 = (-0.051, 0.551)
behav_range_2 = (-0.051, 0.551)
#
# Heatmaps
#
WT_cmap = sns.light_palette(WT_color, as_cmap=True)
WT_dataframe = lab.ExperimentGroup.dataframe(
WT_expt_grp, include_columns=['X_condition', 'X_day', 'X_session'])
WT_1_expt_grp = WT_expt_grp.subGroup(
list(WT_dataframe[(WT_dataframe['X_condition'] == 'C')
& (WT_dataframe['X_day'] == '0') &
(WT_dataframe['X_session'] == '0')]['expt']))
place.plotPositionHeatmap(WT_1_expt_grp,
roi_filter=WT_filter,
ax=WT_1_heatmap_ax,
norm='individual',
cbar_visible=False,
cmap=WT_cmap,
plotting_order='place_cells_only',
show_belt=False,
reward_in_middle=True)
fix_heatmap_ax(WT_1_heatmap_ax, WT_1_expt_grp)
WT_1_heatmap_ax.set_title(r'Condition $\mathrm{III}$: Day 1')
WT_1_heatmap_ax.set_ylabel(WT_label)
WT_1_heatmap_ax.set_xlabel('')
WT_3_expt_grp = WT_expt_grp.subGroup(
list(WT_dataframe[(WT_dataframe['X_condition'] == 'C')
& (WT_dataframe['X_day'] == '2') &
(WT_dataframe['X_session'] == '0')]['expt']))
place.plotPositionHeatmap(WT_3_expt_grp,
roi_filter=WT_filter,
ax=WT_3_heatmap_ax,
norm='individual',
cbar_visible=True,
cax=WT_colorbar_ax,
cmap=WT_cmap,
plotting_order='place_cells_only',
show_belt=False,
reward_in_middle=True)
fix_heatmap_ax(WT_3_heatmap_ax, WT_3_expt_grp)
WT_3_heatmap_ax.set_title(r'Condition $\mathrm{III}$: Day 3')
WT_3_heatmap_ax.set_ylabel('')
WT_3_heatmap_ax.set_xlabel('')
WT_colorbar_ax.set_yticklabels(['Min', 'Max'])
Df_cmap = sns.light_palette(Df_color, as_cmap=True)
Df_dataframe = lab.ExperimentGroup.dataframe(
Df_expt_grp, include_columns=['X_condition', 'X_day', 'X_session'])
Df_1_expt_grp = Df_expt_grp.subGroup(
list(Df_dataframe[(Df_dataframe['X_condition'] == 'C')
& (Df_dataframe['X_day'] == '0') &
(Df_dataframe['X_session'] == '2')]['expt']))
place.plotPositionHeatmap(Df_1_expt_grp,
roi_filter=Df_filter,
ax=Df_1_heatmap_ax,
norm='individual',
cbar_visible=False,
cmap=Df_cmap,
plotting_order='place_cells_only',
show_belt=False,
reward_in_middle=True)
fix_heatmap_ax(Df_1_heatmap_ax, Df_1_expt_grp)
Df_1_heatmap_ax.set_ylabel(Df_label)
Df_3_expt_grp = Df_expt_grp.subGroup(
list(Df_dataframe[(Df_dataframe['X_condition'] == 'C')
& (Df_dataframe['X_day'] == '2') &
(Df_dataframe['X_session'] == '0')]['expt']))
place.plotPositionHeatmap(Df_3_expt_grp,
roi_filter=Df_filter,
ax=Df_3_heatmap_ax,
norm='individual',
cbar_visible=True,
cax=Df_colorbar_ax,
cmap=Df_cmap,
plotting_order='place_cells_only',
show_belt=False,
reward_in_middle=True)
fix_heatmap_ax(Df_3_heatmap_ax, Df_3_expt_grp)
Df_3_heatmap_ax.set_ylabel('')
Df_colorbar_ax.set_yticklabels(['Min', 'Max'])
#
# Fraction of PCs near reward
#
activity_metric = place.centroid_to_position_threshold
activity_kwargs = {
'method': 'resultant_vector',
'positions': 'reward',
'pcs_only': True,
'threshold': np.pi / 8
}
behavior_fn = ra.fraction_licks_in_reward_zone
behavior_kwargs = {}
behavior_label = 'Fraction of licks in reward zone'
plotting.plot_metric(pf_close_fraction_ax,
expt_grps,
metric_fn=activity_metric,
roi_filters=roi_filters,
groupby=[['expt', 'X_condition', 'X_day']],
plotby=['X_condition', 'X_day'],
plot_abs=False,
plot_method='line',
activity_kwargs=activity_kwargs,
rotate_labels=False,
activity_label='Fraction of place cells near reward',
label_every_n=1,
colors=colors,
markers=markers,
markersize=5,
return_full_dataframes=False,
linestyles=linestyles)
pf_close_fraction_ax.axhline(1 / 8., linestyle='--', color='k')
pf_close_fraction_ax.set_title('')
sns.despine(ax=pf_close_fraction_ax)
pf_close_fraction_ax.set_xlabel('Day in Condition')
day_number_only_label(pf_close_fraction_ax)
label_conditions(pf_close_fraction_ax)
pf_close_fraction_ax.legend(loc='upper left', fontsize=6)
pf_close_fraction_ax.set_ylim(0, 0.40)
pf_close_fraction_ax.set_yticks([0, 0.1, 0.2, 0.3, 0.4])
scatter_kws = {'s': 5}
colorby_list = [(expt_grp.label(), 'C') for expt_grp in expt_grps]
pf_close_behav_corr_ax.set_xlim(frac_near_range_2)
pf_close_behav_corr_ax.set_ylim(behav_range_2)
plotting.plot_paired_metrics(
expt_grps,
first_metric_fn=place.centroid_to_position_threshold,
second_metric_fn=behavior_fn,
roi_filters=roi_filters,
groupby=(('expt', ), ),
colorby=('expt_grp', 'X_condition'),
filter_fn=lambda df: df['X_condition'] == 'C',
filter_columns=['X_condition'],
first_metric_kwargs=activity_kwargs,
second_metric_kwargs=behavior_kwargs,
first_metric_label='Fraction of place cells near reward',
second_metric_label=behavior_label,
shuffle_colors=False,
fit_reg=True,
plot_method='regplot',
colorby_list=colorby_list,
colors=colors,
markers=markers,
ax=pf_close_behav_corr_ax,
scatter_kws=scatter_kws,
truncate=False,
linestyles=linestyles)
pf_close_behav_corr_ax.set_xlim(frac_near_range_2)
pf_close_behav_corr_ax.set_ylim(behav_range_2)
pf_close_behav_corr_ax.tick_params(direction='in')
pf_close_behav_corr_ax.get_legend().set_visible(False)
pf_close_behav_corr_ax.legend(loc='upper left', fontsize=6)
misc.save_figure(fig, filename, save_dir=save_dir)
plt.close('all')
def summaryPlot(self, axratio=2, filename=None, showLegend=True,
precip=True, inflow=True, outflow=True, figopts={},
serieslabels={}):
'''
Creates a figure showing the hydrlogic record (flow and
precipitation) of the storm
Input:
axratio : optional float or int (default = 2)
Relative height of the flow axis compared to the
precipiation axis.
filename : optional string (default = None)
Filename to which the figure will be saved.
**figwargs will be passed on to `plt.Figure`
Writes:
Figure of flow and precipitation for a storm
Returns:
None
'''
fig = plt.figure(**figopts)
gs = gridspec.GridSpec(nrows=2, ncols=1, height_ratios=[1, axratio],
hspace=0.12)
rainax = fig.add_subplot(gs[0])
rainax.yaxis.set_major_locator(plt.MaxNLocator(5))
flowax = fig.add_subplot(gs[1], sharex=rainax)
# create the legend proxy artists
artists = []
labels = []
legcols = 0
# in the label assignment: `serieslabels.pop(item, item)` might
# seem odd. What it does is looks for a label (value) in the
# dictionary with the key equal to `item`. If there is no valur
# for that key in the dictionary the `item` itself is returned.
# so if there's nothing called "test" in mydict,
# `mydict.pop("test", "test")` returns `"test"`.
if inflow:
fig, labels, artists = self.plot_hydroquantity(
self.inflowcol,
ax=flowax,
label=serieslabels.pop(self.inflowcol, self.inflowcol),
otherlabels=labels,
artists=artists,
)
if outflow:
fig, labels, arti = self.plot_hydroquantity(
self.outflowcol,
ax=flowax,
label=serieslabels.pop(self.outflowcol, self.outflowcol),
otherlabels=labels,
artists=artists
)
if precip:
fig, labels, arti = self.plot_hydroquantity(
self.precipcol,
ax=rainax,
label=serieslabels.pop(self.precipcol, self.precipcol),
otherlabels=labels,
artists=artists
)
rainax.invert_yaxis()
if showLegend:
leg = rainax.legend(artists, labels, fontsize=7, ncol=1,
markerscale=0.75, frameon=False,
loc='lower right')
leg.get_frame().set_zorder(25)
_leg = [leg]
else:
_leg = None
seaborn.despine(ax=rainax, bottom=True, top=False)
seaborn.despine(ax=flowax)
flowax.set_xlabel('')
rainax.set_xlabel('')
# grid lines and axis background color and layout
#fig.tight_layout()
if filename is not None:
fig.savefig(filename, dpi=300, transparent=True,
bbox_inches='tight', bbox_extra_artists=_leg)
return fig, artists, labels
def pairedcontrast(data, x, y, idcol, reps = 3000,
statfunction = None, idx = None, figsize = None,
beforeAfterSpacer = 0.01,
violinWidth = 0.005,
floatOffset = 0.05,
showRawData = False,
showAllYAxes = False,
floatContrast = True,
smoothboot = False,
floatViolinOffset = None,
showConnections = True,
summaryBar = False,
contrastYlim = None,
swarmYlim = None,
barWidth = 0.005,
rawMarkerSize = 8,
rawMarkerType = 'o',
summaryMarkerSize = 10,
summaryMarkerType = 'o',
summaryBarColor = 'grey',
meansSummaryLineStyle = 'solid',
contrastZeroLineStyle = 'solid', contrastEffectSizeLineStyle = 'solid',
contrastZeroLineColor = 'black', contrastEffectSizeLineColor = 'black',
pal = None,
legendLoc = 2, legendFontSize = 12, legendMarkerScale = 1,
axis_title_size = None,
yticksize = None,
xticksize = None,
tickAngle=45,
tickAlignment='right',
**kwargs):
# Preliminaries.
data = data.dropna()
# plot params
if axis_title_size is None:
axis_title_size = 15
if yticksize is None:
yticksize = 12
if xticksize is None:
xticksize = 12
axisTitleParams = {'labelsize' : axis_title_size}
xtickParams = {'labelsize' : xticksize}
ytickParams = {'labelsize' : yticksize}
rc('axes', **axisTitleParams)
rc('xtick', **xtickParams)
rc('ytick', **ytickParams)
## If `idx` is not specified, just take the FIRST TWO levels alphabetically.
if idx is None:
idx = tuple(np.unique(data[x])[0:2],)
else:
# check if multi-plot or not
if all(isinstance(element, str) for element in idx):
# if idx is supplied but not a multiplot (ie single list or tuple)
if len(idx) != 2:
print(idx, "does not have length 2.")
sys.exit(0)
else:
idx = (tuple(idx, ),)
elif all(isinstance(element, tuple) for element in idx):
# if idx is supplied, and it is a list/tuple of tuples or lists, we have a multiplot!
if ( any(len(element) != 2 for element in idx) ):
# If any of the tuples contain more than 2 elements.
print(element, "does not have length 2.")
sys.exit(0)
if floatViolinOffset is None:
floatViolinOffset = beforeAfterSpacer/2
if contrastYlim is not None:
contrastYlim = np.array([contrastYlim[0],contrastYlim[1]])
if swarmYlim is not None:
swarmYlim = np.array([swarmYlim[0],swarmYlim[1]])
## Here we define the palette on all the levels of the 'x' column.
## Thus, if the same pandas dataframe is re-used across different plots,
## the color identity of each group will be maintained.
## Set palette based on total number of categories in data['x'] or data['hue_column']
if 'hue' in kwargs:
u = kwargs['hue']
else:
u = x
if ('color' not in kwargs and 'hue' not in kwargs):
kwargs['color'] = 'k'
if pal is None:
pal = dict( zip( data[u].unique(), sns.color_palette(n_colors = len(data[u].unique())) )
)
else:
pal = pal
# Initialise figure.
if figsize is None:
if len(idx) > 2:
figsize = (12,(12/np.sqrt(2)))
else:
figsize = (6,6)
fig = plt.figure(figsize = figsize)
# Initialise GridSpec based on `levs_tuple` shape.
gsMain = gridspec.GridSpec( 1, np.shape(idx)[0]) # 1 row; columns based on number of tuples in tuple.
# Set default statfunction
if statfunction is None:
statfunction = np.mean
# Create list to collect all the contrast DataFrames generated.
contrastList = list()
contrastListNames = list()
for gsIdx, xlevs in enumerate(idx):
## Pivot tempdat to get before and after lines.
data_pivot = data.pivot_table(index = idcol, columns = x, values = y)
# Start plotting!!
if floatContrast is True:
ax_raw = fig.add_subplot(gsMain[gsIdx], frame_on = False)
ax_contrast = ax_raw.twinx()
else:
gsSubGridSpec = gridspec.GridSpecFromSubplotSpec(2, 1, subplot_spec = gsMain[gsIdx])
ax_raw = plt.Subplot(fig, gsSubGridSpec[0, 0], frame_on = False)
ax_contrast = plt.Subplot(fig, gsSubGridSpec[1, 0], sharex = ax_raw, frame_on = False)
## Plot raw data as swarmplot or stripplot.
if showRawData is True:
swarm_raw = sns.swarmplot(data = data,
x = x, y = y,
order = xlevs,
ax = ax_raw,
palette = pal,
size = rawMarkerSize,
marker = rawMarkerType,
**kwargs)
else:
swarm_raw = sns.stripplot(data = data,
x = x, y = y,
order = xlevs,
ax = ax_raw,
palette = pal,
**kwargs)
swarm_raw.set_ylim(swarmYlim)
## Get some details about the raw data.
maxXBefore = max(swarm_raw.collections[0].get_offsets().T[0])
minXAfter = min(swarm_raw.collections[1].get_offsets().T[0])
if showRawData is True:
#beforeAfterSpacer = (getSwarmSpan(swarm_raw, 0) + getSwarmSpan(swarm_raw, 1))/2
beforeAfterSpacer = 1
xposAfter = maxXBefore + beforeAfterSpacer
xAfterShift = minXAfter - xposAfter
## shift the after swarmpoints closer for aesthetic purposes.
offsetSwarmX(swarm_raw.collections[1], -xAfterShift)
## pandas DataFrame of 'before' group
x1 = pd.DataFrame({str(xlevs[0] + '_x') : pd.Series(swarm_raw.collections[0].get_offsets().T[0]),
xlevs[0] : pd.Series(swarm_raw.collections[0].get_offsets().T[1]),
'_R_' : pd.Series(swarm_raw.collections[0].get_facecolors().T[0]),
'_G_' : pd.Series(swarm_raw.collections[0].get_facecolors().T[1]),
'_B_' : pd.Series(swarm_raw.collections[0].get_facecolors().T[2]),
})
## join the RGB columns into a tuple, then assign to a column.
x1['_hue_'] = x1[['_R_', '_G_', '_B_']].apply(tuple, axis=1)
x1 = x1.sort_values(by = xlevs[0])
x1.index = data_pivot.sort_values(by = xlevs[0]).index
## pandas DataFrame of 'after' group
### create convenient signifiers for column names.
befX = str(xlevs[0] + '_x')
aftX = str(xlevs[1] + '_x')
x2 = pd.DataFrame( {aftX : pd.Series(swarm_raw.collections[1].get_offsets().T[0]),
xlevs[1] : pd.Series(swarm_raw.collections[1].get_offsets().T[1])} )
x2 = x2.sort_values(by = xlevs[1])
x2.index = data_pivot.sort_values(by = xlevs[1]).index
## Join x1 and x2, on both their indexes.
plotPoints = x1.merge(x2, left_index = True, right_index = True, how='outer')
## Add the hue column if hue argument was passed.
if 'hue' in kwargs:
h = kwargs['hue']
plotPoints[h] = data.pivot(index = idcol, columns = x, values = h)[xlevs[0]]
swarm_raw.legend(loc = legendLoc,
fontsize = legendFontSize,
markerscale = legendMarkerScale)
## Plot the lines to join the 'before' points to their respective 'after' points.
if showConnections is True:
for i in plotPoints.index:
ax_raw.plot([ plotPoints.ix[i, befX],
plotPoints.ix[i, aftX] ],
[ plotPoints.ix[i, xlevs[0]],
plotPoints.ix[i, xlevs[1]] ],
linestyle = 'solid',
color = plotPoints.ix[i, '_hue_'],
linewidth = 0.75,
alpha = 0.75
)
## Hide the raw swarmplot data if so desired.
if showRawData is False:
swarm_raw.collections[0].set_visible(False)
swarm_raw.collections[1].set_visible(False)
if showRawData is True:
#maxSwarmSpan = max(np.array([getSwarmSpan(swarm_raw, 0), getSwarmSpan(swarm_raw, 1)]))/2
maxSwarmSpan = 0.5
else:
maxSwarmSpan = barWidth
## Plot Summary Bar.
if summaryBar is True:
# Calculate means
means = data.groupby([x], sort = True).mean()[y]
# # Calculate medians
# medians = data.groupby([x], sort = True).median()[y]
## Draw summary bar.
bar_raw = sns.barplot(x = means.index,
y = means.values,
order = xlevs,
ax = ax_raw,
ci = 0,
facecolor = summaryBarColor,
alpha = 0.25)
## Draw zero reference line.
ax_raw.add_artist(Line2D(
(ax_raw.xaxis.get_view_interval()[0],
ax_raw.xaxis.get_view_interval()[1]),
(0,0),
color='black', linewidth=0.75
)
)
## get swarm with largest span, set as max width of each barplot.
for i, bar in enumerate(bar_raw.patches):
x_width = bar.get_x()
width = bar.get_width()
centre = x_width + width/2.
if i == 0:
bar.set_x(centre - maxSwarmSpan/2.)
else:
bar.set_x(centre - xAfterShift - maxSwarmSpan/2.)
bar.set_width(maxSwarmSpan)
# Get y-limits of the treatment swarm points.
beforeRaw = pd.DataFrame( swarm_raw.collections[0].get_offsets() )
afterRaw = pd.DataFrame( swarm_raw.collections[1].get_offsets() )
before_leftx = min(beforeRaw[0])
after_leftx = min(afterRaw[0])
after_rightx = max(afterRaw[0])
after_stat_summary = statfunction(beforeRaw[1])
# Calculate the summary difference and CI.
plotPoints['delta_y'] = plotPoints[xlevs[1]] - plotPoints[xlevs[0]]
plotPoints['delta_x'] = [0] * np.shape(plotPoints)[0]
tempseries = plotPoints['delta_y'].tolist()
test = tempseries.count(tempseries[0]) != len(tempseries)
bootsDelta = bootstrap(plotPoints['delta_y'],
statfunction = statfunction,
smoothboot = smoothboot,
reps = reps)
summDelta = bootsDelta['summary']
lowDelta = bootsDelta['bca_ci_low']
highDelta = bootsDelta['bca_ci_high']
# set new xpos for delta violin.
if floatContrast is True:
if showRawData is False:
xposPlusViolin = deltaSwarmX = after_rightx + floatViolinOffset
else:
xposPlusViolin = deltaSwarmX = after_rightx + maxSwarmSpan
else:
xposPlusViolin = xposAfter
if showRawData is True:
# If showRawData is True and floatContrast is True,
# set violinwidth to the barwidth.
violinWidth = maxSwarmSpan
xmaxPlot = xposPlusViolin + violinWidth
# Plot the summary measure.
ax_contrast.plot(xposPlusViolin, summDelta,
marker = 'o',
markerfacecolor = 'k',
markersize = summaryMarkerSize,
alpha = 0.75
)
# Plot the CI.
ax_contrast.plot([xposPlusViolin, xposPlusViolin],
[lowDelta, highDelta],
color = 'k',
alpha = 0.75,
linestyle = 'solid'
)
# Plot the violin-plot.
v = ax_contrast.violinplot(bootsDelta['stat_array'], [xposPlusViolin],
widths = violinWidth,
showextrema = False,
showmeans = False)
halfviolin(v, half = 'right', color = 'k')
# Remove left axes x-axis title.
ax_raw.set_xlabel("")
# Remove floating axes y-axis title.
ax_contrast.set_ylabel("")
# Set proper x-limits
ax_raw.set_xlim(before_leftx - beforeAfterSpacer/2, xmaxPlot)
ax_raw.get_xaxis().set_view_interval(before_leftx - beforeAfterSpacer/2,
after_rightx + beforeAfterSpacer/2)
ax_contrast.set_xlim(ax_raw.get_xlim())
if floatContrast is True:
# Set the ticks locations for ax_raw.
ax_raw.get_xaxis().set_ticks((0, xposAfter))
# Make sure they have the same y-limits.
ax_contrast.set_ylim(ax_raw.get_ylim())
# Drawing in the x-axis for ax_raw.
## Set the tick labels!
ax_raw.set_xticklabels(xlevs, rotation = tickAngle, horizontalalignment = tickAlignment)
## Get lowest y-value for ax_raw.
y = ax_raw.get_yaxis().get_view_interval()[0]
# Align the left axes and the floating axes.
align_yaxis(ax_raw, statfunction(plotPoints[xlevs[0]]),
ax_contrast, 0)
# Add label to floating axes. But on ax_raw!
ax_raw.text(x = deltaSwarmX,
y = ax_raw.get_yaxis().get_view_interval()[0],
horizontalalignment = 'left',
s = 'Difference',
fontsize = 15)
# Set reference lines
## zero line
ax_contrast.hlines(0, # y-coordinate
ax_contrast.xaxis.get_majorticklocs()[0], # x-coordinates, start and end.
ax_raw.xaxis.get_view_interval()[1],
linestyle = 'solid',
linewidth = 0.75,
color = 'black')
## effect size line
ax_contrast.hlines(summDelta,
ax_contrast.xaxis.get_majorticklocs()[1],
ax_raw.xaxis.get_view_interval()[1],
linestyle = 'solid',
linewidth = 0.75,
color = 'black')
# Align the left axes and the floating axes.
align_yaxis(ax_raw, after_stat_summary, ax_contrast, 0.)
else:
# Set the ticks locations for ax_raw.
ax_raw.get_xaxis().set_ticks((0, xposAfter))
fig.add_subplot(ax_raw)
fig.add_subplot(ax_contrast)
ax_contrast.set_ylim(contrastYlim)
# Calculate p-values.
# 1-sample t-test to see if the mean of the difference is different from 0.
ttestresult = ttest_1samp(plotPoints['delta_y'], popmean = 0)[1]
bootsDelta['ttest_pval'] = ttestresult
contrastList.append(bootsDelta)
contrastListNames.append( str(xlevs[1])+' v.s. '+str(xlevs[0]) )
# Turn contrastList into a pandas DataFrame,
contrastList = pd.DataFrame(contrastList).T
contrastList.columns = contrastListNames
# Now we iterate thru the contrast axes to normalize all the ylims.
for j,i in enumerate(range(1, len(fig.get_axes()), 2)):
axx=fig.get_axes()[i]
## Get max and min of the dataset.
lower = np.min(contrastList.ix['stat_array',j])
upper = np.max(contrastList.ix['stat_array',j])
meandiff = contrastList.ix['summary', j]
## Make sure we have zero in the limits.
if lower > 0:
lower = 0.
if upper < 0:
upper = 0.
## Get tick distance on raw axes.
## This will be the tick distance for the contrast axes.
rawAxesTicks = fig.get_axes()[i-1].yaxis.get_majorticklocs()
rawAxesTickDist = rawAxesTicks[1] - rawAxesTicks[0]
## First re-draw of axis with new tick interval
axx.yaxis.set_major_locator(MultipleLocator(rawAxesTickDist))
newticks1 = fig.get_axes()[i].get_yticks()
if floatContrast is False:
if (showAllYAxes is False and i in range( 2, len(fig.get_axes())) ):
axx.get_yaxis().set_visible(showAllYAxes)
else:
## Obtain major ticks that comfortably encompass lower and upper.
newticks2 = list()
for a,b in enumerate(newticks1):
if (b >= lower and b <= upper):
# if the tick lies within upper and lower, take it.
newticks2.append(b)
# if the meandiff falls outside of the newticks2 set, add a tick in the right direction.
if np.max(newticks2) < meandiff:
ind = np.where(newticks1 == np.max(newticks2))[0][0] # find out the max tick index in newticks1.
newticks2.append( newticks1[ind+1] )
elif meandiff < np.min(newticks2):
ind = np.where(newticks1 == np.min(newticks2))[0][0] # find out the min tick index in newticks1.
newticks2.append( newticks1[ind-1] )
newticks2 = np.array(newticks2)
newticks2.sort()
axx.yaxis.set_major_locator(FixedLocator(locs = newticks2))
## Draw zero reference line.
axx.hlines(y = 0,
xmin = fig.get_axes()[i].get_xaxis().get_view_interval()[0],
xmax = fig.get_axes()[i].get_xaxis().get_view_interval()[1],
linestyle = contrastZeroLineStyle,
linewidth = 0.75,
color = contrastZeroLineColor)
sns.despine(ax = fig.get_axes()[i], trim = True,
bottom = False, right = True,
left = False, top = True)
## Draw back the lines for the relevant y-axes.
drawback_y(axx)
## Draw back the lines for the relevant x-axes.
drawback_x(axx)
elif floatContrast is True:
## Get the original ticks on the floating y-axis.
newticks1 = fig.get_axes()[i].get_yticks()
## Obtain major ticks that comfortably encompass lower and upper.
newticks2 = list()
for a,b in enumerate(newticks1):
if (b >= lower and b <= upper):
# if the tick lies within upper and lower, take it.
newticks2.append(b)
# if the meandiff falls outside of the newticks2 set, add a tick in the right direction.
if np.max(newticks2) < meandiff:
ind = np.where(newticks1 == np.max(newticks2))[0][0] # find out the max tick index in newticks1.
newticks2.append( newticks1[ind+1] )
elif meandiff < np.min(newticks2):
ind = np.where(newticks1 == np.min(newticks2))[0][0] # find out the min tick index in newticks1.
newticks2.append( newticks1[ind-1] )
newticks2 = np.array(newticks2)
newticks2.sort()
## Re-draw the axis.
axx.yaxis.set_major_locator(FixedLocator(locs = newticks2))
## Despine and trim the axes.
sns.despine(ax = axx, trim = True,
bottom = False, right = False,
left = True, top = True)
for i in range(0, len(fig.get_axes()), 2):
# Loop through the raw data swarmplots and despine them appropriately.
if floatContrast is True:
sns.despine(ax = fig.get_axes()[i], trim = True, right = True)
else:
sns.despine(ax = fig.get_axes()[i], trim = True, bottom = True, right = True)
fig.get_axes()[i].get_xaxis().set_visible(False)
# Draw back the lines for the relevant y-axes.
ymin = fig.get_axes()[i].get_yaxis().get_majorticklocs()[0]
ymax = fig.get_axes()[i].get_yaxis().get_majorticklocs()[-1]
x, _ = fig.get_axes()[i].get_xaxis().get_view_interval()
fig.get_axes()[i].add_artist(Line2D((x, x), (ymin, ymax), color='black', linewidth=1.5))
# Zero gaps between plots on the same row, if floatContrast is False
if (floatContrast is False and showAllYAxes is False):
gsMain.update(wspace = 0)
else:
# Tight Layout!
gsMain.tight_layout(fig)
# And we're done.
rcdefaults() # restore matplotlib defaults.
sns.set() # restore seaborn defaults.
return fig, contrastList
def display_explained_variance_density(output_dir):
dir_list = [join(output_dir, f) for f in os.listdir(output_dir) if
os.path.isdir(join(output_dir, f))]
fig = plt.figure(figsize=(fig_width * 0.73, fig_height))
gs = gridspec.GridSpec(1, 2, width_ratios=[1, 1])
fig.subplots_adjust(bottom=0.29)
fig.subplots_adjust(left=0.075)
fig.subplots_adjust(right=.92)
results = []
analyses = []
ref_time = 1000000
for dir_name in dir_list:
try:
analyses.append(
json.load(open(join(dir_name, 'analysis.json'), 'r')))
results.append(
json.load(open(join(dir_name, 'results.json'), 'r')))
if results[-1]['reduction'] == 12:
timings = np.array(results[-1]['timings'])
diff = timings[1:] - timings[:1]
ref_time = min(ref_time, np.min(diff))
except IOError:
pass
print(ref_time)
h_reductions = []
ax = {}
ylim = {1e-2: [2.455e8, 2.525e8], 1e-3: [2.3e8, 2.47e8],
1e-4: [2.16e8, 2.42e8]}
for i, alpha in enumerate([1e-3, 1e-4]):
ax[alpha] = fig.add_subplot(gs[:, i])
if i == 0:
ax[alpha].set_ylabel('Objective value on test set')
ax[alpha].annotate('$\\lambda = 10^{%.0f}$' % log(alpha, 10),
xy=(.65, .85),
fontsize=8,
xycoords='axes fraction')
ax[alpha].set_xlim([.05, 200])
ax[alpha].set_ylim(ylim[alpha])
for tick in ax[alpha].xaxis.get_major_ticks():
tick.label.set_fontsize(7)
ax[alpha].set_xscale('log')
ax[alpha].set_xticks([.1, 1, 10, 100])
ax[alpha].set_xticklabels(['.1 h', '1 h', '10 h', '100 h'])
sns.despine(fig=fig, ax=ax[alpha])
ax[alpha].spines['left'].set_color((.6, .6, .6))
ax[alpha].spines['bottom'].set_color((.6, .6, .6))
ax[alpha].xaxis.set_tick_params(color=(.6, .6, .6), which='both')
ax[alpha].yaxis.set_tick_params(color=(.6, .6, .6), which='both')
for tick in ax[alpha].xaxis.get_major_ticks():
tick.label.set_color('black')
for tick in ax[alpha].yaxis.get_major_ticks():
tick.label.set_fontsize(6)
tick.label.set_color('black')
t = ax[alpha].yaxis.get_offset_text()
t.set_size(5)
ax[1e-4].set_xlabel('CPU\ntime', ha='right')
ax[1e-4].xaxis.set_label_coords(1.15, -0.05)
colormap = sns.cubehelix_palette(4, start=0, rot=0., hue=1, dark=.3,
light=.7,
reverse=False)
other_colormap = sns.cubehelix_palette(4, start=0, rot=.5, hue=1, dark=.3,
light=.7,
reverse=False)
colormap[0] = other_colormap[0]
colormap_dict = {reduction: color for reduction, color in
zip([1, 4, 8, 12],
colormap)}
x_bar = []
y_bar_objective = []
y_bar_density = []
hue_bar = []
for result, analysis in zip(results, analyses):
if result['alpha'] != 1e-2 and result['reduction'] != 2:
print("%s %s" % (result['alpha'], result['reduction']))
timings = (np.array(analysis['records']) + 1) / int(
result['reduction']) * 12 * ref_time / 3600
# timings = np.array(result['timings'])[np.array(analysis['records']) + 1] / 3600
s, = ax[result[
'alpha']].plot(
timings,
np.array(analysis['objectives']) / 4,
color=colormap_dict[int(result['reduction'])],
linewidth=2,
linestyle='--' if result[
'reduction'] == 1 else '-',
zorder=result['reduction'] if result[
'reduction'] != 1 else 100)
if result['alpha'] == 1e-3:
h_reductions.append(
(s, '%.0f' % result['reduction']))
handles, labels = list(zip(*h_reductions[::-1]))
argsort = sorted(range(len(labels)), key=lambda t: int(labels[t]))
handles = [handles[i] for i in argsort]
labels = [labels[i] for i in argsort]
offset = .3
yoffset = -.05
legend_vanilla = mlegend.Legend(ax[1e-3], handles[:1], ['No reduction'],
loc='lower left',
ncol=5,
numpoints=1,
handlelength=2,
markerscale=1.4,
bbox_to_anchor=(
0.3 + offset, -.39 + yoffset),
fontsize=8,
frameon=False
)
legend_ratio = mlegend.Legend(ax[1e-3], handles[1:], labels[1:],
loc='lower left',
ncol=5,
markerscale=1.4,
handlelength=2,
fontsize=8,
bbox_to_anchor=(
0.3 + offset, -.54 + yoffset),
frameon=False
)
ax[1e-3].annotate('Original online algorithm',
xy=(0.28 + offset, -.27 + yoffset),
xycoords='axes fraction',
horizontalalignment='right', verticalalignment='bottom',
fontsize=8)
ax[1e-3].annotate('Proposed reduction factor $r$',
xy=(0.28 + offset, -.42 + yoffset),
xycoords='axes fraction',
horizontalalignment='right', verticalalignment='bottom',
fontsize=8)
ax[1e-3].add_artist(legend_ratio)
ax[1e-3].add_artist(legend_vanilla)
ax[1e-3].annotate('(a) Convergence speed', xy=(0.7, 1.02), ha='center',
fontsize=9, va='bottom', xycoords='axes fraction')
fig.savefig(join(output_dir, 'hcp_bench.pdf'))
for result, analysis in zip(results, analyses):
if result['alpha'] != 1e-2 and result['reduction'] != 2:
x_bar.append(result['alpha'])
y_bar_objective.append(analysis['objectives'][-1])
y_bar_density.append(analysis['densities'][-1])
hue_bar.append(result['reduction'])
ref_objective = {}
for objective, alpha, reduction in zip(y_bar_objective, x_bar, hue_bar):
if reduction == 1:
ref_objective[alpha] = objective
for i, (objective, alpha) in enumerate(zip(y_bar_objective, x_bar)):
y_bar_objective[i] /= ref_objective[alpha]
y_bar_objective[i] -= 1
####################### Final objective
fig = plt.figure(figsize=(fig_width * 0.27, fig_height))
fig.subplots_adjust(bottom=0.29)
fig.subplots_adjust(left=0.05)
fig.subplots_adjust(right=1.2)
fig.subplots_adjust(top=0.85)
gs = gridspec.GridSpec(2, 1, width_ratios=[1, 1], height_ratios=[1.2, 0.8])
ax_bar_objective = fig.add_subplot(gs[0])
ax_bar_objective.set_ylim(-0.007, 0.007)
ax_bar_objective.set_yticks([-0.005, 0, 0.005])
ax_bar_objective.set_yticklabels(['-0.5\%', '0\%', '0.5\%'])
ax_bar_objective.tick_params(axis='y', labelsize=6)
sns.despine(fig=fig, ax=ax_bar_objective, left=True, right=False)
sns.barplot(x=x_bar, y=y_bar_objective, hue=hue_bar, ax=ax_bar_objective,
order=[1e-3, 1e-4],
palette=colormap)
plt.setp(ax_bar_objective.patches, linewidth=0.1)
ax_bar_objective.legend_ = None
ax_bar_objective.get_xaxis().set_visible(False)
ax_bar_objective.set_xlim([-.5, 1.6])
ax_bar_objective.annotate('Final\nobjective\ndeviation\n(relative)',
xy=(1.28, 0.45), fontsize=7, va='center',
xycoords='axes fraction')
ax_bar_objective.annotate('(Less is better)', xy=(.06, 0.1), fontsize=7,
va='center', xycoords='axes fraction')
ax_bar_objective.yaxis.set_label_position('right')
################################## Density
x_bar = []
y_bar_density = []
hue_bar = []
for result, analysis in zip(results, analyses):
if result['alpha'] != 1e-2 and result['reduction'] != 2:
x_bar.append(result['alpha'])
y_bar_density.append(analysis['densities'][-1])
hue_bar.append(result['reduction'])
ax_bar_density = fig.add_subplot(gs[1])
ax_bar_density.set_yscale('log')
ax_bar_density.set_ylim(100, 1000)
ax_bar_density.set_yticks([100, 1000])
ax_bar_density.set_yticklabels(['100', '1000'])
ax_bar_density.tick_params(axis='y', labelsize=6)
sns.barplot(x=x_bar, y=y_bar_density, hue=hue_bar, ax=ax_bar_density,
order=[1e-3, 1e-4],
palette=colormap)
ax_bar_density.set_xticklabels(['$10^{-2}$', '$10^{-3}$', '$10^{-4}$'])
sns.despine(fig=fig, ax=ax_bar_density, left=True, right=False)
# ax_bar_density.get_xaxis().set_ticks([])
ax_bar_density.set_xlim([-.5, 1.6])
ax_bar_density.set_xlabel('Regularization $\\lambda$')
ax_bar_density.annotate('$\\frac{\\ell_1}{\\ell_2}(\\mathbf D)$',
xy=(1.26, 0.45),
fontsize=7, va='center', xycoords='axes fraction')
ax_bar_density.yaxis.set_label_position('right')
plt.setp(ax_bar_density.patches, linewidth=0.1)
ax_bar_density.legend_ = None
for ax in [ax_bar_density, ax_bar_objective]:
ax.spines['right'].set_color((.6, .6, .6))
ax.spines['bottom'].set_color((.6, .6, .6))
ax.xaxis.set_tick_params(color=(.6, .6, .6), which='both')
ax.yaxis.set_tick_params(color=(.6, .6, .6), which='both')
for tic in ax_bar_density.xaxis.get_major_ticks():
tic.tick1On = tic.tick2On = False
ax_bar_objective.spines['bottom'].set_position(('data', 0))
ax_bar_objective.spines['bottom'].set_linewidth(.3)
ax_bar_objective.annotate('(b) Decomposition quality', xy=(0.7, 1.21),
ha='center', va='bottom', fontsize=9,
xycoords='axes fraction')
fig.savefig(expanduser(join(output_dir, 'bar_plot.pdf')))
def display_explained_variance_epoch(output_dir):
dir_list = [join(output_dir, f) for f in os.listdir(output_dir) if
os.path.isdir(join(output_dir, f))]
fig = plt.figure()
gs = gridspec.GridSpec(1, 1, width_ratios=[1])
fig.set_figwidth(3.25653379549)
fig.set_figheight(1.3)
fig.subplots_adjust(bottom=0.105)
fig.subplots_adjust(top=0.9)
fig.subplots_adjust(left=0.12)
fig.subplots_adjust(right=.95)
results = []
analyses = []
ref_time = 1000000
for dir_name in dir_list:
try:
analyses.append(
json.load(open(join(dir_name, 'analysis.json'), 'r')))
results.append(
json.load(open(join(dir_name, 'results.json'), 'r')))
if results[-1]['reduction'] == 12:
timings = np.array(results[-1]['timings'])
diff = timings[1:] - timings[:1]
ref_time = min(ref_time, np.min(diff))
except IOError:
pass
h_reductions = []
ax = {}
ylim = {1e-2: [2.475e8, 2.522e8], 1e-3: [2.3e8, 2.335e8],
1e-4: [2.16e8, 2.24e8]}
for i, alpha in enumerate([1e-4]):
ax[alpha] = fig.add_subplot(gs[:, i])
if i == 0:
ax[alpha].set_ylabel('Objective value on test set')
ax[alpha].set_xlim([50, 4000])
for tick in ax[alpha].xaxis.get_major_ticks():
tick.label.set_fontsize(7)
ax[alpha].set_xscale('log')
ax[alpha].set_xticks([100, 1000, 1947, 4000])
ax[alpha].set_xticklabels(['100', '1000', 'Epoch', '4000'])
ax[alpha].set_ylim(ylim[alpha])
sns.despine(fig=fig, ax=ax[alpha])
ax[alpha].spines['left'].set_color((.6, .6, .6))
ax[alpha].spines['bottom'].set_color((.6, .6, .6))
ax[alpha].xaxis.set_tick_params(color=(.6, .6, .6), which='both')
ax[alpha].yaxis.set_tick_params(color=(.6, .6, .6), which='both')
for tick in ax[alpha].xaxis.get_major_ticks():
tick.label.set_color('black')
for tick in ax[alpha].yaxis.get_major_ticks():
tick.label.set_fontsize(7)
tick.label.set_color('black')
t = ax[alpha].yaxis.get_offset_text()
t.set_size(6)
ax[1e-4].set_xlabel('Records')
ax[1e-4].xaxis.set_label_coords(-0.04, -0.047)
colormap = sns.cubehelix_palette(4, start=0, rot=0., hue=1, dark=.3,
light=.7,
reverse=False)
other_colormap = sns.cubehelix_palette(4, start=0, rot=.5, hue=1, dark=.3,
light=.7,
reverse=False)
colormap[0] = other_colormap[0]
colormap_dict = {reduction: color for reduction, color in
zip([1, 4, 8, 12],
colormap)}
for result, analysis in zip(results, analyses):
if result['alpha'] in [1e-4] and result['reduction'] in [1, 4, 8, 12]:
print("%s %s" % (result['alpha'], result['reduction']))
s, = ax[result[
'alpha']].plot(np.array(analysis['records']),
np.array(analysis['objectives']) / 4,
color=colormap_dict[result['reduction']],
linewidth=1.5,
linestyle='--' if result[
'reduction'] == 1 else '-',
zorder=result['reduction'] if result[
'reduction'] > 1 else 100)
h_reductions.append(
(s, result['reduction']))
handles, labels = list(zip(*h_reductions[::-1]))
argsort = sorted(range(len(labels)), key=lambda t: int(labels[t]))
handles = [handles[i] for i in argsort]
labels = [('$r=%i$' % labels[i]) for i in argsort]
labels[0] = 'No reduction\n(original alg.)'
ax[1e-4].annotate('$\\lambda = 10^{%.0f}$' % log(alpha, 10),
xy=(0.07, 0.07),
ha='left',
va='bottom',
fontsize=8,
xycoords='axes fraction')
legend_ratio = mlegend.Legend(ax[1e-4], handles[0:], labels[0:],
loc='upper right',
ncol=1,
numpoints=1,
handlelength=2,
frameon=False,
bbox_to_anchor=(1, 1.15)
)
ax[1e-4].add_artist(legend_ratio)
fig.savefig(join(output_dir, 'hcp_epoch.pdf'))
color_dict[1] = ref_colormap[0]
for method, sub_data in data.groupby('method'):
for _, this_data in sub_data.iterrows():
if method == 'sgd':
label = 'SGD (best step-size)'
color = sgd_colormap[0]
else:
reduction = this_data['reduction']
color = color_dict[reduction]
if reduction == 1:
label = 'Online matrix factorization'
else:
label = 'SOMF ($r = %i$)' % reduction
time = np.array(this_data['time'])
# Offset log
time += 4
ax.plot(this_data['time'], this_data['score'],
label=label,
color=color,
linestyle='-')
ax.set_xscale('log')
ax.set_ylabel('Test objective value')
ax.yaxis.set_label_coords(-0.13, 0.38)
ax.set_xlabel('Time')
ax.ticklabel_format(axis='y', style='sci', scilimits=(-2, 2))
ax.legend(frameon=False, loc='upper right', bbox_to_anchor=(1., 1.))
sns.despine(fig, ax)
plt.savefig(join(analysis_dir, 'bench.pdf'))
plt.show()
def main():
hidden_grps = df.loadExptGrps('GOL')
WT_expt_grp_hidden = hidden_grps['WT_place_set']
Df_expt_grp_hidden = hidden_grps['Df_place_set']
expt_grps_hidden = [WT_expt_grp_hidden, Df_expt_grp_hidden]
acute_grps = df.loadExptGrps('RF')
WT_expt_grp_acute = acute_grps['WT_place_set'].unpair()
Df_expt_grp_acute = acute_grps['Df_place_set'].unpair()
expt_grps_acute = [WT_expt_grp_acute, Df_expt_grp_acute]
WT_label = WT_expt_grp_hidden.label()
Df_label = Df_expt_grp_hidden.label()
labels = [WT_label, Df_label]
fig = plt.figure(figsize=(8.5, 11))
gs1 = plt.GridSpec(1, 1, top=0.9, bottom=0.7, left=0.1, right=0.20)
across_ctx_ax = fig.add_subplot(gs1[0, 0])
gs2 = plt.GridSpec(3, 1, top=0.9, bottom=0.7, left=0.25, right=0.35)
wt_pie_ax = fig.add_subplot(gs2[0, 0])
df_pie_ax = fig.add_subplot(gs2[1, 0])
shuffle_pie_ax = fig.add_subplot(gs2[2, 0])
pie_axs = (wt_pie_ax, df_pie_ax, shuffle_pie_ax)
gs3 = plt.GridSpec(1, 1, top=0.9, bottom=0.7, left=0.4, right=0.5)
cue_cell_bar_ax = fig.add_subplot(gs3[0, 0])
gs5 = plt.GridSpec(1, 1, top=0.5, bottom=0.3, left=0.1, right=0.3)
acute_stability_ax = fig.add_subplot(gs5[0, 0])
acute_stability_inset_ax = fig.add_axes([0.23, 0.32, 0.05, 0.08])
gs6 = plt.GridSpec(1, 1, top=0.5, bottom=0.3, left=0.4, right=0.5)
task_compare_ax = fig.add_subplot(gs6[0, 0])
#
# RF Compare
#
params = {}
params['filename'] = filename
params_cent_shift_pc = {}
params_cent_shift_pc['stability_fn'] = place.activity_centroid_shift
params_cent_shift_pc['stability_kwargs'] = {
'activity_filter': 'pc_both',
'circ_var_pcs': False,
'units': 'norm',
'shuffle': True
}
params_cent_shift_pc['stability_label'] = \
'Centroid shift (fraction of belt)'
params_cent_shift_all = {}
params_cent_shift_all['stability_fn'] = place.activity_centroid_shift
params_cent_shift_all['stability_kwargs'] = {
'activity_filter': 'active_both',
'circ_var_pcs': False,
'units': 'norm',
'shuffle': True
}
params_cent_shift_all['stability_label'] = \
'Centroid shift (fraction of belt)'
params_cent_shift_all['stability_inset_ylim'] = (0.15, 0.30)
params_cent_shift_all['stability_cdf_range'] = (0.15, 0.35)
params_cent_shift_all['stability_cdf_ticks'] = \
(0.15, 0.20, 0.25, 0.30, 0.35)
params_cent_shift_all['stability_compare_ylim'] = (0.15, 0.27)
params_cent_shift_all['stability_compare_yticks'] = (0.15, 0.20, 0.25)
params_cent_shift_all['ctx_compare_ylim'] = (0.10, 0.30)
params_cent_shift_all['ctx_compare_yticks'] = \
(0.10, 0.15, 0.20, 0.25, 0.30)
params_cent_shift_cm = {}
params_cent_shift_cm['stability_fn'] = place.activity_centroid_shift
params_cent_shift_cm['stability_kwargs'] = {
'activity_filter': 'active_both',
'circ_var_pcs': False,
'units': 'cm',
'shuffle': True
}
params_cent_shift_cm['stability_label'] = 'Centroid shift (cm)'
params_pop_vect_corr = {}
params_pop_vect_corr['stability_fn'] = place.population_vector_correlation
params_pop_vect_corr['stability_kwargs'] = {
'method': 'corr',
'activity_filter': 'pc_both',
'min_pf_density': 0.05,
'circ_var_pcs': False
}
params_pop_vect_corr['stability_label'] = 'Population vector correlation'
params_pf_corr = {}
params_pf_corr['stability_fn'] = place.place_field_correlation
params_pf_corr['stability_kwargs'] = {'activity_filter': 'pc_either'}
params_pf_corr['stability_label'] = 'Place field correlation'
params_pf_corr['stability_inset_ylim'] = (0, 0.50)
params_pf_corr['stability_cdf_range'] = (0.15, 0.55)
params_pf_corr['stability_cdf_ticks'] = (0.15, 0.25, 0.35, 0.45, 0.55)
params_pf_corr['stability_compare_ylim'] = (0.22, 0.40)
params_pf_corr['stability_compare_yticks'] = (0.25, 0.30, 0.35, 0.40)
params_pf_corr['hidden_ctx_compare_ylim'] = (0.22, 0.40)
params_pf_corr['hidden_ctx_compare_yticks'] = (0.25, 0.30, 0.35, 0.40)
params_pf_corr['ctx_compare_ylim'] = (0.22, 0.40)
params_pf_corr['ctx_compare_yticks'] = (0.25, 0.30, 0.35, 0.40)
params.update(params_cent_shift_all)
day_paired_grps_acute = [
grp.pair('consecutive groups', groupby=['day_in_df'])
for grp in expt_grps_acute
]
paired_grps_acute = day_paired_grps_acute
paired_grps_hidden = [
grp.pair('consecutive groups', groupby=['X_condition', 'X_day'])
for grp in expt_grps_hidden
]
filter_fn = lambda df: (df['expt_pair_label'] == 'SameAll')
filter_columns = ['expt_pair_label']
acute_stability = plotting.plot_metric(
acute_stability_ax,
paired_grps_acute,
metric_fn=params['stability_fn'],
groupby=[['expt_pair_label', 'second_expt']],
plotby=None,
plot_method='cdf',
plot_abs=True,
roi_filters=roi_filters,
activity_kwargs=params['stability_kwargs'],
plot_shuffle=True,
shuffle_plotby=False,
pool_shuffle=True,
activity_label=params['stability_label'],
colors=colors,
rotate_labels=False,
filter_fn=filter_fn,
filter_columns=filter_columns,
return_full_dataframes=False,
linestyles=linestyles)
acute_stability_ax.set_xlabel(params['stability_label'])
acute_stability_ax.set_title('')
sns.despine(ax=acute_stability_ax)
acute_stability_ax.set_xlim(params['stability_cdf_range'])
acute_stability_ax.set_xticks(params['stability_cdf_ticks'])
acute_stability_ax.legend(loc='upper left', fontsize=6)
plotting.plot_metric(acute_stability_inset_ax,
paired_grps_acute,
metric_fn=params['stability_fn'],
groupby=[['second_expt'], ['second_mouseID']],
plotby=None,
plot_method='swarm',
plot_abs=True,
roi_filters=roi_filters,
activity_kwargs=params['stability_kwargs'],
plot_shuffle=True,
shuffle_plotby=False,
pool_shuffle=True,
activity_label=params['stability_label'],
colors=colors,
rotate_labels=False,
filter_fn=filter_fn,
filter_columns=filter_columns,
linewidth=0.2,
edgecolor='gray',
plot_shuffle_as_hline=True)
acute_stability_inset_ax.get_legend().set_visible(False)
sns.despine(ax=acute_stability_inset_ax)
acute_stability_inset_ax.set_title('')
acute_stability_inset_ax.set_ylabel('')
acute_stability_inset_ax.set_xlabel('')
acute_stability_inset_ax.tick_params(bottom=False, labelbottom=False)
acute_stability_inset_ax.set_ylim(params['stability_inset_ylim'])
acute_stability_inset_ax.set_yticks(params['stability_inset_ylim'])
tmp_fig = plt.figure()
tmp_ax = tmp_fig.add_subplot(111)
hidden_stability = plotting.plot_metric(
tmp_ax,
paired_grps_hidden,
metric_fn=params['stability_fn'],
groupby=[['expt_pair_label', 'second_expt']],
plotby=('expt_pair_label', ),
plot_method='line',
plot_abs=True,
roi_filters=roi_filters,
activity_kwargs=params['stability_kwargs'],
plot_shuffle=True,
shuffle_plotby=False,
pool_shuffle=True,
activity_label=params['stability_label'],
colors=colors,
rotate_labels=False,
filter_fn=filter_fn,
filter_columns=filter_columns,
return_full_dataframes=False)
plt.close(tmp_fig)
wt_acute = acute_stability[WT_label]['dataframe']
wt_acute_shuffle = acute_stability[WT_label]['shuffle']
df_acute = acute_stability[Df_label]['dataframe']
df_acute_shuffle = acute_stability[Df_label]['shuffle']
wt_hidden = hidden_stability[WT_label]['dataframe']
wt_hidden_shuffle = hidden_stability[WT_label]['shuffle']
df_hidden = hidden_stability[Df_label]['dataframe']
df_hidden_shuffle = hidden_stability[Df_label]['shuffle']
for dataframe in (wt_acute, wt_acute_shuffle, df_acute, df_acute_shuffle):
dataframe['task'] = 'RF'
for dataframe in (wt_hidden, wt_hidden_shuffle, df_hidden,
df_hidden_shuffle):
dataframe['task'] = 'GOL'
WT_data = wt_acute.append(wt_hidden, ignore_index=True)
Df_data = df_acute.append(df_hidden, ignore_index=True)
WT_shuffle = wt_acute_shuffle.append(wt_hidden_shuffle, ignore_index=True)
Df_shuffle = df_acute_shuffle.append(df_hidden_shuffle, ignore_index=True)
filter_columns = ('expt_pair_label', )
filter_fn = lambda df: (df['expt_pair_label'] == 'SameAll')
order_dict = {'RF': 0, 'GOL': 1}
WT_data['order'] = WT_data['task'].map(order_dict)
Df_data['order'] = Df_data['task'].map(order_dict)
line_kwargs = {'markersize': 4}
plotting.plot_dataframe(task_compare_ax, [WT_data, Df_data],
[WT_shuffle, Df_shuffle],
labels=labels,
activity_label='',
groupby=[['task', 'second_mouseID']],
plotby=('task', ),
plot_method='box_and_line',
colors=colors,
filter_fn=filter_fn,
filter_columns=filter_columns,
plot_shuffle=True,
shuffle_plotby=False,
pool_shuffle=True,
orderby='order',
notch=False,
plot_shuffle_as_hline=True,
markers=markers,
linestyles=linestyles,
line_kwargs=line_kwargs,
flierprops={
'markersize': 3,
'marker': 'o'
},
whis='range')
task_compare_ax.set_title('')
sns.despine(ax=task_compare_ax)
task_compare_ax.set_ylim(params['stability_compare_ylim'])
task_compare_ax.set_yticks(params['stability_compare_yticks'])
task_compare_ax.set_xlabel('')
task_compare_ax.set_ylabel(params['stability_label'])
task_compare_ax.legend(loc='upper right', fontsize=6)
#
# Stability across transition
#
groupby = [['second_expt'], ['second_mouse']]
filter_fn = lambda df: (df['X_first_condition'] == 'A') \
& (df['X_second_condition'] == 'B')
filter_columns = ('X_first_condition', 'X_second_condition')
plotting.plot_metric(across_ctx_ax,
paired_grps_hidden,
metric_fn=params['stability_fn'],
groupby=groupby,
plotby=None,
plot_method='swarm',
activity_kwargs=params['stability_kwargs'],
plot_shuffle=True,
shuffle_plotby=False,
pool_shuffle=True,
colors=colors,
activity_label=params['stability_label'],
rotate_labels=False,
filter_fn=filter_fn,
filter_columns=filter_columns,
plot_shuffle_as_hline=True,
return_full_dataframes=False,
plot_bar=True,
roi_filters=roi_filters)
sns.despine(ax=across_ctx_ax)
across_ctx_ax.set_ylim(0.0, 0.3)
across_ctx_ax.set_yticks([0.0, 0.1, 0.2, 0.3])
across_ctx_ax.set_xticklabels([])
across_ctx_ax.set_xlabel('')
across_ctx_ax.set_title('')
across_ctx_ax.get_legend().set_visible(False)
plotting.stackedText(across_ctx_ax, labels, colors=colors, loc=2, size=10)
#
# Cue remapping
#
THRESHOLD = 0.05 * 2 * np.pi
CUENESS_THRESHOLD = 0.33
def first_cue_position(row):
expt = row['first_expt']
cue = row['cue']
cues = expt.belt().cues(normalized=True)
first_cue = cues.ix[cues['cue'] == cue]
pos = (first_cue['start'] + first_cue['stop']) / 2
angle = pos * 2 * np.pi
return np.complex(np.cos(angle), np.sin(angle))
def dotproduct(v1, v2):
return sum((a * b) for a, b in zip(v1, v2))
def length(v):
return math.sqrt(dotproduct(v, v))
def angle(v1, v2):
return math.acos(
np.round(dotproduct(v1, v2) / (length(v1) * length(v2)), 3))
def distance_to_first_cue(row):
centroid = row['second_centroid']
pos = row['first_cue_position']
return angle((pos.real, pos.imag), (centroid.real, centroid.imag))
WT_copy = copy(WT_expt_grp_hidden)
WT_copy.filterby(lambda df: ~df['X_condition'].str.contains('C'),
['X_condition'])
WT_paired = WT_copy.pair('consecutive groups',
groupby=['X_condition',
'X_day']).pair('consecutive groups',
groupby=['X_condition'])
Df_copy = copy(Df_expt_grp_hidden)
Df_copy.filterby(lambda df: ~df['X_condition'].str.contains('C'),
['X_condition'])
Df_paired = Df_copy.pair('consecutive groups',
groupby=['X_condition',
'X_day']).pair('consecutive groups',
groupby=['X_condition'])
WT_df, WT_shuffle_df = place.cue_cell_remapping(
WT_paired,
roi_filter=WT_filter,
near_threshold=THRESHOLD,
activity_filter='active_both',
circ_var_pcs=False,
shuffle=True)
Df_df, Df_shuffle_df = place.cue_cell_remapping(
Df_paired,
roi_filter=Df_filter,
near_threshold=THRESHOLD,
activity_filter='active_both',
circ_var_pcs=False,
shuffle=True)
shuffle_df = pd.concat([WT_shuffle_df, Df_shuffle_df], ignore_index=True)
cueness, cueness_fraction = [], []
cue_n, place_n, neither_n = [], [], []
for grp_df in (WT_df, Df_df, shuffle_df):
grp_df['first_cue_position'] = grp_df.apply(first_cue_position, axis=1)
grp_df['second_distance_to_first_cue_position'] = grp_df.apply(
distance_to_first_cue, axis=1)
grp_df['cueness'] = grp_df['second_distance_to_first_cue_position'] / \
(grp_df['value'] + grp_df['second_distance_to_first_cue_position'])
plotting.prepare_dataframe(grp_df, ['first_mouse'])
cueness_fraction.append([[]])
cue_n.append([])
place_n.append([])
neither_n.append([])
for mouse, mouse_df in grp_df.groupby('first_mouse'):
cue_n[-1].append((mouse_df['cueness'] >
(1 - CUENESS_THRESHOLD)).sum())
place_n[-1].append((mouse_df['cueness'] < CUENESS_THRESHOLD).sum())
neither_n[-1].append(mouse_df.shape[0] - cue_n[-1][-1] -
place_n[-1][-1])
cueness_fraction[-1][0].append(cue_n[-1][-1] /
float(place_n[-1][-1]))
cueness.append([grp_df['cueness']])
cue_labels = labels + ['shuffle']
plotting.swarm_plot(cue_cell_bar_ax,
cueness_fraction[:2],
condition_labels=labels,
colors=colors,
plot_bar=True)
cue_cell_bar_ax.axhline(np.mean(cueness_fraction[-1][0]),
ls='--',
color='k')
sns.despine(ax=cue_cell_bar_ax)
cue_cell_bar_ax.set_ylim(0, 1.5)
cue_cell_bar_ax.set_yticks([0, 0.5, 1.0, 1.5])
cue_cell_bar_ax.set_xticklabels([])
cue_cell_bar_ax.set_xlabel('')
cue_cell_bar_ax.set_ylabel('Cue-to-position ratio')
cue_cell_bar_ax.get_legend().set_visible(False)
plotting.stackedText(cue_cell_bar_ax,
labels,
colors=colors,
loc=2,
size=10)
WT_colors = sns.light_palette(WT_color, 7)[:-6:-2]
Df_colors = sns.light_palette(Df_color, 7)[:-6:-2]
shuffle_colors = sns.light_palette('k', 7)[:-6:-2]
pie_colors = (WT_colors, Df_colors, shuffle_colors)
pie_labels = ['cue', 'position', 'neither']
orig_size = mpl.rcParams.get('xtick.labelsize')
mpl.rcParams['xtick.labelsize'] = 5
for grp_ax, grp_label, grp_cue_n, grp_place_n, grp_neither_n, p_cs in zip(
pie_axs, cue_labels, cue_n, place_n, neither_n, pie_colors):
grp_ax.pie([sum(grp_cue_n),
sum(grp_place_n),
sum(grp_neither_n)],
autopct='%1.0f%%',
shadow=False,
frame=False,
labels=pie_labels,
colors=p_cs,
textprops={'fontsize': 5})
grp_ax.set_title(grp_label)
plotting.square_axis(grp_ax)
mpl.rcParams['xtick.labelsize'] = orig_size
misc.save_figure(fig, params['filename'], save_dir=save_dir)
plt.close('all')
dcd_file = sys.argv[3]
dat_file = sys.argv[4] + '.dat'
out_file = sys.argv[4] + '.png'
u = mda.Universe(psf_file, dcd_file)
ref = mda.Universe(psf_file, pdb_file) # default the 0th frame
R = MDAnalysis.analysis.rms.RMSD(u, ref, select = "backbone", filename=dat_file)
R.run()
R.save()
rmsd = R.rmsd.T
time = rmsd[1]
import seaborn.apionly as sns
#matplotlib inline
plt.style.use('ggplot')
rcParams.update({'figure.autolayout': True})
sns.set_style('ticks')
fig = plt.figure(figsize=(5,3))
ax = fig.add_subplot(111)
color = sns.color_palette()[2]
#ax.fill_between(ca.residues.resids, rmsf, alpha=0.3, color=color)
ax.plot(time, rmsd[2], lw=1, color=color)
sns.despine(ax=ax)
ax.set_xlabel("Time (ps)")
ax.set_ylabel(r"RMSD ($\AA$)")
ax.set_xlim(0, max(time))
ax.set_ylim(0, 10)
fig.savefig(out_file)
def _plotInitializationTime2D(plotData, loadFilePath, simLength, timeStep, nTargets):
timeArray = np.arange(0, simLength, timeStep)
for M_init, d1 in plotData.items():
for N_init, d2 in d1.items():
figure = plt.figure(figsize=(figureWidth, fullPageHeight), dpi=600)
ax11 = figure.add_subplot(311)
ax12 = figure.add_subplot(312)
ax13 = figure.add_subplot(313)
sns.set_style(style='white')
savePath = _getSavePath(loadFilePath, "Time({0:}-{1:})".format(M_init, N_init))
cpfmList = []
falseCPFMlist = []
accFalseTrackList = []
for k, (lambda_phi, d3) in enumerate(d2.items()):
for j, (P_d, (correctInitTimeLog, falseInitTimeLog)) in enumerate(d3.items()):
falsePFM = np.zeros_like(timeArray)
pmf = np.zeros_like(timeArray)
falseTrackDelta = np.zeros_like(timeArray)
for i, time in enumerate(timeArray):
if str(time) in correctInitTimeLog:
pmf[i] = correctInitTimeLog[str(time)]
if str(time) in falseInitTimeLog:
falsePFM[i] = falseInitTimeLog[str(time)][0]
falseTrackDelta[i] = falseInitTimeLog[str(time)][1]
cpmf = np.cumsum(pmf) / float(nTargets)
falseCPFM = np.cumsum(falsePFM)
falseTrackDelta = np.cumsum(falseTrackDelta)
cpfmList.append((P_d, lambda_phi, cpmf))
falseCPFMlist.append((P_d, lambda_phi, falseCPFM))
accFalseTrackList.append((P_d, lambda_phi, falseTrackDelta))
cpfmList.sort(key=lambda tup: float(tup[1]))
cpfmList.sort(key=lambda tup: float(tup[0]), reverse=True)
falseCPFMlist.sort(key=lambda tup: float(tup[1]))
falseCPFMlist.sort(key=lambda tup: float(tup[0]), reverse=True)
accFalseTrackList.sort(key=lambda tup: float(tup[1]))
accFalseTrackList.sort(key=lambda tup: float(tup[0]), reverse=True)
pdSet = set()
lambdaPhiSet = set()
for P_d, lambda_phi, cpmf in cpfmList:
if P_d not in pdSet:
lambdaPhiSet.clear()
pdSet.add(P_d)
lambdaPhiSet.add(lambda_phi)
ax11.plot(timeArray,
cpmf,
label="$P_D$ = {0:}, $\lambda_\phi$ = {1:}".format(P_d, float(lambda_phi)),
c=colors[len(pdSet)-1],
linestyle=linestyleList[len(lambdaPhiSet)-1],
linewidth=linewidth)
pdSet = set()
lambdaPhiSet = set()
for P_d, lambda_phi, cpmf in falseCPFMlist:
if P_d not in pdSet:
lambdaPhiSet.clear()
pdSet.add(P_d)
lambdaPhiSet.add(lambda_phi)
ax12.semilogy(timeArray,
cpmf+(1e-10),
label="$P_D$ = {0:}, $\lambda_\phi$ = {1:}".format(P_d, float(lambda_phi)),
c=colors[len(pdSet)-1],
linestyle=linestyleList[len(lambdaPhiSet)-1],
linewidth=linewidth)
pdSet = set()
lambdaPhiSet = set()
for P_d, lambda_phi, accFalseTrack in accFalseTrackList:
if P_d not in pdSet:
lambdaPhiSet.clear()
pdSet.add(P_d)
lambdaPhiSet.add(lambda_phi)
ax13.plot(timeArray,
accFalseTrack,
label="$P_D$ = {0:}, $\lambda_\phi$ = {1:}".format(P_d, float(lambda_phi)),
c=colors[len(pdSet) - 1],
linestyle=linestyleList[len(lambdaPhiSet) - 1],
linewidth=linewidth)
ax11.set_xlabel("Time [s]", fontsize=labelFontsize)
ax11.set_ylabel("Average cpfm", fontsize=labelFontsize)
ax11.set_title("Cumulative Probability Mass Function", fontsize=titleFontsize)
ax11.legend(loc=4, ncol=len(pdSet), fontsize=legendFontsize)
ax11.grid(False)
ax11.set_xlim(0, simLength)
ax11.set_ylim(0,1)
ax11.xaxis.set_ticks(np.arange(0,simLength+15, 15))
ax11.tick_params(labelsize=labelFontsize)
sns.despine(ax=ax11, offset=0)
ax12.set_xlabel("Time [s]", fontsize=labelFontsize)
ax12.set_ylabel("Average number of tracks", fontsize=labelFontsize)
ax12.set_title("Accumulative number of erroneous tracks", fontsize=titleFontsize)
ax12.grid(False)
ax12.set_xlim(0, simLength)
ax12.set_ylim(1e-3,1000)
ax12.xaxis.set_ticks(np.arange(0,simLength+15, 15))
ax12.tick_params(labelsize=labelFontsize)
sns.despine(ax=ax12, offset=0)
ax13.set_xlabel("Time [s]", fontsize=labelFontsize)
ax13.set_ylabel("Average number of tracks", fontsize=labelFontsize)
ax13.set_title("Number of erroneous tracks alive", fontsize=titleFontsize)
ax13.grid(False)
ax13.set_xlim(0, simLength)
ax13.set_ylim(-0.02, max(1,ax13.get_ylim()[1]))
ax13.xaxis.set_ticks(np.arange(0,simLength+15, 15))
ax13.tick_params(labelsize=labelFontsize)
sns.despine(ax=ax13, offset=0)
figure.tight_layout(pad=0.8, h_pad=0.8, w_pad=0.8)
figure.savefig(savePath)
figure.clf()
plt.close()
source = ['Lustre', 'SSD']
size = ['9000', '900']
analysis = ['RDF', 'RMS']
scheduler = ['distr', 'multi']
nodes = ['3nodes', '6nodes']
scheduler_full_name = {'distr': 'distributed', 'multi': 'multiprocessing'}
# for Lustre distributed
for ana in analysis:
fig = plt.figure(figsize=(12, 8), tight_layout=True)
gs = gridspec.GridSpec(5, 9)
ax0 = fig.add_subplot(gs[0:2, 0:3])
ax0.set_xlabel('Number of cores')
ax0.set_ylabel('Wait (s)')
sns.despine(offset=10, ax=ax0)
ax0.set_title('pmda.{} on 900 frames'.format(ana.lower()))
ax0.set_xscale("log")
ax0.set_yscale("log")
ax1 = fig.add_subplot(gs[0:2, 3:6])
ax1.set_xlabel('Number of cores')
ax1.set_ylabel('Compute per block (s)')
sns.despine(offset=10, ax=ax1)
ax1.set_title('pmda.{} on 900 frames'.format(ana.lower()))
ax1.set_xscale("log")
ax1.set_yscale("log")
ax2 = fig.add_subplot(gs[0:2, 6:9])
def pairedcontrast(data,
x,
y,
idcol,
reps=3000,
statfunction=None,
idx=None,
figsize=None,
beforeAfterSpacer=0.01,
violinWidth=0.005,
floatOffset=0.05,
showRawData=False,
showAllYAxes=False,
floatContrast=True,
smoothboot=False,
floatViolinOffset=None,
showConnections=True,
summaryBar=False,
contrastYlim=None,
swarmYlim=None,
barWidth=0.005,
rawMarkerSize=8,
rawMarkerType='o',
summaryMarkerSize=10,
summaryMarkerType='o',
summaryBarColor='grey',
meansSummaryLineStyle='solid',
contrastZeroLineStyle='solid',
contrastEffectSizeLineStyle='solid',
contrastZeroLineColor='black',
contrastEffectSizeLineColor='black',
pal=None,
legendLoc=2,
legendFontSize=12,
legendMarkerScale=1,
axis_title_size=None,
yticksize=None,
xticksize=None,
tickAngle=45,
tickAlignment='right',
**kwargs):
# Preliminaries.
data = data.dropna()
# plot params
if axis_title_size is None:
axis_title_size = 15
if yticksize is None:
yticksize = 12
if xticksize is None:
xticksize = 12
axisTitleParams = {'labelsize': axis_title_size}
xtickParams = {'labelsize': xticksize}
ytickParams = {'labelsize': yticksize}
rc('axes', **axisTitleParams)
rc('xtick', **xtickParams)
rc('ytick', **ytickParams)
## If `idx` is not specified, just take the FIRST TWO levels alphabetically.
if idx is None:
idx = tuple(np.unique(data[x])[0:2], )
else:
# check if multi-plot or not
if all(isinstance(element, str) for element in idx):
# if idx is supplied but not a multiplot (ie single list or tuple)
if len(idx) != 2:
print(idx, "does not have length 2.")
sys.exit(0)
else:
idx = (tuple(idx, ), )
elif all(isinstance(element, tuple) for element in idx):
# if idx is supplied, and it is a list/tuple of tuples or lists, we have a multiplot!
if (any(len(element) != 2 for element in idx)):
# If any of the tuples contain more than 2 elements.
print(element, "does not have length 2.")
sys.exit(0)
if floatViolinOffset is None:
floatViolinOffset = beforeAfterSpacer / 2
if contrastYlim is not None:
contrastYlim = np.array([contrastYlim[0], contrastYlim[1]])
if swarmYlim is not None:
swarmYlim = np.array([swarmYlim[0], swarmYlim[1]])
## Here we define the palette on all the levels of the 'x' column.
## Thus, if the same pandas dataframe is re-used across different plots,
## the color identity of each group will be maintained.
## Set palette based on total number of categories in data['x'] or data['hue_column']
if 'hue' in kwargs:
u = kwargs['hue']
else:
u = x
if ('color' not in kwargs and 'hue' not in kwargs):
kwargs['color'] = 'k'
if pal is None:
pal = dict(
zip(data[u].unique(),
sns.color_palette(n_colors=len(data[u].unique()))))
else:
pal = pal
# Initialise figure.
if figsize is None:
if len(idx) > 2:
figsize = (12, (12 / np.sqrt(2)))
else:
figsize = (6, 6)
fig = plt.figure(figsize=figsize)
# Initialise GridSpec based on `levs_tuple` shape.
gsMain = gridspec.GridSpec(
1,
np.shape(idx)[0]) # 1 row; columns based on number of tuples in tuple.
# Set default statfunction
if statfunction is None:
statfunction = np.mean
# Create list to collect all the contrast DataFrames generated.
contrastList = list()
contrastListNames = list()
for gsIdx, xlevs in enumerate(idx):
## Pivot tempdat to get before and after lines.
data_pivot = data.pivot_table(index=idcol, columns=x, values=y)
# Start plotting!!
if floatContrast is True:
ax_raw = fig.add_subplot(gsMain[gsIdx], frame_on=False)
ax_contrast = ax_raw.twinx()
else:
gsSubGridSpec = gridspec.GridSpecFromSubplotSpec(
2, 1, subplot_spec=gsMain[gsIdx])
ax_raw = plt.Subplot(fig, gsSubGridSpec[0, 0], frame_on=False)
ax_contrast = plt.Subplot(fig,
gsSubGridSpec[1, 0],
sharex=ax_raw,
frame_on=False)
## Plot raw data as swarmplot or stripplot.
if showRawData is True:
swarm_raw = sns.swarmplot(data=data,
x=x,
y=y,
order=xlevs,
ax=ax_raw,
palette=pal,
size=rawMarkerSize,
marker=rawMarkerType,
**kwargs)
else:
swarm_raw = sns.stripplot(data=data,
x=x,
y=y,
order=xlevs,
ax=ax_raw,
palette=pal,
**kwargs)
swarm_raw.set_ylim(swarmYlim)
## Get some details about the raw data.
maxXBefore = max(swarm_raw.collections[0].get_offsets().T[0])
minXAfter = min(swarm_raw.collections[1].get_offsets().T[0])
if showRawData is True:
#beforeAfterSpacer = (getSwarmSpan(swarm_raw, 0) + getSwarmSpan(swarm_raw, 1))/2
beforeAfterSpacer = 1
xposAfter = maxXBefore + beforeAfterSpacer
xAfterShift = minXAfter - xposAfter
## shift the after swarmpoints closer for aesthetic purposes.
offsetSwarmX(swarm_raw.collections[1], -xAfterShift)
## pandas DataFrame of 'before' group
x1 = pd.DataFrame({
str(xlevs[0] + '_x'):
pd.Series(swarm_raw.collections[0].get_offsets().T[0]),
xlevs[0]:
pd.Series(swarm_raw.collections[0].get_offsets().T[1]),
'_R_':
pd.Series(swarm_raw.collections[0].get_facecolors().T[0]),
'_G_':
pd.Series(swarm_raw.collections[0].get_facecolors().T[1]),
'_B_':
pd.Series(swarm_raw.collections[0].get_facecolors().T[2]),
})
## join the RGB columns into a tuple, then assign to a column.
x1['_hue_'] = x1[['_R_', '_G_', '_B_']].apply(tuple, axis=1)
x1 = x1.sort_values(by=xlevs[0])
x1.index = data_pivot.sort_values(by=xlevs[0]).index
## pandas DataFrame of 'after' group
### create convenient signifiers for column names.
befX = str(xlevs[0] + '_x')
aftX = str(xlevs[1] + '_x')
x2 = pd.DataFrame({
aftX:
pd.Series(swarm_raw.collections[1].get_offsets().T[0]),
xlevs[1]:
pd.Series(swarm_raw.collections[1].get_offsets().T[1])
})
x2 = x2.sort_values(by=xlevs[1])
x2.index = data_pivot.sort_values(by=xlevs[1]).index
## Join x1 and x2, on both their indexes.
plotPoints = x1.merge(x2,
left_index=True,
right_index=True,
how='outer')
## Add the hue column if hue argument was passed.
if 'hue' in kwargs:
h = kwargs['hue']
plotPoints[h] = data.pivot(index=idcol, columns=x,
values=h)[xlevs[0]]
swarm_raw.legend(loc=legendLoc,
fontsize=legendFontSize,
markerscale=legendMarkerScale)
## Plot the lines to join the 'before' points to their respective 'after' points.
if showConnections is True:
for i in plotPoints.index:
ax_raw.plot(
[plotPoints.ix[i, befX], plotPoints.ix[i, aftX]],
[plotPoints.ix[i, xlevs[0]], plotPoints.ix[i, xlevs[1]]],
linestyle='solid',
color=plotPoints.ix[i, '_hue_'],
linewidth=0.75,
alpha=0.75)
## Hide the raw swarmplot data if so desired.
if showRawData is False:
swarm_raw.collections[0].set_visible(False)
swarm_raw.collections[1].set_visible(False)
if showRawData is True:
#maxSwarmSpan = max(np.array([getSwarmSpan(swarm_raw, 0), getSwarmSpan(swarm_raw, 1)]))/2
maxSwarmSpan = 0.5
else:
maxSwarmSpan = barWidth
## Plot Summary Bar.
if summaryBar is True:
# Calculate means
means = data.groupby([x], sort=True).mean()[y]
# # Calculate medians
# medians = data.groupby([x], sort = True).median()[y]
## Draw summary bar.
bar_raw = sns.barplot(x=means.index,
y=means.values,
order=xlevs,
ax=ax_raw,
ci=0,
facecolor=summaryBarColor,
alpha=0.25)
## Draw zero reference line.
ax_raw.add_artist(
Line2D((ax_raw.xaxis.get_view_interval()[0],
ax_raw.xaxis.get_view_interval()[1]), (0, 0),
color='black',
linewidth=0.75))
## get swarm with largest span, set as max width of each barplot.
for i, bar in enumerate(bar_raw.patches):
x_width = bar.get_x()
width = bar.get_width()
centre = x_width + width / 2.
if i == 0:
bar.set_x(centre - maxSwarmSpan / 2.)
else:
bar.set_x(centre - xAfterShift - maxSwarmSpan / 2.)
bar.set_width(maxSwarmSpan)
# Get y-limits of the treatment swarm points.
beforeRaw = pd.DataFrame(swarm_raw.collections[0].get_offsets())
afterRaw = pd.DataFrame(swarm_raw.collections[1].get_offsets())
before_leftx = min(beforeRaw[0])
after_leftx = min(afterRaw[0])
after_rightx = max(afterRaw[0])
after_stat_summary = statfunction(beforeRaw[1])
# Calculate the summary difference and CI.
plotPoints['delta_y'] = plotPoints[xlevs[1]] - plotPoints[xlevs[0]]
plotPoints['delta_x'] = [0] * np.shape(plotPoints)[0]
tempseries = plotPoints['delta_y'].tolist()
test = tempseries.count(tempseries[0]) != len(tempseries)
bootsDelta = bootstrap(plotPoints['delta_y'],
statfunction=statfunction,
smoothboot=smoothboot,
reps=reps)
summDelta = bootsDelta['summary']
lowDelta = bootsDelta['bca_ci_low']
highDelta = bootsDelta['bca_ci_high']
# set new xpos for delta violin.
if floatContrast is True:
if showRawData is False:
xposPlusViolin = deltaSwarmX = after_rightx + floatViolinOffset
else:
xposPlusViolin = deltaSwarmX = after_rightx + maxSwarmSpan
else:
xposPlusViolin = xposAfter
if showRawData is True:
# If showRawData is True and floatContrast is True,
# set violinwidth to the barwidth.
violinWidth = maxSwarmSpan
xmaxPlot = xposPlusViolin + violinWidth
# Plot the summary measure.
ax_contrast.plot(xposPlusViolin,
summDelta,
marker='o',
markerfacecolor='k',
markersize=summaryMarkerSize,
alpha=0.75)
# Plot the CI.
ax_contrast.plot([xposPlusViolin, xposPlusViolin],
[lowDelta, highDelta],
color='k',
alpha=0.75,
linestyle='solid')
# Plot the violin-plot.
v = ax_contrast.violinplot(bootsDelta['stat_array'], [xposPlusViolin],
widths=violinWidth,
showextrema=False,
showmeans=False)
halfviolin(v, half='right', color='k')
# Remove left axes x-axis title.
ax_raw.set_xlabel("")
# Remove floating axes y-axis title.
ax_contrast.set_ylabel("")
# Set proper x-limits
ax_raw.set_xlim(before_leftx - beforeAfterSpacer / 2, xmaxPlot)
ax_raw.get_xaxis().set_view_interval(
before_leftx - beforeAfterSpacer / 2,
after_rightx + beforeAfterSpacer / 2)
ax_contrast.set_xlim(ax_raw.get_xlim())
if floatContrast is True:
# Set the ticks locations for ax_raw.
ax_raw.get_xaxis().set_ticks((0, xposAfter))
# Make sure they have the same y-limits.
ax_contrast.set_ylim(ax_raw.get_ylim())
# Drawing in the x-axis for ax_raw.
## Set the tick labels!
ax_raw.set_xticklabels(xlevs,
rotation=tickAngle,
horizontalalignment=tickAlignment)
## Get lowest y-value for ax_raw.
y = ax_raw.get_yaxis().get_view_interval()[0]
# Align the left axes and the floating axes.
align_yaxis(ax_raw, statfunction(plotPoints[xlevs[0]]),
ax_contrast, 0)
# Add label to floating axes. But on ax_raw!
ax_raw.text(x=deltaSwarmX,
y=ax_raw.get_yaxis().get_view_interval()[0],
horizontalalignment='left',
s='Difference',
fontsize=15)
# Set reference lines
## zero line
ax_contrast.hlines(
0, # y-coordinate
ax_contrast.xaxis.get_majorticklocs()
[0], # x-coordinates, start and end.
ax_raw.xaxis.get_view_interval()[1],
linestyle='solid',
linewidth=0.75,
color='black')
## effect size line
ax_contrast.hlines(summDelta,
ax_contrast.xaxis.get_majorticklocs()[1],
ax_raw.xaxis.get_view_interval()[1],
linestyle='solid',
linewidth=0.75,
color='black')
# Align the left axes and the floating axes.
align_yaxis(ax_raw, after_stat_summary, ax_contrast, 0.)
else:
# Set the ticks locations for ax_raw.
ax_raw.get_xaxis().set_ticks((0, xposAfter))
fig.add_subplot(ax_raw)
fig.add_subplot(ax_contrast)
ax_contrast.set_ylim(contrastYlim)
# Calculate p-values.
# 1-sample t-test to see if the mean of the difference is different from 0.
ttestresult = ttest_1samp(plotPoints['delta_y'], popmean=0)[1]
bootsDelta['ttest_pval'] = ttestresult
contrastList.append(bootsDelta)
contrastListNames.append(str(xlevs[1]) + ' v.s. ' + str(xlevs[0]))
# Turn contrastList into a pandas DataFrame,
contrastList = pd.DataFrame(contrastList).T
contrastList.columns = contrastListNames
# Now we iterate thru the contrast axes to normalize all the ylims.
for j, i in enumerate(range(1, len(fig.get_axes()), 2)):
axx = fig.get_axes()[i]
## Get max and min of the dataset.
lower = np.min(contrastList.ix['stat_array', j])
upper = np.max(contrastList.ix['stat_array', j])
meandiff = contrastList.ix['summary', j]
## Make sure we have zero in the limits.
if lower > 0:
lower = 0.
if upper < 0:
upper = 0.
## Get tick distance on raw axes.
## This will be the tick distance for the contrast axes.
rawAxesTicks = fig.get_axes()[i - 1].yaxis.get_majorticklocs()
rawAxesTickDist = rawAxesTicks[1] - rawAxesTicks[0]
## First re-draw of axis with new tick interval
axx.yaxis.set_major_locator(MultipleLocator(rawAxesTickDist))
newticks1 = fig.get_axes()[i].get_yticks()
if floatContrast is False:
if (showAllYAxes is False and i in range(2, len(fig.get_axes()))):
axx.get_yaxis().set_visible(showAllYAxes)
else:
## Obtain major ticks that comfortably encompass lower and upper.
newticks2 = list()
for a, b in enumerate(newticks1):
if (b >= lower and b <= upper):
# if the tick lies within upper and lower, take it.
newticks2.append(b)
# if the meandiff falls outside of the newticks2 set, add a tick in the right direction.
if np.max(newticks2) < meandiff:
ind = np.where(newticks1 == np.max(newticks2))[0][
0] # find out the max tick index in newticks1.
newticks2.append(newticks1[ind + 1])
elif meandiff < np.min(newticks2):
ind = np.where(newticks1 == np.min(newticks2))[0][
0] # find out the min tick index in newticks1.
newticks2.append(newticks1[ind - 1])
newticks2 = np.array(newticks2)
newticks2.sort()
axx.yaxis.set_major_locator(FixedLocator(locs=newticks2))
## Draw zero reference line.
axx.hlines(
y=0,
xmin=fig.get_axes()[i].get_xaxis().get_view_interval()[0],
xmax=fig.get_axes()[i].get_xaxis().get_view_interval()[1],
linestyle=contrastZeroLineStyle,
linewidth=0.75,
color=contrastZeroLineColor)
sns.despine(ax=fig.get_axes()[i],
trim=True,
bottom=False,
right=True,
left=False,
top=True)
## Draw back the lines for the relevant y-axes.
drawback_y(axx)
## Draw back the lines for the relevant x-axes.
drawback_x(axx)
elif floatContrast is True:
## Get the original ticks on the floating y-axis.
newticks1 = fig.get_axes()[i].get_yticks()
## Obtain major ticks that comfortably encompass lower and upper.
newticks2 = list()
for a, b in enumerate(newticks1):
if (b >= lower and b <= upper):
# if the tick lies within upper and lower, take it.
newticks2.append(b)
# if the meandiff falls outside of the newticks2 set, add a tick in the right direction.
if np.max(newticks2) < meandiff:
ind = np.where(newticks1 == np.max(newticks2))[0][
0] # find out the max tick index in newticks1.
newticks2.append(newticks1[ind + 1])
elif meandiff < np.min(newticks2):
ind = np.where(newticks1 == np.min(newticks2))[0][
0] # find out the min tick index in newticks1.
newticks2.append(newticks1[ind - 1])
newticks2 = np.array(newticks2)
newticks2.sort()
## Re-draw the axis.
axx.yaxis.set_major_locator(FixedLocator(locs=newticks2))
## Despine and trim the axes.
sns.despine(ax=axx,
trim=True,
bottom=False,
right=False,
left=True,
top=True)
for i in range(0, len(fig.get_axes()), 2):
# Loop through the raw data swarmplots and despine them appropriately.
if floatContrast is True:
sns.despine(ax=fig.get_axes()[i], trim=True, right=True)
else:
sns.despine(ax=fig.get_axes()[i],
trim=True,
bottom=True,
right=True)
fig.get_axes()[i].get_xaxis().set_visible(False)
# Draw back the lines for the relevant y-axes.
ymin = fig.get_axes()[i].get_yaxis().get_majorticklocs()[0]
ymax = fig.get_axes()[i].get_yaxis().get_majorticklocs()[-1]
x, _ = fig.get_axes()[i].get_xaxis().get_view_interval()
fig.get_axes()[i].add_artist(
Line2D((x, x), (ymin, ymax), color='black', linewidth=1.5))
# Zero gaps between plots on the same row, if floatContrast is False
if (floatContrast is False and showAllYAxes is False):
gsMain.update(wspace=0)
else:
# Tight Layout!
gsMain.tight_layout(fig)
# And we're done.
rcdefaults() # restore matplotlib defaults.
sns.set() # restore seaborn defaults.
return fig, contrastList
import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt
import seaborn.apionly as sns
data = np.loadtxt('msd.xvg')
x = np.zeros(np.shape(data))
x[:, 1] = data[:, 0]
x = x / 1000
regr = linear_model.LinearRegression()
regr.fit(x, data[:, 1])
y_hat = np.dot(x, np.array(regr.coef_).T)
fig = plt.figure(figsize=(8, 4))
ax = fig.add_subplot(1, 1, 1)
ax.plot(data[:, 0], data[:, 1], color='k', label='Data')
ax.plot(data[:, 0], y_hat, color='blue', label='Fitted line')
ax.legend(loc='best')
ax.set_xlabel(r"time $t$ (ps)")
ax.set_ylabel("msd (nm)")
sns.despine(offset=10, ax=ax)
plt.tight_layout()
fig.savefig('fit.png')
def main():
all_grps = df.loadExptGrps('GOL')
WT_expt_grp = all_grps['WT_hidden_behavior_set']
Df_expt_grp = all_grps['Df_hidden_behavior_set']
behavior_fn = ra.fraction_licks_in_reward_zone
behavior_kwargs = {}
activity_label = 'Fraction of licks in reward zone'
WT_colors = sns.light_palette(WT_color, 8)[::-1]
Df_colors = sns.light_palette(Df_color, 7)[::-1]
markers = ('o', 'v', '^', 'D', '*', 's')
fig, axs = plt.subplots(4, 2, figsize=(8.5, 11))
sns.despine(fig)
wt_ax = axs[0, 0]
df_ax = axs[0, 1]
for ax in list(axs.flat)[2:]:
ax.set_visible(False)
wt_expt_grps = [
WT_expt_grp.subGroup(list(expts['expt']), label=mouse)
for mouse, expts in WT_expt_grp.dataframe(
WT_expt_grp, include_columns=['mouseID']).groupby('mouseID')
]
df_expt_grps = [
Df_expt_grp.subGroup(list(expts['expt']), label=mouse)
for mouse, expts in Df_expt_grp.dataframe(
Df_expt_grp, include_columns=['mouseID']).groupby('mouseID')
]
plotting.plot_metric(wt_ax,
wt_expt_grps,
metric_fn=behavior_fn,
activity_kwargs=behavior_kwargs,
groupby=[['expt'], ['condition_day']],
plotby=['condition_day'],
plot_method='line',
ms=5,
activity_label=activity_label,
colors=WT_colors,
markers=markers,
label_every_n=1,
label_groupby=False,
rotate_labels=False)
wt_ax.set_xlabel('Day in Condition')
wt_ax.set_title(WT_expt_grp.label())
wt_ax.set_yticks([0, 0.1, 0.2, 0.3, 0.4, 0.5])
wt_ax.set_xticklabels(['1', '2', '3', '1', '2', '3', '1', '2', '3'])
label_conditions(wt_ax)
wt_ax.get_legend().set_visible(False)
wt_ax.tick_params(length=3, pad=2)
plotting.plot_metric(df_ax,
df_expt_grps,
metric_fn=behavior_fn,
activity_kwargs=behavior_kwargs,
groupby=[['expt'], ['condition_day']],
plotby=['condition_day'],
plot_method='line',
ms=5,
activity_label=activity_label,
colors=Df_colors,
markers=markers,
label_every_n=1,
label_groupby=False,
rotate_labels=False)
df_ax.set_xlabel('Day in Condition')
df_ax.set_title(Df_expt_grp.label())
df_ax.set_yticks([0, 0.1, 0.2, 0.3, 0.4, 0.5])
df_ax.set_xticklabels(['1', '2', '3', '1', '2', '3', '1', '2', '3'])
label_conditions(df_ax)
df_ax.get_legend().set_visible(False)
df_ax.tick_params(length=3, pad=2)
misc.save_figure(fig, filename, save_dir=save_dir)
def contrastplot(
data, x=None, y=None, idx=None, idcol=None,
alpha=0.75,
axis_title_size=None,
ci=95,
contrastShareY=True,
contrastEffectSizeLineStyle='solid',
contrastEffectSizeLineColor='black',
contrastYlim=None,
contrastZeroLineStyle='solid',
contrastZeroLineColor='black',
connectPairs=True,
effectSizeYLabel="Effect Size",
figsize=None,
floatContrast=True,
floatSwarmSpacer=0.2,
heightRatio=(1, 1),
lineWidth=2,
legend=True,
legendFontSize=14,
legendFontProps={},
paired=False,
pairedDeltaLineAlpha=0.3,
pairedDeltaLineWidth=1.2,
pal=None,
rawMarkerSize=8,
rawMarkerType='o',
reps=3000,
showGroupCount=True,
showCI=False,
showAllYAxes=False,
showRawData=True,
smoothboot=False,
statfunction=None,
summaryBar=False,
summaryBarColor='grey',
summaryBarAlpha=0.25,
summaryColour='black',
summaryLine=True,
summaryLineStyle='solid',
summaryLineWidth=0.25,
summaryMarkerSize=10,
summaryMarkerType='o',
swarmShareY=True,
swarmYlim=None,
tickAngle=45,
tickAlignment='right',
violinOffset=0.375,
violinWidth=0.2,
violinColor='k',
xticksize=None,
yticksize=None,
**kwargs):
'''Takes a pandas DataFrame and produces a contrast plot:
either a Cummings hub-and-spoke plot or a Gardner-Altman contrast plot.
Paired and unpaired options available.
Keyword arguments:
data: pandas DataFrame
x: string
column name containing categories to be plotted on the x-axis.
y: string
column name containing values to be plotted on the y-axis.
idx: tuple
flxible declaration of groupwise comparisons.
idcol: string
for paired plots.
alpha: float
alpha (transparency) of raw swarmed data points.
axis_title_size=None
ci=95
contrastShareY=True
contrastEffectSizeLineStyle='solid'
contrastEffectSizeLineColor='black'
contrastYlim=None
contrastZeroLineStyle='solid'
contrastZeroLineColor='black'
effectSizeYLabel="Effect Size"
figsize=None
floatContrast=True
floatSwarmSpacer=0.2
heightRatio=(1,1)
lineWidth=2
legend=True
legendFontSize=14
legendFontProps={}
paired=False
pairedDeltaLineAlpha=0.3
pairedDeltaLineWidth=1.2
pal=None
rawMarkerSize=8
rawMarkerType='o'
reps=3000
showGroupCount=True
showCI=False
showAllYAxes=False
showRawData=True
smoothboot=False
statfunction=None
summaryBar=False
summaryBarColor='grey'
summaryBarAlpha=0.25
summaryColour='black'
summaryLine=True
summaryLineStyle='solid'
summaryLineWidth=0.25
summaryMarkerSize=10
summaryMarkerType='o'
swarmShareY=True
swarmYlim=None
tickAngle=45
tickAlignment='right'
violinOffset=0.375
violinWidth=0.2
violinColor='k'
xticksize=None
yticksize=None
Returns:
An matplotlib Figure.
Organization of figure Axes.
'''
# Check that `data` is a pandas dataframe
if 'DataFrame' not in str(type(data)):
raise TypeError("The object passed to the command is not not a pandas DataFrame.\
Please convert it to a pandas DataFrame.")
# make sure that at least x, y, and idx are specified.
if x is None and y is None and idx is None:
raise ValueError('You need to specify `x` and `y`, or `idx`. Neither has been specifed.')
if x is None:
# if x is not specified, assume this is a 'wide' dataset, with each idx being the name of a column.
datatype='wide'
# Check that the idx are legit columns.
all_idx=np.unique([element for tupl in idx for element in tupl])
# # melt the data.
# data=pd.melt(data,value_vars=all_idx)
# x='variable'
# y='value'
else:
# if x is specified, assume this is a 'long' dataset with each row corresponding to one datapoint.
datatype='long'
# make sure y is not none.
if y is None:
raise ValueError("`paired` is false, but no y-column given.")
# Calculate Ns.
counts=data.groupby(x)[y].count()
# Get and set levels of data[x]
if paired is True:
violinWidth=0.1
# # Calculate Ns--which should be simply the number of rows in data.
# counts=len(data)
# is idcol supplied?
if idcol is None and datatype=='long':
raise ValueError('`idcol` has not been supplied but a paired plot is desired; please specify the `idcol`.')
if idx is not None:
# check if multi-plot or not
if all(isinstance(element, str) for element in idx):
# check that every idx is a column name.
idx_not_in_cols=[n
for n in idx
if n not in data[x].unique()]
if len(idx_not_in_cols)!=0:
raise ValueError(str(idx_not_in_cols)+" cannot be found in the columns of `data`.")
# data_wide_cols=[n for n in idx if n in data.columns]
# if idx is supplied but not a multiplot (ie single list or tuple)
if len(idx) != 2:
raise ValueError(idx+" does not have length 2.")
else:
tuple_in=(tuple(idx, ),)
widthratio=[1]
elif all(isinstance(element, tuple) for element in idx):
# if idx is supplied, and it is a list/tuple of tuples or lists, we have a multiplot!
idx_not_in_cols=[n
for tup in idx
for n in tup
if n not in data[x].unique()]
if len(idx_not_in_cols)!=0:
raise ValueError(str(idx_not_in_cols)+" cannot be found in the column "+x)
# data_wide_cols=[n for tup in idx for n in tup if n in data.columns]
if ( any(len(element) != 2 for element in idx) ):
# If any of the tuples does not contain exactly 2 elements.
raise ValueError(element+" does not have length 2.")
# Make sure the widthratio of the seperate multiplot corresponds to how
# many groups there are in each one.
tuple_in=idx
widthratio=[]
for i in tuple_in:
widthratio.append(len(i))
elif idx is None:
raise ValueError('Please specify idx.')
showRawData=False # Just show lines, do not show data.
showCI=False # wait till I figure out how to plot this for sns.barplot.
if datatype=='long':
if idx is None:
## If `idx` is not specified, just take the FIRST TWO levels alphabetically.
tuple_in=tuple(np.sort(np.unique(data[x]))[0:2],)
# pivot the dataframe if it is long!
data_pivot=data.pivot_table(index = idcol, columns = x, values = y)
elif paired is False:
if idx is None:
widthratio=[1]
tuple_in=( tuple(data[x].unique()) ,)
if len(tuple_in[0])>2:
floatContrast=False
else:
if all(isinstance(element, str) for element in idx):
# if idx is supplied but not a multiplot (ie single list or tuple)
# check all every idx specified can be found in data[x]
idx_not_in_x=[n for n in idx
if n not in data[x].unique()]
if len(idx_not_in_x)!=0:
raise ValueError(str(idx_not_in_x)+" cannot be found in the column "+x)
tuple_in=(idx, )
widthratio=[1]
if len(idx)>2:
floatContrast=False
elif all(isinstance(element, tuple) for element in idx):
# if idx is supplied, and it is a list/tuple of tuples or lists, we have a multiplot!
idx_not_in_x=[n
for tup in idx
for n in tup
if n not in data[x].unique()]
if len(idx_not_in_x)!=0:
raise ValueError(str(idx_not_in_x)+" cannot be found in the column "+x)
tuple_in=idx
if ( any(len(element)>2 for element in tuple_in) ):
# if any of the tuples in idx has more than 2 groups, we turn set floatContrast as False.
floatContrast=False
# Make sure the widthratio of the seperate multiplot corresponds to how
# many groups there are in each one.
widthratio=[]
for i in tuple_in:
widthratio.append(len(i))
else:
raise TypeError("The object passed to `idx` consists of a mixture of single strings and tuples. \
Please make sure that `idx` is either a tuple of column names, or a tuple of tuples, for plotting.")
# Ensure summaryLine and summaryBar are not displayed together.
if summaryLine is True and summaryBar is True:
summaryBar=True
summaryLine=False
# Turn off summary line if floatContrast is true
if floatContrast:
summaryLine=False
# initialise statfunction
if statfunction == None:
statfunction=np.mean
# Create list to collect all the contrast DataFrames generated.
contrastList=list()
contrastListNames=list()
# Setting color palette for plotting.
if pal is None:
if 'hue' in kwargs:
colorCol=kwargs['hue']
if colorCol not in data.columns:
raise ValueError(colorCol+' is not a column name.')
colGrps=data[colorCol].unique()#.tolist()
plotPal=dict( zip( colGrps, sns.color_palette(n_colors=len(colGrps)) ) )
else:
if datatype=='long':
colGrps=data[x].unique()#.tolist()
plotPal=dict( zip( colGrps, sns.color_palette(n_colors=len(colGrps)) ) )
if datatype=='wide':
plotPal=np.repeat('k',len(data))
else:
if datatype=='long':
plotPal=pal
if datatype=='wide':
plotPal=list(map(lambda x:pal[x], data[hue]))
if swarmYlim is None:
# get range of _selected groups_.
# u = list()
# for t in tuple_in:
# for i in np.unique(t):
# u.append(i)
# u = np.unique(u)
u=np.unique([element for tupl in tuple_in for element in tupl])
if datatype=='long':
tempdat=data[data[x].isin(u)]
swarm_ylim=np.array([np.min(tempdat[y]), np.max(tempdat[y])])
if datatype=='wide':
allMin=list()
allMax=list()
for col in u:
allMin.append(np.min(data[col]))
allMax.append(np.max(data[col]))
swarm_ylim=np.array( [np.min(allMin),np.max(allMax)] )
swarm_ylim=np.round(swarm_ylim)
else:
swarm_ylim=np.array([swarmYlim[0],swarmYlim[1]])
if summaryBar is True:
lims=swarm_ylim
# check that 0 lies within the desired limits.
# if not, extend (upper or lower) limit to zero.
if 0 not in range( int(round(lims[0])),int(round(lims[1])) ): # turn swarm_ylim to integer range.
# check if all negative:.
if lims[0]<0. and lims[1]<0.:
swarm_ylim=np.array([np.min(lims),0.])
# check if all positive.
elif lims[0]>0. and lims[1]>0.:
swarm_ylim=np.array([0.,np.max(lims)])
if contrastYlim is not None:
contrastYlim=np.array([contrastYlim[0],contrastYlim[1]])
# plot params
if axis_title_size is None:
axis_title_size=27
if yticksize is None:
yticksize=22
if xticksize is None:
xticksize=22
# Set clean style
sns.set(style='ticks')
axisTitleParams={'labelsize' : axis_title_size}
xtickParams={'labelsize' : xticksize}
ytickParams={'labelsize' : yticksize}
svgParams={'fonttype' : 'none'}
rc('axes', **axisTitleParams)
rc('xtick', **xtickParams)
rc('ytick', **ytickParams)
rc('svg', **svgParams)
if figsize is None:
if len(tuple_in)>2:
figsize=(12,(12/np.sqrt(2)))
else:
figsize=(8,(8/np.sqrt(2)))
# calculate CI.
if ci<0 or ci>100:
raise ValueError('ci should be between 0 and 100.')
alpha_level=(100.-ci)/100.
# Initialise figure, taking into account desired figsize.
fig=plt.figure(figsize=figsize)
# Initialise GridSpec based on `tuple_in` shape.
gsMain=gridspec.GridSpec(
1, np.shape(tuple_in)[0],
# 1 row; columns based on number of tuples in tuple.
width_ratios=widthratio,
wspace=0 )
for gsIdx, current_tuple in enumerate(tuple_in):
#### FOR EACH TUPLE IN IDX
if datatype=='long':
plotdat=data[data[x].isin(current_tuple)]
plotdat[x]=plotdat[x].astype("category")
plotdat[x].cat.set_categories(
current_tuple,
ordered=True,
inplace=True)
plotdat.sort_values(by=[x])
# # Drop all nans.
# plotdat.dropna(inplace=True)
summaries=plotdat.groupby(x)[y].apply(statfunction)
if datatype=='wide':
plotdat=data[list(current_tuple)]
summaries=statfunction(plotdat)
plotdat=pd.melt(plotdat) ##### NOW I HAVE MELTED THE WIDE DATA.
if floatContrast is True:
# Use fig.add_subplot instead of plt.Subplot.
ax_raw=fig.add_subplot(gsMain[gsIdx],
frame_on=False)
ax_contrast=ax_raw.twinx()
else:
# Create subGridSpec with 2 rows and 1 column.
subGridSpec=gridspec.GridSpecFromSubplotSpec(2, 1,
subplot_spec=gsMain[gsIdx],
wspace=0)
# Use plt.Subplot instead of fig.add_subplot
ax_raw=plt.Subplot(fig,
subGridSpec[0, 0],
frame_on=False)
ax_contrast=plt.Subplot(fig,
subGridSpec[1, 0],
sharex=ax_raw,
frame_on=False)
# Calculate the boostrapped contrast
bscontrast=list()
if paired is False:
tempplotdat=plotdat[[x,y]] # only select the columns used for x and y plotting.
for i in range (1, len(current_tuple)):
# Note that you start from one. No need to do auto-contrast!
# if datatype=='long':aas
tempbs=bootstrap_contrast(
data=tempplotdat.dropna(),
x=x,
y=y,
idx=[current_tuple[0], current_tuple[i]],
statfunction=statfunction,
smoothboot=smoothboot,
alpha_level=alpha_level,
reps=reps)
bscontrast.append(tempbs)
contrastList.append(tempbs)
contrastListNames.append(current_tuple[i]+' vs. '+current_tuple[0])
#### PLOT RAW DATA.
ax_raw.set_ylim(swarm_ylim)
# ax_raw.yaxis.set_major_locator(MaxNLocator(n_bins='auto'))
# ax_raw.yaxis.set_major_locator(LinearLocator())
if paired is False and showRawData is True:
# Seaborn swarmplot doc says to set custom ylims first.
sw=sns.swarmplot(
data=plotdat,
x=x, y=y,
order=current_tuple,
ax=ax_raw,
alpha=alpha,
palette=plotPal,
size=rawMarkerSize,
marker=rawMarkerType,
**kwargs)
if floatContrast:
# Get horizontal offset values.
maxXBefore=max(sw.collections[0].get_offsets().T[0])
minXAfter=min(sw.collections[1].get_offsets().T[0])
xposAfter=maxXBefore+floatSwarmSpacer
xAfterShift=minXAfter-xposAfter
# shift the (second) swarmplot
offsetSwarmX(sw.collections[1], -xAfterShift)
# shift the tick.
ax_raw.set_xticks([0.,1-xAfterShift])
elif paired is True:
if showRawData is True:
sw=sns.swarmplot(data=plotdat,
x=x, y=y,
order=current_tuple,
ax=ax_raw,
alpha=alpha,
palette=plotPal,
size=rawMarkerSize,
marker=rawMarkerType,
**kwargs)
if connectPairs is True:
# Produce paired plot with lines.
before=plotdat[plotdat[x]==current_tuple[0]][y].tolist()
after=plotdat[plotdat[x]==current_tuple[1]][y].tolist()
linedf=pd.DataFrame(
{'before':before,
'after':after}
)
# to get color, need to loop thru each line and plot individually.
for ii in range(0,len(linedf)):
ax_raw.plot( [0,0.25], [ linedf.loc[ii,'before'],
linedf.loc[ii,'after'] ],
linestyle='solid',
linewidth=pairedDeltaLineWidth,
color=plotPal[current_tuple[0]],
alpha=pairedDeltaLineAlpha,
)
ax_raw.set_xlim(-0.25,0.5)
ax_raw.set_xticks([0,0.25])
ax_raw.set_xticklabels([current_tuple[0],current_tuple[1]])
# if swarmYlim is None:
# # if swarmYlim was not specified, tweak the y-axis
# # to show all the data without losing ticks and range.
# ## Get all yticks.
# axxYTicks=ax_raw.yaxis.get_majorticklocs()
# ## Get ytick interval.
# YTickInterval=axxYTicks[1]-axxYTicks[0]
# ## Get current ylim
# currentYlim=ax_raw.get_ylim()
# ## Extend ylim by adding a fifth of the tick interval as spacing at both ends.
# ax_raw.set_ylim(
# currentYlim[0]-(YTickInterval/5),
# currentYlim[1]+(YTickInterval/5)
# )
# ax_raw.yaxis.set_major_locator(MaxNLocator(nbins='auto'))
# ax_raw.yaxis.set_major_locator(MaxNLocator(nbins='auto'))
# ax_raw.yaxis.set_major_locator(LinearLocator())
if summaryBar is True:
if paired is False:
bar_raw=sns.barplot(
x=summaries.index.tolist(),
y=summaries.values,
facecolor=summaryBarColor,
ax=ax_raw,
alpha=summaryBarAlpha)
if floatContrast is True:
maxSwarmSpan=2/10.
xlocs=list()
for i, bar in enumerate(bar_raw.patches):
x_width=bar.get_x()
width=bar.get_width()
centre=x_width + (width/2.)
if i == 0:
bar.set_x(centre-maxSwarmSpan/2.)
xlocs.append(centre)
else:
bar.set_x(centre-xAfterShift-maxSwarmSpan/2.)
xlocs.append(centre-xAfterShift)
bar.set_width(maxSwarmSpan)
ax_raw.set_xticks(xlocs) # make sure xticklocs match the barplot.
elif floatContrast is False:
maxSwarmSpan=4/10.
xpos=ax_raw.xaxis.get_majorticklocs()
for i, bar in enumerate(bar_raw.patches):
bar.set_x(xpos[i]-maxSwarmSpan/2.)
bar.set_width(maxSwarmSpan)
else:
# if paired is true
ax_raw.bar([0,0.25],
[ statfunction(plotdat[current_tuple[0]]),
statfunction(plotdat[current_tuple[1]]) ],
color=summaryBarColor,
alpha=0.5,
width=0.05)
## Draw zero reference line.
ax_raw.add_artist(Line2D(
(ax_raw.xaxis.get_view_interval()[0],
ax_raw.xaxis.get_view_interval()[1]),
(0,0),
color='k', linewidth=1.25)
)
if summaryLine is True:
if paired is True:
xdelta=0
else:
xdelta=summaryLineWidth
for i, m in enumerate(summaries):
ax_raw.plot(
(i-xdelta,
i+xdelta), # x-coordinates
(m, m),
color=summaryColour,
linestyle=summaryLineStyle)
if showCI is True:
sns.barplot(
data=plotdat,
x=x, y=y,
ax=ax_raw,
alpha=0, ci=95)
ax_raw.set_xlabel("")
if floatContrast is False:
fig.add_subplot(ax_raw)
#### PLOT CONTRAST DATA.
if len(current_tuple)==2:
if paired is False:
# Plot the CIs on the contrast axes.
plotbootstrap(sw.collections[1],
bslist=tempbs,
ax=ax_contrast,
violinWidth=violinWidth,
violinOffset=violinOffset,
markersize=summaryMarkerSize,
marker=summaryMarkerType,
offset=floatContrast,
color=violinColor,
linewidth=1)
else:
bootsDelta = bootstrap(
plotdat[current_tuple[1]]-plotdat[current_tuple[0]],
statfunction=statfunction,
smoothboot=smoothboot,
alpha_level=alpha_level,
reps=reps)
contrastList.append(bootsDelta)
contrastListNames.append(current_tuple[1]+' vs. '+current_tuple[0])
summDelta = bootsDelta['summary']
lowDelta = bootsDelta['bca_ci_low']
highDelta = bootsDelta['bca_ci_high']
if floatContrast:
xpos=0.375
else:
xpos=0.25
# Plot the summary measure.
ax_contrast.plot(xpos, bootsDelta['summary'],
marker=summaryMarkerType,
markerfacecolor='k',
markersize=summaryMarkerSize,
alpha=0.75
)
# Plot the CI.
ax_contrast.plot([xpos, xpos],
[lowDelta, highDelta],
color='k',
alpha=0.75,
# linewidth=1,
linestyle='solid'
)
# Plot the violin-plot.
v = ax_contrast.violinplot(bootsDelta['stat_array'], [xpos],
widths = violinWidth,
showextrema = False,
showmeans = False)
halfviolin(v, half = 'right', color = 'k')
if floatContrast:
# Set reference lines
if paired is False:
## First get leftmost limit of left reference group
xtemp, _=np.array(sw.collections[0].get_offsets()).T
leftxlim=xtemp.min()
## Then get leftmost limit of right test group
xtemp, _=np.array(sw.collections[1].get_offsets()).T
rightxlim=xtemp.min()
ref=tempbs['summary']
else:
leftxlim=0
rightxlim=0.25
ref=bootsDelta['summary']
ax_contrast.set_xlim(-0.25, 0.5) # does this work?
## zero line
ax_contrast.hlines(0, # y-coordinates
leftxlim, 3.5, # x-coordinates, start and end.
linestyle=contrastZeroLineStyle,
linewidth=1,
color=contrastZeroLineColor)
## effect size line
ax_contrast.hlines(ref,
rightxlim, 3.5, # x-coordinates, start and end.
linestyle=contrastEffectSizeLineStyle,
linewidth=1,
color=contrastEffectSizeLineColor)
if paired is False:
es=float(tempbs['summary'])
refSum=tempbs['statistic_ref']
else:
es=float(bootsDelta['summary'])
refSum=statfunction(plotdat[current_tuple[0]])
## If the effect size is positive, shift the right axis up.
if es>0:
rightmin=ax_raw.get_ylim()[0]-es
rightmax=ax_raw.get_ylim()[1]-es
## If the effect size is negative, shift the right axis down.
elif es<0:
rightmin=ax_raw.get_ylim()[0]+es
rightmax=ax_raw.get_ylim()[1]+es
ax_contrast.set_ylim(rightmin, rightmax)
if gsIdx>0:
ax_contrast.set_ylabel('')
align_yaxis(ax_raw, refSum, ax_contrast, 0.)
else:
# Set bottom axes ybounds
if contrastYlim is not None:
ax_contrast.set_ylim(contrastYlim)
if paired is False:
# Set xlims so everything is properly visible!
swarm_xbounds=ax_raw.get_xbound()
ax_contrast.set_xbound(swarm_xbounds[0] -(summaryLineWidth * 1.1),
swarm_xbounds[1] + (summaryLineWidth * 1.1))
else:
ax_contrast.set_xlim(-0.05,0.25+violinWidth)
else:
# Plot the CIs on the bottom axes.
plotbootstrap_hubspoke(
bslist=bscontrast,
ax=ax_contrast,
violinWidth=violinWidth,
violinOffset=violinOffset,
markersize=summaryMarkerSize,
marker=summaryMarkerType,
linewidth=lineWidth)
if floatContrast is False:
fig.add_subplot(ax_contrast)
if gsIdx>0:
ax_raw.set_ylabel('')
ax_contrast.set_ylabel('')
# Turn contrastList into a pandas DataFrame,
contrastList=pd.DataFrame(contrastList).T
contrastList.columns=contrastListNames
# Get number of axes in figure for aesthetic tweaks.
axesCount=len(fig.get_axes())
for i in range(0, axesCount, 2):
# Set new tick labels.
# The tick labels belong to the SWARM axes
# for both floating and non-floating plots.
# This is because `sharex` was invoked.
axx=fig.axes[i]
newticklabs=list()
for xticklab in axx.xaxis.get_ticklabels():
t=xticklab.get_text()
if paired:
N=str(counts)
else:
N=str(counts.ix[t])
if showGroupCount:
newticklabs.append(t+' n='+N)
else:
newticklabs.append(t)
axx.set_xticklabels(
newticklabs,
rotation=tickAngle,
horizontalalignment=tickAlignment)
## Loop thru SWARM axes for aesthetic touchups.
for i in range(0, axesCount, 2):
axx=fig.axes[i]
if floatContrast is False:
axx.xaxis.set_visible(False)
sns.despine(ax=axx, trim=True, bottom=False, left=False)
else:
sns.despine(ax=axx, trim=True, bottom=True, left=True)
if i==0:
drawback_y(axx)
if i!=axesCount-2 and 'hue' in kwargs:
# If this is not the final swarmplot, remove the hue legend.
axx.legend().set_visible(False)
if showAllYAxes is False:
if i in range(2, axesCount):
axx.yaxis.set_visible(False)
else:
# Draw back the lines for the relevant y-axes.
# Not entirely sure why I have to do this.
drawback_y(axx)
else:
drawback_y(axx)
# Add zero reference line for swarmplots with bars.
if summaryBar is True:
axx.add_artist(Line2D(
(axx.xaxis.get_view_interval()[0],
axx.xaxis.get_view_interval()[1]),
(0,0),
color='black', linewidth=0.75
)
)
if legend is False:
axx.legend().set_visible(False)
else:
if i==axesCount-2: # the last (rightmost) swarm axes.
axx.legend(loc='top right',
bbox_to_anchor=(1.1,1.0),
fontsize=legendFontSize,
**legendFontProps)
## Loop thru the CONTRAST axes and perform aesthetic touch-ups.
## Get the y-limits:
for j,i in enumerate(range(1, axesCount, 2)):
axx=fig.get_axes()[i]
if floatContrast is False:
xleft, xright=axx.xaxis.get_view_interval()
# Draw zero reference line.
axx.hlines(y=0,
xmin=xleft-1,
xmax=xright+1,
linestyle=contrastZeroLineStyle,
linewidth=0.75,
color=contrastZeroLineColor)
# reset view interval.
axx.set_xlim(xleft, xright)
if showAllYAxes is False:
if i in range(2, axesCount):
axx.yaxis.set_visible(False)
else:
# Draw back the lines for the relevant y-axes, only is axesCount is 2.
# Not entirely sure why I have to do this.
if axesCount==2:
drawback_y(axx)
sns.despine(ax=axx,
top=True, right=True,
left=False, bottom=False,
trim=True)
if j==0 and axesCount==2:
# Draw back x-axis lines connecting ticks.
drawback_x(axx)
# Rotate tick labels.
rotateTicks(axx,tickAngle,tickAlignment)
elif floatContrast is True:
if paired is True:
# Get the bootstrapped contrast range.
lower=np.min(contrastList.ix['stat_array',j])
upper=np.max(contrastList.ix['stat_array',j])
else:
lower=np.min(contrastList.ix['diffarray',j])
upper=np.max(contrastList.ix['diffarray',j])
meandiff=contrastList.ix['summary', j]
## Make sure we have zero in the limits.
if lower>0:
lower=0.
if upper<0:
upper=0.
## Get the tick interval from the left y-axis.
leftticks=fig.get_axes()[i-1].get_yticks()
tickstep=leftticks[1] -leftticks[0]
## First re-draw of axis with new tick interval
axx.yaxis.set_major_locator(MultipleLocator(base=tickstep))
newticks1=axx.get_yticks()
## Obtain major ticks that comfortably encompass lower and upper.
newticks2=list()
for a,b in enumerate(newticks1):
if (b >= lower and b <= upper):
# if the tick lies within upper and lower, take it.
newticks2.append(b)
# if the meandiff falls outside of the newticks2 set, add a tick in the right direction.
if np.max(newticks2)<meandiff:
ind=np.where(newticks1 == np.max(newticks2))[0][0] # find out the max tick index in newticks1.
newticks2.append( newticks1[ind+1] )
elif meandiff<np.min(newticks2):
ind=np.where(newticks1 == np.min(newticks2))[0][0] # find out the min tick index in newticks1.
newticks2.append( newticks1[ind-1] )
newticks2=np.array(newticks2)
newticks2.sort()
## Second re-draw of axis to shrink it to desired limits.
axx.yaxis.set_major_locator(FixedLocator(locs=newticks2))
## Despine the axes.
sns.despine(ax=axx, trim=True,
bottom=False, right=False,
left=True, top=True)
# Normalize bottom/right Contrast axes to each other for Cummings hub-and-spoke plots.
if (axesCount>2 and
contrastShareY is True and
floatContrast is False):
# Set contrast ylim as max ticks of leftmost swarm axes.
if contrastYlim is None:
lower=list()
upper=list()
for c in range(0,len(contrastList.columns)):
lower.append( np.min(contrastList.ix['bca_ci_low',c]) )
upper.append( np.max(contrastList.ix['bca_ci_high',c]) )
lower=np.min(lower)
upper=np.max(upper)
else:
lower=contrastYlim[0]
upper=contrastYlim[1]
normalizeContrastY(fig,
contrast_ylim = contrastYlim,
show_all_yaxes = showAllYAxes)
# Zero gaps between plots on the same row, if floatContrast is False
if (floatContrast is False and showAllYAxes is False):
gsMain.update(wspace=0.)
else:
# Tight Layout!
gsMain.tight_layout(fig)
# And we're all done.
rcdefaults() # restore matplotlib defaults.
sns.set() # restore seaborn defaults.
return fig, contrastList
def plot_learning_rate(
output_dir=expanduser('~/output/recommender/learning_rate')):
with open(join(output_dir, 'results_netflix.json'), 'r') as f:
data_netflix = json.load(f)
with open(join(output_dir, 'results_10m.json'), 'r') as f:
data_10m = json.load(f)
min_time = 400
for i, learning_rate in enumerate(
sorted(data_netflix.keys(), key=lambda t: float(t))):
this_data = data_netflix[learning_rate]
min_time = min(this_data['time'][0], min_time)
for i, learning_rate in enumerate(
sorted(data_netflix.keys(), key=lambda t: float(t))):
this_data = data_netflix[learning_rate]
for j in range(len(this_data)):
this_data['time'][j] -= this_data['time'][0] - min_time
fig = plt.figure()
# fig.subplots_adjust(right=0.7)
fig.subplots_adjust(bottom=0.33)
fig.subplots_adjust(top=0.99)
fig.subplots_adjust(right=0.98)
fig.set_figwidth(3.25653379549)
fig.set_figheight(1.25)
ax = {}
gs = gridspec.GridSpec(1, 2)
palette = sns.cubehelix_palette(10,
start=0,
rot=3,
hue=1,
dark=.3,
light=.7,
reverse=False)
for j, data in enumerate([data_10m, data_netflix]):
ax[j] = fig.add_subplot(gs[j])
# palette = sns.hls_palette(10, l=.4, s=.7)
for i, learning_rate in enumerate(
sorted(data.keys(), key=lambda t: float(t))):
if float(learning_rate) > .6:
this_data = data[learning_rate]
ax[j].plot(np.linspace(0., 20, len(this_data['rmse'])),
this_data['rmse'],
label='%.2f' % float(learning_rate),
color=palette[i],
zorder=int(100 * float(learning_rate)))
ax[j].set_xscale('log')
sns.despine(fig, ax)
ax[j].spines['left'].set_color((.6, .6, .6))
ax[j].spines['bottom'].set_color((.6, .6, .6))
ax[j].xaxis.set_tick_params(color=(.6, .6, .6), which='both')
ax[j].yaxis.set_tick_params(color=(.6, .6, .6), which='both')
ax[j].tick_params(axis='y', labelsize=6)
ax[0].set_ylabel('RMSE on test set')
ax[0].set_xlabel('Epoch', ha='left', va='top')
ax[0].xaxis.set_label_coords(-.18, -0.055)
ax[0].set_xlim([.1, 20])
ax[0].set_xticks([1, 10, 20])
ax[0].set_xticklabels(['1', '10', '20'])
ax[1].set_xlim([.1, 20])
ax[1].set_xticks([.1, 1, 10, 20])
ax[1].set_xticklabels(['.1', '1', '10', '20'])
ax[0].annotate('MovieLens 10M',
xy=(.95, .8),
ha='right',
xycoords='axes fraction')
ax[1].annotate('Netflix',
xy=(.95, .8),
ha='right',
xycoords='axes fraction')
ax[0].set_ylim([0.795, 0.863])
ax[1].set_ylim([0.93, 0.983])
ax[0].legend(ncol=4,
loc='upper left',
bbox_to_anchor=(0., -.13),
fontsize=6,
numpoints=1,
columnspacing=.3,
frameon=False)
ax[0].annotate('Learning rate $\\beta$',
xy=(1.6, -.38),
xycoords='axes fraction')
ltext = ax[0].get_legend().get_texts()
plt.setp(ltext, fontsize=7)
plt.savefig(expanduser('~/output/icml/learning_rate.pdf'))
def plot_learning_rate(output_dir=expanduser('~/output/recommender/learning_rate')):
with open(join(output_dir, 'results_netflix.json'), 'r') as f:
data_netflix = json.load(f)
with open(join(output_dir, 'results_10m.json'), 'r') as f:
data_10m = json.load(f)
min_time = 400
for i, learning_rate in enumerate(sorted(data_netflix.keys(), key=lambda t : float(t))):
this_data = data_netflix[learning_rate]
min_time = min(this_data['time'][0], min_time)
for i, learning_rate in enumerate(sorted(data_netflix.keys(), key=lambda t : float(t))):
this_data = data_netflix[learning_rate]
for j in range(len(this_data)):
this_data['time'][j] -= this_data['time'][0] - min_time
fig = plt.figure()
# fig.subplots_adjust(right=0.7)
fig.subplots_adjust(bottom=0.33)
fig.subplots_adjust(top=0.99)
fig.subplots_adjust(right=0.98)
fig.set_figwidth(3.25653379549)
fig.set_figheight(1.25)
ax = {}
gs = gridspec.GridSpec(1, 2)
palette = sns.cubehelix_palette(10, start=0, rot=3, hue=1, dark=.3,
light=.7,
reverse=False)
for j, data in enumerate([data_10m, data_netflix]):
ax[j] = fig.add_subplot(gs[j])
# palette = sns.hls_palette(10, l=.4, s=.7)
for i, learning_rate in enumerate(sorted(data.keys(), key=lambda t : float(t))):
if float(learning_rate) > .6:
this_data = data[learning_rate]
ax[j].plot(np.linspace(0., 20, len(this_data['rmse'])),
this_data['rmse'],
label='%.2f' % float(learning_rate),
color=palette[i],
zorder=int(100 * float(learning_rate)))
ax[j].set_xscale('log')
sns.despine(fig, ax)
ax[j].spines['left'].set_color((.6, .6, .6))
ax[j].spines['bottom'].set_color((.6, .6, .6))
ax[j].xaxis.set_tick_params(color=(.6, .6, .6), which='both')
ax[j].yaxis.set_tick_params(color=(.6, .6, .6), which='both')
ax[j].tick_params(axis='y', labelsize=6)
ax[0].set_ylabel('RMSE on test set')
ax[0].set_xlabel('Epoch', ha='left', va='top')
ax[0].xaxis.set_label_coords(-.18, -0.055)
ax[0].set_xlim([.1, 20])
ax[0].set_xticks([1, 10, 20])
ax[0].set_xticklabels(['1', '10', '20'])
ax[1].set_xlim([.1, 20])
ax[1].set_xticks([.1, 1, 10, 20])
ax[1].set_xticklabels(['.1', '1', '10', '20'])
ax[0].annotate('MovieLens 10M', xy=(.95, .8), ha='right', xycoords='axes fraction')
ax[1].annotate('Netflix', xy=(.95, .8), ha='right', xycoords='axes fraction')
ax[0].set_ylim([0.795, 0.863])
ax[1].set_ylim([0.93, 0.983])
ax[0].legend(ncol=4, loc='upper left', bbox_to_anchor=(0., -.13), fontsize=6, numpoints=1, columnspacing=.3, frameon=False)
ax[0].annotate('Learning rate $\\beta$', xy=(1.6, -.38), xycoords='axes fraction')
ltext = ax[0].get_legend().get_texts()
plt.setp(ltext, fontsize=7)
plt.savefig(expanduser('~/output/icml/learning_rate.pdf'))
def contrastplot_test(
data, x, y, idx=None,
alpha=0.75,
axis_title_size=None,
barWidth=5,
contrastShareY=True,
contrastEffectSizeLineStyle='solid',
contrastEffectSizeLineColor='black',
contrastYlim=None,
contrastZeroLineStyle='solid',
contrastZeroLineColor='black',
effectSizeYLabel="Effect Size",
figsize=None,
floatContrast=True,
floatSwarmSpacer=0.2,
heightRatio=(1, 1),
idcol=None,
lineWidth=2,
legend=True,
legendFontSize=14,
legendFontProps={},
paired=False,
pal=None,
rawMarkerSize=8,
rawMarkerType='o',
reps=3000,
showGroupCount=True,
show95CI=False,
showAllYAxes=False,
showRawData=True,
smoothboot=False,
statfunction=None,
summaryBar=False,
summaryBarColor='grey',
summaryBarAlpha=0.25,
summaryColour='black',
summaryLine=True,
summaryLineStyle='solid',
summaryLineWidth=0.25,
summaryMarkerSize=10,
summaryMarkerType='o',
swarmShareY=True,
swarmYlim=None,
tickAngle=45,
tickAlignment='right',
violinOffset=0.375,
violinWidth=0.2,
violinColor='k',
xticksize=None,
yticksize=None,
**kwargs):
'''Takes a pandas dataframe and produces a contrast plot:
either a Cummings hub-and-spoke plot or a Gardner-Altman contrast plot.
-----------------------------------------------------------------------
Description of flags upcoming.'''
# Check that `data` is a pandas dataframe
if 'DataFrame' not in str(type(data)):
raise TypeError("The object passed to the command is not not a pandas DataFrame.\
Please convert it to a pandas DataFrame.")
# Get and set levels of data[x]
if idx is None:
widthratio=[1]
allgrps=np.sort(data[x].unique())
if paired:
# If `idx` is not specified, just take the FIRST TWO levels alphabetically.
tuple_in=tuple(allgrps[0:2],)
else:
# No idx is given, so all groups are compared to the first one in the DataFrame column.
tuple_in=(tuple(allgrps), )
if len(allgrps)>2:
floatContrast=False
else:
if all(isinstance(element, str) for element in idx):
# if idx is supplied but not a multiplot (ie single list or tuple)
tuple_in=(idx, )
widthratio=[1]
if len(idx)>2:
floatContrast=False
elif all(isinstance(element, tuple) for element in idx):
# if idx is supplied, and it is a list/tuple of tuples or lists, we have a multiplot!
tuple_in=idx
if ( any(len(element)>2 for element in tuple_in) ):
# if any of the tuples in idx has more than 2 groups, we turn set floatContrast as False.
floatContrast=False
# Make sure the widthratio of the seperate multiplot corresponds to how
# many groups there are in each one.
widthratio=[]
for i in tuple_in:
widthratio.append(len(i))
else:
raise TypeError("The object passed to `idx` consists of a mixture of single strings and tuples. \
Please make sure that `idx` is either a tuple of column names, or a tuple of tuples for plotting.")
# initialise statfunction
if statfunction == None:
statfunction=np.mean
# Create list to collect all the contrast DataFrames generated.
contrastList=list()
contrastListNames=list()
# # Calculate the bootstraps according to idx.
# for ix, current_tuple in enumerate(tuple_in):
# bscontrast=list()
# for i in range (1, len(current_tuple)):
# # Note that you start from one. No need to do auto-contrast!
# tempbs=bootstrap_contrast(
# data=data,
# x=x,
# y=y,
# idx=[current_tuple[0], current_tuple[i]],
# statfunction=statfunction,
# smoothboot=smoothboot,
# reps=reps)
# bscontrast.append(tempbs)
# contrastList.append(tempbs)
# contrastListNames.append(current_tuple[i]+' vs. '+current_tuple[0])
# Setting color palette for plotting.
if pal is None:
if 'hue' in kwargs:
colorCol=kwargs['hue']
colGrps=data[colorCol].unique()
nColors=len(colGrps)
else:
colorCol=x
colGrps=data[x].unique()
nColors=len([element for tupl in tuple_in for element in tupl])
plotPal=dict( zip( colGrps, sns.color_palette(n_colors=nColors) ) )
else:
plotPal=pal
# Ensure summaryLine and summaryBar are not displayed together.
if summaryLine is True and summaryBar is True:
summaryBar=True
summaryLine=False
# Turn off summary line if floatContrast is true
if floatContrast:
summaryLine=False
if swarmYlim is None:
# get range of _selected groups_.
u = list()
for t in idx:
for i in np.unique(t):
u.append(i)
u = np.unique(u)
tempdat=data[data[x].isin(u)]
swarm_ylim=np.array([np.min(tempdat[y]), np.max(tempdat[y])])
else:
swarm_ylim=np.array([swarmYlim[0],swarmYlim[1]])
if contrastYlim is not None:
contrastYlim=np.array([contrastYlim[0],contrastYlim[1]])
barWidth=barWidth/1000 # Not sure why have to reduce the barwidth by this much!
if showRawData is True:
maxSwarmSpan=0.25
else:
maxSwarmSpan=barWidth
# Expand the ylim in both directions.
## Find half of the range of swarm_ylim.
swarmrange=swarm_ylim[1] -swarm_ylim[0]
pad=0.1*swarmrange
x2=np.array([swarm_ylim[0]-pad, swarm_ylim[1]+pad])
swarm_ylim=x2
# plot params
if axis_title_size is None:
axis_title_size=25
if yticksize is None:
yticksize=18
if xticksize is None:
xticksize=18
# Set clean style
sns.set(style='ticks')
axisTitleParams={'labelsize' : axis_title_size}
xtickParams={'labelsize' : xticksize}
ytickParams={'labelsize' : yticksize}
svgParams={'fonttype' : 'none'}
rc('axes', **axisTitleParams)
rc('xtick', **xtickParams)
rc('ytick', **ytickParams)
rc('svg', **svgParams)
if figsize is None:
if len(tuple_in)>2:
figsize=(12,(12/np.sqrt(2)))
else:
figsize=(8,(8/np.sqrt(2)))
# Initialise figure, taking into account desired figsize.
fig=plt.figure(figsize=figsize)
# Initialise GridSpec based on `tuple_in` shape.
gsMain=gridspec.GridSpec(
1, np.shape(tuple_in)[0],
# 1 row; columns based on number of tuples in tuple.
width_ratios=widthratio,
wspace=0 )
for gsIdx, current_tuple in enumerate(tuple_in):
#### FOR EACH TUPLE IN IDX
plotdat=data[data[x].isin(current_tuple)]
plotdat[x]=plotdat[x].astype("category")
plotdat[x].cat.set_categories(
current_tuple,
ordered=True,
inplace=True)
plotdat.sort_values(by=[x])
# Drop all nans.
plotdat=plotdat.dropna()
# Calculate summaries.
summaries=plotdat.groupby([x],sort=True)[y].apply(statfunction)
if floatContrast is True:
# Use fig.add_subplot instead of plt.Subplot
ax_raw=fig.add_subplot(gsMain[gsIdx],
frame_on=False)
ax_contrast=ax_raw.twinx()
else:
# Create subGridSpec with 2 rows and 1 column.
subGridSpec=gridspec.GridSpecFromSubplotSpec(2, 1,
subplot_spec=gsMain[gsIdx],
wspace=0)
# Use plt.Subplot instead of fig.add_subplot
ax_raw=plt.Subplot(fig,
subGridSpec[0, 0],
frame_on=False)
ax_contrast=plt.Subplot(fig,
subGridSpec[1, 0],
sharex=ax_raw,
frame_on=False)
# Calculate the boostrapped contrast
bscontrast=list()
for i in range (1, len(current_tuple)):
# Note that you start from one. No need to do auto-contrast!
tempbs=bootstrap_contrast(
data=data,
x=x,
y=y,
idx=[current_tuple[0], current_tuple[i]],
statfunction=statfunction,
smoothboot=smoothboot,
reps=reps)
bscontrast.append(tempbs)
contrastList.append(tempbs)
contrastListNames.append(current_tuple[i]+' vs. '+current_tuple[0])
#### PLOT RAW DATA.
if showRawData is True:
# Seaborn swarmplot doc says to set custom ylims first.
ax_raw.set_ylim(swarm_ylim)
sw=sns.swarmplot(
data=plotdat,
x=x, y=y,
order=current_tuple,
ax=ax_raw,
alpha=alpha,
palette=plotPal,
size=rawMarkerSize,
marker=rawMarkerType,
**kwargs)
if summaryBar is True:
bar_raw=sns.barplot(
x=summaries.index.tolist(),
y=summaries.values,
facecolor=summaryBarColor,
ax=ax_raw,
alpha=summaryBarAlpha)
if floatContrast:
# Get horizontal offset values.
maxXBefore=max(sw.collections[0].get_offsets().T[0])
minXAfter=min(sw.collections[1].get_offsets().T[0])
xposAfter=maxXBefore+floatSwarmSpacer
xAfterShift=minXAfter-xposAfter
# shift the swarmplots
offsetSwarmX(sw.collections[1], -xAfterShift)
## get swarm with largest span, set as max width of each barplot.
for i, bar in enumerate(bar_raw.patches):
x_width=bar.get_x()
width=bar.get_width()
centre=x_width + (width/2.)
if i == 0:
bar.set_x(centre-maxSwarmSpan/2.)
else:
bar.set_x(centre-xAfterShift-maxSwarmSpan/2.)
bar.set_width(maxSwarmSpan)
## Set the ticks locations for ax_raw.
ax_raw.xaxis.set_ticks((0, xposAfter))
firstTick=ax_raw.xaxis.get_ticklabels()[0].get_text()
secondTick=ax_raw.xaxis.get_ticklabels()[1].get_text()
ax_raw.set_xticklabels([firstTick,#+' n='+count[firstTick],
secondTick],#+' n='+count[secondTick]],
rotation=tickAngle,
horizontalalignment=tickAlignment)
if summaryLine is True:
for i, m in enumerate(summaries):
ax_raw.plot(
(i -summaryLineWidth,
i + summaryLineWidth), # x-coordinates
(m, m),
color=summaryColour,
linestyle=summaryLineStyle)
if show95CI is True:
sns.barplot(
data=plotdat,
x=x, y=y,
ax=ax_raw,
alpha=0, ci=95)
ax_raw.set_xlabel("")
if floatContrast is False:
fig.add_subplot(ax_raw)
#### PLOT CONTRAST DATA.
if len(current_tuple)==2:
# Plot the CIs on the contrast axes.
plotbootstrap(sw.collections[1],
bslist=tempbs,
ax=ax_contrast,
violinWidth=violinWidth,
violinOffset=violinOffset,
markersize=summaryMarkerSize,
marker=summaryMarkerType,
offset=floatContrast,
color=violinColor,
linewidth=1)
if floatContrast:
# Set reference lines
## First get leftmost limit of left reference group
xtemp, _=np.array(sw.collections[0].get_offsets()).T
leftxlim=xtemp.min()
## Then get leftmost limit of right test group
xtemp, _=np.array(sw.collections[1].get_offsets()).T
rightxlim=xtemp.min()
## zero line
ax_contrast.hlines(0, # y-coordinates
leftxlim, 3.5, # x-coordinates, start and end.
linestyle=contrastZeroLineStyle,
linewidth=0.75,
color=contrastZeroLineColor)
## effect size line
ax_contrast.hlines(tempbs['summary'],
rightxlim, 3.5, # x-coordinates, start and end.
linestyle=contrastEffectSizeLineStyle,
linewidth=0.75,
color=contrastEffectSizeLineColor)
## If the effect size is positive, shift the right axis up.
if float(tempbs['summary'])>0:
rightmin=ax_raw.get_ylim()[0] -float(tempbs['summary'])
rightmax=ax_raw.get_ylim()[1] -float(tempbs['summary'])
## If the effect size is negative, shift the right axis down.
elif float(tempbs['summary'])<0:
rightmin=ax_raw.get_ylim()[0] + float(tempbs['summary'])
rightmax=ax_raw.get_ylim()[1] + float(tempbs['summary'])
ax_contrast.set_ylim(rightmin, rightmax)
if gsIdx>0:
ax_contrast.set_ylabel('')
align_yaxis(ax_raw, tempbs['statistic_ref'], ax_contrast, 0.)
else:
# Set bottom axes ybounds
if contrastYlim is not None:
ax_contrast.set_ylim(contrastYlim)
# Set xlims so everything is properly visible!
swarm_xbounds=ax_raw.get_xbound()
ax_contrast.set_xbound(swarm_xbounds[0] -(summaryLineWidth * 1.1),
swarm_xbounds[1] + (summaryLineWidth * 1.1))
else:
# Plot the CIs on the bottom axes.
plotbootstrap_hubspoke(
bslist=bscontrast,
ax=ax_contrast,
violinWidth=violinWidth,
violinOffset=violinOffset,
markersize=summaryMarkerSize,
marker=summaryMarkerType,
linewidth=lineWidth)
if floatContrast is False:
fig.add_subplot(ax_contrast)
if gsIdx>0:
ax_raw.set_ylabel('')
ax_contrast.set_ylabel('')
# Turn contrastList into a pandas DataFrame,
contrastList=pd.DataFrame(contrastList).T
contrastList.columns=contrastListNames
########
axesCount=len(fig.get_axes())
## Loop thru SWARM axes for aesthetic touchups.
for i in range(0, axesCount, 2):
axx=fig.axes[i]
if i!=axesCount-2 and 'hue' in kwargs:
# If this is not the final swarmplot, remove the hue legend.
axx.legend().set_visible(False)
if floatContrast is False:
axx.xaxis.set_visible(False)
sns.despine(ax=axx, trim=True, bottom=False, left=False)
else:
sns.despine(ax=axx, trim=True, bottom=True, left=True)
if showAllYAxes is False:
if i in range(2, axesCount):
axx.yaxis.set_visible(showAllYAxes)
else:
# Draw back the lines for the relevant y-axes.
# Not entirely sure why I have to do this.
drawback_y(axx)
# Add zero reference line for swarmplots with bars.
if summaryBar is True:
axx.add_artist(Line2D(
(axx.xaxis.get_view_interval()[0],
axx.xaxis.get_view_interval()[1]),
(0,0),
color='black', linewidth=0.75
)
)
# I don't know why the swarm axes controls the contrast axes ticks....
if showGroupCount:
count=data.groupby(x).count()[y]
newticks=list()
for ix, t in enumerate(axx.xaxis.get_ticklabels()):
t_text=t.get_text()
nt=t_text+' n='+str(count[t_text])
newticks.append(nt)
axx.xaxis.set_ticklabels(newticks)
if legend is False:
axx.legend().set_visible(False)
else:
if i==axesCount-2: # the last (rightmost) swarm axes.
axx.legend(loc='top right',
bbox_to_anchor=(1.1,1.0),
fontsize=legendFontSize,
**legendFontProps)
## Loop thru the CONTRAST axes and perform aesthetic touch-ups.
## Get the y-limits:
for j,i in enumerate(range(1, axesCount, 2)):
axx=fig.get_axes()[i]
if floatContrast is False:
xleft, xright=axx.xaxis.get_view_interval()
# Draw zero reference line.
axx.hlines(y=0,
xmin=xleft-1,
xmax=xright+1,
linestyle=contrastZeroLineStyle,
linewidth=0.75,
color=contrastZeroLineColor)
# reset view interval.
axx.set_xlim(xleft, xright)
# # Draw back x-axis lines connecting ticks.
# drawback_x(axx)
if showAllYAxes is False:
if i in range(2, axesCount):
axx.yaxis.set_visible(False)
else:
# Draw back the lines for the relevant y-axes.
# Not entirely sure why I have to do this.
drawback_y(axx)
sns.despine(ax=axx,
top=True, right=True,
left=False, bottom=False,
trim=True)
# Rotate tick labels.
rotateTicks(axx,tickAngle,tickAlignment)
else:
# Re-draw the floating axis to the correct limits.
lower=np.min(contrastList.ix['diffarray',j])
upper=np.max(contrastList.ix['diffarray',j])
meandiff=contrastList.ix['summary', j]
## Make sure we have zero in the limits.
if lower>0:
lower=0.
if upper<0:
upper=0.
## Get the tick interval from the left y-axis.
leftticks=fig.get_axes()[i-1].get_yticks()
tickstep=leftticks[1] -leftticks[0]
## First re-draw of axis with new tick interval
axx.yaxis.set_major_locator(MultipleLocator(base=tickstep))
newticks1=axx.get_yticks()
## Obtain major ticks that comfortably encompass lower and upper.
newticks2=list()
for a,b in enumerate(newticks1):
if (b >= lower and b <= upper):
# if the tick lies within upper and lower, take it.
newticks2.append(b)
# if the meandiff falls outside of the newticks2 set, add a tick in the right direction.
if np.max(newticks2)<meandiff:
ind=np.where(newticks1 == np.max(newticks2))[0][0] # find out the max tick index in newticks1.
newticks2.append( newticks1[ind+1] )
elif meandiff<np.min(newticks2):
ind=np.where(newticks1 == np.min(newticks2))[0][0] # find out the min tick index in newticks1.
newticks2.append( newticks1[ind-1] )
newticks2=np.array(newticks2)
newticks2.sort()
## Second re-draw of axis to shrink it to desired limits.
axx.yaxis.set_major_locator(FixedLocator(locs=newticks2))
## Despine the axes.
sns.despine(ax=axx, trim=True,
bottom=False, right=False,
left=True, top=True)
# Normalize bottom/right Contrast axes to each other for Cummings hub-and-spoke plots.
if (axesCount>2 and
contrastShareY is True and
floatContrast is False):
# Set contrast ylim as max ticks of leftmost swarm axes.
if contrastYlim is None:
lower=list()
upper=list()
for c in range(0,len(contrastList.columns)):
lower.append( np.min(contrastList.ix['bca_ci_low',c]) )
upper.append( np.max(contrastList.ix['bca_ci_high',c]) )
lower=np.min(lower)
upper=np.max(upper)
else:
lower=contrastYlim[0]
upper=contrastYlim[1]
normalizeContrastY(fig,
contrast_ylim = contrastYlim,
show_all_yaxes = showAllYAxes)
# if (axesCount==2 and
# floatContrast is False):
# drawback_x(fig.get_axes()[1])
# drawback_y(fig.get_axes()[1])
# if swarmShareY is False:
# for i in range(0, axesCount, 2):
# drawback_y(fig.get_axes()[i])
# if contrastShareY is False:
# for i in range(1, axesCount, 2):
# if floatContrast is True:
# sns.despine(ax=fig.get_axes()[i],
# top=True, right=False, left=True, bottom=True,
# trim=True)
# else:
# sns.despine(ax=fig.get_axes()[i], trim=True)
# Zero gaps between plots on the same row, if floatContrast is False
if (floatContrast is False and showAllYAxes is False):
gsMain.update(wspace=0.)
else:
# Tight Layout!
gsMain.tight_layout(fig)
# And we're all done.
rcdefaults() # restore matplotlib defaults.
sns.set() # restore seaborn defaults.
return fig, contrastList
def plot_benchs(output_dir=expanduser('~/output/recommender/benches')):
fig = plt.figure()
fig.subplots_adjust(right=.9)
fig.subplots_adjust(top=.915)
fig.subplots_adjust(bottom=.12)
fig.subplots_adjust(left=.08)
fig.set_figheight(fig.get_figheight() * 0.66)
gs = gridspec.GridSpec(1, 3, width_ratios=[1, 1, 1.5])
ylims = {
'100k': [.90, .96],
'1m': [.865, .915],
'10m': [.795, .868],
'netflix': [.928, .99]
}
xlims = {
'100k': [0.0001, 10],
'1m': [0.1, 15],
'10m': [1, 200],
'netflix': [30, 4000]
}
names = {
'dl_partial': 'Proposed \n(partial projection)',
'dl': 'Proposed \n(full projection)',
'cd': 'Coordinate descent'
}
for i, version in enumerate(['1m', '10m', 'netflix']):
with open(join(output_dir, 'results_%s.json' % version), 'r') as f:
data = json.load(f)
ax_time = fig.add_subplot(gs[0, i])
ax_time.grid()
sns.despine(fig, ax_time)
ax_time.spines['left'].set_color((.6, .6, .6))
ax_time.spines['bottom'].set_color((.6, .6, .6))
ax_time.xaxis.set_tick_params(color=(.6, .6, .6), which='both')
# ax_time.tick_params(axis='x', which='major', pad=2)
ax_time.yaxis.set_tick_params(color=(.6, .6, .6), which='both')
for tick in ax_time.xaxis.get_major_ticks():
tick.label.set_fontsize(7)
tick.label.set_color('black')
for tick in ax_time.yaxis.get_major_ticks():
tick.label.set_fontsize(7)
tick.label.set_color('black')
if i == 0:
ax_time.set_ylabel('RMSE on test set')
if i == 2:
ax_time.set_xlabel('CPU time')
ax_time.xaxis.set_label_coords(1.12, -0.045)
ax_time.grid()
palette = sns.cubehelix_palette(3,
start=0,
rot=.5,
hue=1,
dark=.3,
light=.7,
reverse=False)
color = {'dl_partial': palette[2], 'dl': palette[1], 'cd': palette[0]}
for estimator in sorted(OrderedDict(data).keys()):
this_data = data[estimator]
ax_time.plot(this_data['time'],
this_data['rmse'],
label=names[estimator],
color=color[estimator],
linewidth=2,
linestyle='-' if estimator != 'cd' else '--')
if version == 'netflix':
ax_time.legend(loc='upper left',
bbox_to_anchor=(.65, 1.1),
numpoints=1,
frameon=False)
ax_time.set_xscale('log')
ax_time.set_ylim(ylims[version])
ax_time.set_xlim(xlims[version])
if version == '1m':
ax_time.set_xticks([.1, 1, 10])
ax_time.set_xticklabels(['0.1 s', '1 s', '10 s'])
elif version == '10m':
ax_time.set_xticks([1, 10, 100])
ax_time.set_xticklabels(['1 s', '10 s', '100 s'])
else:
ax_time.set_xticks([100, 1000])
ax_time.set_xticklabels(['100 s', '1000 s'])
ax_time.annotate(
'MovieLens %s' %
version.upper() if version != 'netflix' else 'Netflix (140M)',
xy=(.5 if version != 'netflix' else .4, 1),
xycoords='axes fraction',
ha='center',
va='bottom')
plt.savefig(expanduser('~/output/icml/rec_bench.pdf'))
