def plot(most_probable_params, best_step, chain, lnprob, nwalkers, ndim, niter): # PLOT WALKERS fig=plt.figure() Y_PLOT=2 X_PLOT=5 alpha=0.1 # Walkers burnin=0.5*niter print 'burnin', burnin for n in range(ndim): ax=fig.add_subplot(Y_PLOT+1,X_PLOT,n+1) for i in range(nwalkers): # Risem za posamezne walkerje d=np.array(chain[i][burnin:,n]) ax.plot(d, color='black', alpha=alpha) ax.set_xlabel(thetaText[n+1]) if best_step-burnin>0: plt.axvline(x=best_step-burnin, linewidth=1, color='red') # Lnprob ax=fig.add_subplot(Y_PLOT+1,1,Y_PLOT+1) for i in range(nwalkers): ax.plot((lnprob[i][burnin:]), color='black', alpha=alpha) if best_step-burnin>0: plt.axvline(x=best_step-burnin, linewidth=1, color='red') #~ import triangle #~ fig = triangle.corner(sampler.flatchain, truths=most_probable_params) # labels=thetaText plt.show()
def mark_cross(center, **kwargs):
"""Mark a cross. Correct for matplotlib imshow funny coordinate system.
"""
N = 20
plt.hold(1)
plt.axhline(y=center[1]-0.5, **kwargs)
plt.axvline(x=center[0]-0.5, **kwargs)
def segmentation(self, threshold):
img = self.spectrogram["data"]
mask = (img > threshold).astype(np.float)
hist, bin_edges = np.histogram(img, bins=60)
bin_centers = 0.5*(bin_edges[:-1] + bin_edges[1:])
binary_img = mask > 0.5
plt.figure(figsize=(11,8))
plt.subplot(131)
plt.imshow(img)
plt.axis('off')
plt.subplot(132)
plt.plot(bin_centers, hist, lw=2)
print(threshold)
plt.axvline(threshold, color='r', ls='--', lw=2)
plt.text(0.57, 0.8, 'histogram', fontsize=20, transform = plt.gca().transAxes)
plt.text(0.45, 0.75, 'threshold = '+ str(threshold)[0:5], fontsize=15, transform = plt.gca().transAxes)
plt.yticks([])
plt.subplot(133)
plt.imshow(binary_img)
plt.axis('off')
plt.subplots_adjust(wspace=0.02, hspace=0.3, top=1, bottom=0.1, left=0, right=1)
plt.show()
print(img.max())
print(binary_img.max())
return mask
def plot_spikes(time,voltage,APTimes,titlestr):
"""
plot_spikes takes four arguments - the recording time array, the voltage
array, the time of the detected action potentials, and the title of your
plot. The function creates a labeled plot showing the raw voltage signal
and indicating the location of detected spikes with red tick marks (|)
"""
# Make a plot and markup
plt.figure()
plt.title(titlestr)
plt.xlabel("Time (s)")
plt.ylabel("Voltage (uV)")
plt.plot(time, voltage)
# Vertical positions for red marker
# The following attributes are configurable if required
vertical_markers_indent = 0.01 # 1% of Voltage scale height
vertical_markers_height = 0.03 # 5% of Voltage scale height
y_scale_height = 100 # Max of scale
marker_ymin = 0.5 + ( max(voltage) / y_scale_height / 2 ) + vertical_markers_indent
marker_ymax = marker_ymin + vertical_markers_height
# Drawing red markers for detected spikes
for spike in APTimes:
plt.axvline(spike, ymin=marker_ymin, ymax=marker_ymax, color='red')
plt.draw()
def plot_beta_dist( ctr, trials, success, alphas, betas, turns ):
"""
Pass in the ctr, trials and success, alphas, betas returned
by the `experiment` function and the number of turns
and plot the beta distribution for all the arms in that turn
"""
subplot_num = len(turns) / 2
x = np.linspace( 0.001, .999, 200 )
fig = plt.figure( figsize = ( 14, 7 ) )
for idx, turn in enumerate(turns):
plt.subplot( subplot_num, 2, idx + 1 )
for i in range( len(ctr) ):
y = beta( alphas[i] + success[ turn, i ],
betas[i] + trials[ turn, i ] - success[ turn, i ] ).pdf(x)
line = plt.plot( x, y, lw = 2, label = "arm {}".format( i + 1 ) )
color = line[0].get_color()
plt.fill_between( x, 0, y, alpha = 0.2, color = color )
plt.axvline( x = ctr[i], color = color, linestyle = "--", lw = 2 )
plt.title("Posteriors After {} turns".format(turn) )
plt.legend( loc = "upper right" )
return fig
def showKernel(dataOrMatrix, fileName = None, useLabels = True, **args) :
labels = None
if hasattr(dataOrMatrix, 'type') and dataOrMatrix.type == 'dataset' :
data = dataOrMatrix
k = data.getKernelMatrix()
labels = data.labels
else :
k = dataOrMatrix
if 'labels' in args :
labels = args['labels']
import matplotlib
if fileName is not None and fileName.find('.eps') > 0 :
matplotlib.use('PS')
from matplotlib import pylab
pylab.matshow(k)
#pylab.show()
if useLabels and labels.L is not None :
numPatterns = 0
for i in range(labels.numClasses) :
numPatterns += labels.classSize[i]
#pylab.figtext(0.05, float(numPatterns) / len(labels), labels.classLabels[i])
#pylab.figtext(float(numPatterns) / len(labels), 0.05, labels.classLabels[i])
pylab.axhline(numPatterns, color = 'black', linewidth = 1)
pylab.axvline(numPatterns, color = 'black', linewidth = 1)
pylab.axis([0, len(labels), 0, len(labels)])
if fileName is not None :
pylab.savefig(fileName)
pylab.close()
def test(args):
data = multivariate_normal([0, 0], [[1, 2], [2, 5]], int(args[1]))
print(data)
# PCA
result = pca(data, base_num=int(args[2]))
pc_base = result[0]
print(pc_base)
# Plotting
fig = plt.figure()
fig.add_subplot(1, 1, 1)
plt.axvline(x=0, color="#000000")
plt.axhline(y=0, color="#000000")
# Plot data
plt.scatter(data[:, 0], data[:, 1])
# Draw the 1st principal axis
pc_line = sp.array([-3.0, 3.0]) * (pc_base[1] / pc_base[0])
plt.arrow(0, 0, -pc_base[0] * 2, -pc_base[1] * 2, fc="r", width=0.15, head_width=0.45)
plt.plot([-3, 3], pc_line, "r")
# Settings
plt.xticks(size=15)
plt.yticks(size=15)
plt.xlim([-3, 3])
plt.tight_layout()
plt.show()
plt.savefig("image.png")
return 0
def my_lines(ax, pos, *args, **kwargs):
if ax == 'x':
for p in pos:
plt.axvline(p, *args, **kwargs)
else:
for p in pos:
plt.axhline(p, *args, **kwargs)
def plot_vrad_chi2(self, fig):
fig.clf()
ax = fig.add_subplot(111)
ax.plot(self.v_rads, self.v_rad_grid)
ax.set_xlabel('v_rad [km/s]')
ax.set_ylabel('Chi2')
ax.axvline(self.v_rad, color='red', linewidth=2)
ax.set_title('v_rad = %.2f' % self.v_rad)
def show_hist(datai, mean1, mean2, avg, title="Histogram", bins=100):
# mean1,mean2.min(),npdata.max()
# avg=(mean1+mean2)/2
fig, ax = subplots(1, 1, sharex=True, sharey=True, figsize=(10, 10))
n, bins, patches = ax.hist(datai.flat, bins=bins, range=(mean1, mean2), histtype="bar")
axvline(x=avg, alpha=0.7, linewidth=3, color="r")
ax.set_title("histogram")
show()
def plotline(x):
ax = x['ax']
xk = x['xk']
plt.sca(ax)
trans = blended_transform_factory(ax.transData,ax.transAxes)
plt.axvline(smpar[xk],ls='--')
plt.text(smpar[xk],0.9,'SM',transform=trans)
if libpar is not None:
plt.axvline(libpar[xk])
plt.text(libpar[xk],0.9,'LIB',transform=trans)
def plot_example(x, y, q_vals):
q = q_vals[np.argmax(np.array([var_sums(x, y, q) for q in q_vals]))]
beta, grid = gtv_cvlam(x, y, (q, ))
bins = np.linspace(0, 1, 100)[:, np.newaxis]
predictions = predict(bins, beta, grid)
plt.scatter(x[:, 0], y, color='blue')
plt.plot(bins, predictions, color='orange')
for b in breakpoints[1:-1]:
plt.axvline(b, ls='--', lw=3, color='green')
plt.savefig('plots/1d-example.pdf', bbox_inches='tight')
plt.close()
def save_fig(self, idx_episode, list_rwd):
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(20, 15))
ax.plot(range(idx_episode + 1), list_rwd)
ax.grid(True)
ax.set_ylabel('Total reward')
ax.set_xlabel('Episode')
plt.axhline(0, color='black')
plt.axvline(0, color='black')
fig.savefig('{}/reward_total.png'.format(self.path_summary))
plt.draw()
plt.close(fig)
def plot_policy(self, policy, prefix, policy_folder):
plt.clf()
for idx in range(len(policy)):
i, j = self.env.get_state_xy(idx)
dx = 0
dy = 0
if policy[idx] == 0: # up
dy = 0.35
elif policy[idx] == 1: # right
dx = 0.35
elif policy[idx] == 2: # down
dy = -0.35
elif policy[idx] == 3: # left
dx = -0.35
elif self.env.not_wall(i, j) and policy[idx] == 4: # termination
circle = plt.Circle(
(j + 0.5, self.config.input_size[0] - i + 0.5 - 1),
0.025,
color='k')
plt.gca().add_artist(circle)
if self.env.not_wall(i, j):
plt.arrow(j + 0.5,
self.config.input_size[0] - i + 0.5 - 1,
dx,
dy,
head_width=0.05,
head_length=0.05,
fc='k',
ec='k')
else:
plt.gca().add_patch(
patches.Rectangle(
(j, self.config.input_size[0] - i - 1), # (x,y)
1.0, # width
1.0, # height
facecolor="gray"))
plt.xlim([0, self.config.input_size[1]])
plt.ylim([0, self.config.input_size[0]])
for i in range(self.config.input_size[1]):
plt.axvline(i, color='k', linestyle=':')
plt.axvline(self.config.input_size[1], color='k', linestyle=':')
for j in range(self.config.input_size[0]):
plt.axhline(j, color='k', linestyle=':')
plt.axhline(self.config.input_size[0], color='k', linestyle=':')
plt.savefig(
os.path.join(policy_folder,
"SuccessorFeatures_" + prefix + 'policy.png'))
plt.close()
def plotline(x):
ax = x['ax']
xk = x['xk']
plt.sca(ax)
trans = blended_transform_factory(ax.transData,ax.transAxes)
plt.axvline(smpar[xk],ls='--')
plt.text(smpar[xk],0.9,'SM',transform=trans)
if libpar is not None:
plt.axvline(libpar[xk])
plt.text(libpar[xk],0.9,'LIB',transform=trans)
def hist_pos(dream2015_therapy, synergy_score, drug, outputfile):
df_synergy = pd.read_csv(dream2015_therapy)
syn = df_synergy['SYNERGY_SCORE']
fig = plt.figure()
plt.hist(syn, synergy_score)
plt.axvline(synergy_score, color='r', linestyle='dashed', linewidth=4)
ax = fig.add_subplot(111)
ax.text(synergy_score, 450, drug)
ax.set_xlabel('synergy score')
ax.set_ylabel('frequency')
plt.savefig(outputfile, dpi=600)
def test_r_wet_init(constants, r_dry, plot=False):
# Arrange
T = 280
RH = .9
f_org = .607
kappa = .356
class Particulator:
formulae = Formulae(surface_tension='CompressedFilm_Ovadnevaite')
class Env:
particulator = Particulator()
thermo = {
'T': CPU.Storage.from_ndarray(np.full(1, T)),
'RH': CPU.Storage.from_ndarray(np.full(1, RH))
}
def __getitem__(self, item):
return self.thermo[item]
r_dry_arr = np.full(1, r_dry)
# Plot
if plot:
r_wet = np.logspace(np.log(.9 * r_dry),
np.log(10 * si.nm),
base=np.e,
num=100)
sigma = Env.particulator.formulae.surface_tension.sigma(
np.nan, Env.particulator.formulae.trivia.volume(r_wet),
Env.particulator.formulae.trivia.volume(r_dry), f_org)
RH_eq = Env.particulator.formulae.hygroscopicity.RH_eq(
r_wet, T, kappa, r_dry**3, sigma)
pylab.plot(r_wet / si.nm, (RH_eq - 1) * 100, label='RH_eq')
pylab.axhline((RH - 1) * 100, color='orange', label='RH')
pylab.axvline(r_dry / si.nm, label='a', color='red')
pylab.axvline(Env.particulator.formulae.hygroscopicity.r_cr(
kappa, r_dry**3, T, const.sgm_w) / si.nm,
color='green',
label='b')
pylab.grid()
pylab.xscale('log')
pylab.xlabel('Wet radius [nm]')
pylab.xlim(r_wet[0] / si.nm, r_wet[-1] / si.nm)
pylab.ylabel('Equilibrium supersaturation [%]')
pylab.legend()
pylab.show()
# Act & Assert
r_wet_init(r_dry=r_dry_arr,
environment=Env(),
kappa_times_dry_volume=Env.particulator.formulae.trivia.volume(
r_dry_arr) * kappa,
f_org=np.full(1, f_org))
def plotPolicy(self, policy, prefix):
plt.clf()
for idx in range(len(policy)):
i, j = self.env.getStateXY(idx)
dx = 0
dy = 0
if policy[idx] == 0: # up
dy = 0.35
elif policy[idx] == 1: # right
dx = 0.35
elif policy[idx] == 2: # down
dy = -0.35
elif policy[idx] == 3: # left
dx = -0.35
elif self.matrixMDP[i][j] != -1 and policy[idx] == 4: # termination
circle = plt.Circle((j + 0.5, self.numRows - i + 0.5 - 1),
0.025,
color="k")
plt.gca().add_artist(circle)
if self.matrixMDP[i][j] != -1:
plt.arrow(
j + 0.5,
self.numRows - i + 0.5 - 1,
dx,
dy,
head_width=0.05,
head_length=0.05,
fc="k",
ec="k",
)
else:
plt.gca().add_patch(
patches.Rectangle(
(j, self.numRows - i - 1), # (x,y)
1.0, # width
1.0, # height
facecolor="gray",
))
plt.xlim([0, self.numCols])
plt.ylim([0, self.numRows])
for i in range(self.numCols):
plt.axvline(i, color="k", linestyle=":")
plt.axvline(self.numCols, color="k", linestyle=":")
for j in range(self.numRows):
plt.axhline(j, color="k", linestyle=":")
plt.axhline(self.numRows, color="k", linestyle=":")
plt.savefig(self.outputPath + prefix + "policy.png")
plt.close()
def dissimilar(twosier, slot=50, show=True):
'''
Compare each part of two time series data with a fixed sliding window,
and those below the overall Pearson correlation coefficient are detected
as dissimilar.
Parameters
----------
twosier : two 1-D array-like
Time series data to compare.
Returns
-------
ind : 1-D array-like
Indices of dissimilar parts.
'''
seir1, seir2 = twosier
assert len(seir1) == len(seir2)
nsample = len(seir1)
sp1 = [seir1[i:i + slot] for i in np.arange(nsample - slot + 1)]
sp2 = [seir2[i:i + slot] for i in np.arange(nsample - slot + 1)]
res = []
for i in np.arange(len(sp1)):
res.append(scipy.stats.pearsonr(sp1[i], sp2[i]))
ind = detect_onset(-np.array(res)[:, 0],
n_above=5,
threshold=-scipy.stats.pearsonr(seir1, seir2)[0])
# if len(ind):
# for tmpind in ind:
# if np.diff(tmpind) >= slot:
# tmpind[0] += slot
# tmpind[-1][1] == nsample - slot
if show:
plt.figure()
plt.subplot(221)
plt.plot(seir1)
plt.subplot(222)
plt.plot(seir2)
plt.subplot(223)
plt.plot(1 - np.array(res)[:, 0])
plt.subplot(224)
plt.plot(seir1)
plt.plot(seir2)
for oneind in ind:
plt.axvline(x=oneind[0], color='b', lw=1, ls='--')
plt.axvline(x=oneind[1], color='b', lw=1, ls='--')
return ind
def main():
# --- setup
times = 10**np.linspace(0, 11.0, 100)
nodes = np.linspace(0.0, 1.0, 100)
# nodes = nodes**2; nodes[0] = NaN
# big range
tmin = times[0]
tmax = times[-1]
dmin = 1
dmax = 1e+17
# --- main
plt.figure(figsize=(15, 10))
for ship in ships:
print(ship[5], ship[1] * 1e-3, " km/s", ship[0] * 1e-3, "kW/kg")
st, vt = timeToDistace(times,
ship[0],
ship[1],
ship[2],
ship[3],
ship[4],
nodes=nodes)
plt.plot(st, times, label=ship[5], color=ship[6], ls=ship[7])
#text ( st[-1], times[-1], ship[5], color='k', horizontalalignment='left', verticalalignment='center')
for time, txt in zip(timeLines, timeTexts):
if (time < tmax) and (time > tmin):
plt.axhline(time, color='k', alpha=0.5)
plt.text(dmax,
time,
txt,
color='k',
horizontalalignment='right',
verticalalignment='baseline')
for dist, txt in zip(distLines, distTexts):
if (dist < dmax) and (dist > dmin):
plt.axvline(dist, color='k', alpha=0.5)
plt.text(dist,
tmin,
txt,
rotation=90,
color='k',
horizontalalignment='left',
rotation_mode='anchor',
verticalalignment='baseline')
plt.legend(loc=2, prop={'family': 'monospace'})
plt.xscale('log')
plt.yscale('log')
plt.xlim(dmin, dmax)
plt.ylim(tmin, tmax)
plt.ylabel(r"Flight Time [ s ]")
plt.xlabel(r"Distance [ m ]")
plt.grid()
#plt.savefig( "timeToDistance.png", bbox_inches='tight' )
plt.show()
def tf_analysis(self, plot_Z = True, frequencies = None, vis_frequency_limits = [1.8, 2.2], nr_cycles = 16, analysis_sample_rate = 100):
self.assert_data_intern()
if frequencies == None:
frequencies = np.linspace(1.0, self.analyzer.low_pass_pupil_f, 40)
down_sample_factor = int(self.sample_rate/analysis_sample_rate)
resampled_signal = self.pupil_bp_pt[:,::down_sample_factor]
# complex tf results per trial
self.tf_trials = mne.time_frequency.cwt_morlet(resampled_signal, analysis_sample_rate, frequencies, use_fft=True, n_cycles=nr_cycles, zero_mean=True)
self.instant_power_trials = np.abs(self.tf_trials)
# z-score power
self.Z_tf_trials = np.zeros_like(self.instant_power_trials)
m = self.instant_power_trials.mean(axis = -1)
sd = self.instant_power_trials.std(axis = -1)
for z in range(len(self.Z_tf_trials)):
self.Z_tf_trials[z] = ((self.instant_power_trials[z].T - m[z]) / sd[z] ).T
# some obvious conditions
if plot_Z:
tf_to_plot = self.Z_tf_trials
else:
tf_to_plot = self.instant_power_trials
f = pl.figure(figsize = (24,24))
for x in range(len(self.trial_indices)):
s = f.add_subplot(len(self.trial_indices), 2, (x*2)+1)
pl.imshow(np.squeeze(tf_to_plot[x,(frequencies > vis_frequency_limits[0]) & (frequencies < vis_frequency_limits[1]),::100]), cmap = 'seismic', extent = [self.from_zero_timepoints[0], self.from_zero_timepoints[-1], vis_frequency_limits[-1], vis_frequency_limits[0]], aspect='auto')
sn.despine(offset=10)
s = f.add_subplot(len(self.trial_indices), 2, (x*2)+2)
# pl.imshow(np.squeeze(tf_to_plot[x,:,::100]), cmap = 'gray')
pl.plot(self.from_zero_timepoints[::down_sample_factor], np.squeeze(np.squeeze(tf_to_plot[x,(frequencies > vis_frequency_limits[0]) & (frequencies < vis_frequency_limits[1]),:])).mean(axis = 0), 'k')
if len(self.events) != 0:
events_this_trial = self.events[(self.events['EL_timestamp'] > self.timestamps_pt[x][0]) & (self.events['EL_timestamp'] < self.timestamps_pt[x][-1])]
for sc, scancode in enumerate(self.scancode_list):
these_event_times = events_this_trial[events_this_trial['scancode'] == scancode]['EL_timestamp']
for tet in these_event_times:
pl.axvline(x = (tet - self.timestamps_pt[x,0]) / self.sample_rate, c = self.colors[sc], lw = 5.0)
sn.despine(offset=10)
pl.tight_layout()
pl.savefig(os.path.join(self.analyzer.fig_dir, self.file_alias + '_%i_tfr.pdf'%nr_cycles))
with pd.get_store(self.analyzer.h5_file) as h5_file:
for name, data in zip(['tf_complex_real', 'tf_complex_imag', 'tf_power', 'tf_power_Z'],
np.array([np.real(self.tf_trials), np.imag(self.tf_trials), self.instant_power_trials, self.Z_tf_trials], dtype = np.float64)):
opd = pd.Panel(data,
items = pd.Series(self.trial_indices),
major_axis = pd.Series(frequencies),
minor_axis = self.from_zero_timepoints[::down_sample_factor])
h5_file.put("/%s/tf/cycles_%s_%s"%(self.file_alias, nr_cycles, name), opd)
def histograms_x2(tensor1, tensor2):
"""
Crea los histogramas de las listas pasadas,
con anotaciones y líneas marcadas.
:param tensor1: Primera lista
:param tensor2: Segunda lista
:return: None
"""
# Promedio de los valores de las listas pasadas
promedio_valores_1 = promedio_valores(tensor1)
promedio_valores_2 = promedio_valores(tensor2)
# Crea la figura que va a contener ambos histogramas
plt.figure(figsize=(15, 5))
# Figura número 1
plt.subplot(121)
cantidad_valores_por_clase_1, clases_1, patches1 = plt.hist(tensor1)
promedio_cantidades = promedio_valores(cantidad_valores_por_clase_1)
pyl.axvline(promedio_valores_1, color='r', linewidth=3, linestyle="--")
pyl.axhline(promedio_cantidades, color='#db9723', linewidth=3, linestyle="--")
plt.xlabel('Magnitud de los valores')
plt.ylabel('Cantidad de valores por clase')
plt.title('Histograma {} valores'.format(len(tensor1)))
plt.text(promedio_valores_1 * 1.05, max(cantidad_valores_por_clase_1) * .9,
"Promedio valores \naleatorios creados:\n{}".format(round(promedio_valores_1, 5)),
bbox={'facecolor': 'red', 'alpha': 0.75, 'pad': 2})
plt.text(clases_1[0], promedio_cantidades * .8,
"Promedio de cantidad\nde valores por clase:\n{}".format(promedio_cantidades),
bbox={'facecolor': 'orange', 'alpha': 0.75, 'pad': 2})
plt.grid()
# Figura número 2
plt.subplot(122)
cantidad_valores_por_clase_2, clases_2, patches2 = plt.hist(tensor2)
cantidad_máxima_2 = max(cantidad_valores_por_clase_2)
promedio_cantidades = promedio_valores(cantidad_valores_por_clase_2)
pyl.axvline(promedio_valores_2, color='r', linewidth=3, linestyle="--")
pyl.axhline(promedio_cantidades, color='#db9723', linewidth=3, linestyle="--")
plt.xlabel('Magnitud de los valores')
plt.ylabel('Cantidad de valores por clase')
plt.title('Histograma {} valores'.format(len(tensor2)))
plt.text(promedio_valores_2 * 1.05, cantidad_máxima_2 * .9,
"Promedio valores \naleatorios creados:\n{}".format(round(promedio_valores_2, 5)),
bbox={'facecolor': 'red', 'alpha': 0.75, 'pad': 2})
plt.text(clases_2[0], promedio_cantidades * 0.81,
"Promedio de cantidad\nde valores por clase:\n{}".format(promedio_cantidades),
bbox={'facecolor': 'orange', 'alpha': 0.75, 'pad': 2})
plt.grid()
def plot_themepark_score():
data = pickle.load(
open(
'results/results_cust_all_only_strat31jan/park_score_clust_all_only_strat.p',
'rb'))
data2 = [
1098, 1093, 1089, 1101, 1084, 1096, 1104, 1118, 1092, 1093, 1102, 1097,
1072, 1064, 1112, 1078, 1100, 1078, 1095, 1108, 1121, 1069, 1079, 1072,
1067, 1072, 1090, 1086, 1057, 1102, 1106, 1051, 1082, 1080, 1108, 1098,
1125, 1068, 1092, 1081, 1097, 1108, 1074, 1110, 1119, 1086, 1085, 1110,
1078, 1086, 1047, 1057, 1121, 1139, 1107, 1072, 1102, 1121, 1114, 1063,
1119, 1156, 1146, 1099, 1067
]
data3 = pickle.load(
open('results/results_cust_all_only_strat31jan/park_score.p', 'rb'))
data4 = pickle.load(
open(
'results/results_cust_all_only_strat31jan/park_score_clusterd_diff_strat.p',
'rb'))
STRATEGIES = [
"Adaptive", "Noise", "Random", "0.00", "0.25", "0.50", "0.75", "1.00"
]
x_pos = np.arange(len(STRATEGIES))
values = data.values()
values = list(values)
total = []
total.append(data4)
total.append(data2)
total.append(values[0])
total.append(values[1])
total.append(values[2])
total.append(values[3])
total.append(values[4])
total.append(values[5])
ticks = STRATEGIES
fig, axes = plt.subplots()
boxplot = axes.boxplot(total, patch_artist=True, widths=0.8)
plt.xticks(x_pos + 1, STRATEGIES)
# adding horizontal grid lines
axes.yaxis.grid(True)
plt.axvline(x=3.5, color='gray', linestyle='--')
# plt.yticks(np.arange(0, 100, 20))
# axes.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: ('%g') % (x / 1160)))
axes.set_title("Park score")
axes.set_xlabel('Strategy')
axes.set_ylabel('Score')
plt.show()
def annotates_peak(peaks, color='red', I_level=1e3, symbol=''):
for p in peaks:
angle = p['2𝜃 (deg)']
if angle > np.max(twth):
break
plt.axvline(x=angle, linewidth=1, color=color, alpha=0.7)
linename = p['hkl'].replace('(', '').replace(')', '')
text_y_position = I_level + 300 * np.gcd.reduce(p['hkl_tuple'])
plt.text(angle, text_y_position, linename, rotation=0, color=color)
def errorInfo(self, xRange, yVals, errors, label):
numXVals = 50
lowerError, upperError = errors
pl.title(r"$\Delta$" + label + r" vs. $\Delta$NLL")
pl.xlabel(r"$\Delta$" + label)
pl.ylabel("$\Delta NLL$")
pl.axvline(x = -lowerError, linestyle=':', color='r')
pl.axvline(x = upperError, linestyle=':', color='r')
pl.axhline(y = 0.5, linewidth=0.5, linestyle='--', color='dimgray')
pl.plot(xRange, yVals)
pl.show()
def worker_rate_hist(avg_rates, target_rate=10):
fig_labels = {
'fig_title': 'Worker Rates',
'x_label': 'Hourly rate (USD)',
'y_label': '# Workers',
}
bins = np.arange(0, avg_rates.max())
avg_rates.plot(kind='hist', bins=bins)
center_bin_labels(bins, fontsize=20)
plt.axvline(x=target_rate + 0.5, color='r', linewidth=3, linestyle='--')
plt.legend(['Target Rate'], fontsize=12)
make_standard_fig(fig_labels, save=True)
def epi_vs_gain_volcano_plot(filtered_gain_snps, filtered_epi_snps, gain_vals, epi_vals, max_p, min_I3):
gain_I3 = []
gain_log_p = []
for snps in filtered_gain_snps:
gain_I3.append(gain_vals[snps])
order = switch_snp_key_order(snps)
if epi_vals.has_key(order[0]):
gain_log_p.append(epi_vals[order[0]])
elif epi_vals.has_key(order[1]):
gain_log_p.append(epi_vals[order[1]])
gain_log_p = -1 * np.log10(gain_log_p)
epi_I3 = []
epi_log_p = []
for snps in filtered_epi_snps:
order = switch_snp_key_order(snps)
if gain_vals.has_key(order[0]):
epi_I3.append(gain_vals[order[0]])
elif gain_vals.has_key(order[1]):
epi_I3.append(gain_vals[order[1]])
epi_log_p.append(epi_vals[snps])
epi_log_p = -1 * np.log10(epi_log_p)
mp.figure(1)
mp.xlabel("I3")
mp.ylabel("-log10(P)")
mp.title("Volcano plot - EPISTASIS and GAIN")
mp.plot(epi_I3, epi_log_p, "bo")
mp.plot(gain_I3, gain_log_p, "ro")
mp.axhline(y=(-1 * np.log10(max_p)), linewidth=2, color="g")
mp.axvline(x=min_I3, linewidth=2, color="g")
# label max point
max_x = np.max(gain_I3)
max_y = np.max(gain_log_p)
best_connection = ""
# label best edge
for snps in epi_vals:
if -1 * np.log10(epi_vals[snps]) == max_y:
best_connection = str(snps)
mp.text(
np.max(gain_I3),
np.max(gain_log_p),
best_connection,
fontsize=10,
horizontalalignment="center",
verticalalignment="center",
)
mp.show()
print
def counter_histogram(library_barcode_counter, total_element_count, xlabel):
median = np.median(list(library_barcode_counter.values()))
stdev = np.std(list(library_barcode_counter.values()))
expected_per_variant = total_element_count / 2800
bins = np.linspace(0, max(library_barcode_counter.values()), 100)
plt.hist(list(library_barcode_counter.values()), bins=bins, density=True)
plt.axvline(expected_per_variant, color='k', linestyle='dashed')
plt.xlabel(xlabel)
plt.ylabel('Count')
plt.text(50, 0.14, 'Median: {0}\nExpected: {1}'.format(
round(median, 2), round(expected_per_variant, 2)))
plt.savefig('hist_barcode_per_variant.png', dpi=300)
plt.close()
def plot_cost_function_deltas(criterion, final_sizes):
colors = plt.rcParams["axes.prop_cycle"].by_key()["color"]
for scale, data in criterion.items():
if scale in final_sizes:
x, y = zip(*data)
y = np.array(y)
plt.plot(x, y - min(y) + 1, color=colors[scale - 2], label=scale)
plt.xscale("log")
plt.yscale("log")
plt.axvline(final_sizes[scale], color=colors[scale - 2])
plt.legend()
plt.ylabel("$\Delta(-\log{L})$", fontsize=12)
plt.xlabel("Distance (meters)", fontsize=12)
def plotPredictiveMarginals(self,
plotGridSize=0.001,
matrixPlotSide=(2, 2)):
plt.figure(177)
# For each parameter
for ii in range(self.nPars):
plt.subplot(matrixPlotSide[0], matrixPlotSide[1], ii + 1)
# Form grid for parameter
grid1 = np.arange(self.lowerBounds[ii], self.upperBounds[ii],
plotGridSize)
grid1 = grid1.reshape((len(grid1), 1))
# Stack grids together, fix all other parameters to thhat
grid2 = np.zeros((len(grid1), 1))
for kk in range(self.nPars):
if (kk == ii):
grid2 = np.hstack((grid2, grid1))
else:
grid2 = np.hstack((grid2, np.ones(
(len(grid1), 1)) * self.thhat[kk]))
# Remove the first column
grid2 = grid2[:, range(1, self.nPars + 1)]
# Make prediction
ypred, s2 = self.m.predict(grid2)
# Compensate for normalization
ypred = (ypred * np.sqrt(self.ynormVar)) + self.ynormMean
s2 = s2 * self.ynormVar
# Plot 95% CIs
plt.plot(grid1,
ypred + 1.96 * np.sqrt(s2),
linewidth=0.5,
color='k')
plt.plot(grid1,
ypred - 1.96 * np.sqrt(s2),
linewidth=0.5,
color='k')
# Plot mean function and data
plt.plot(grid1, ypred)
plt.plot(self.x[:, ii], self.y, 'k.')
# Plot thhat
plt.axvline(self.thhat[ii], linewidth=2, color='k')
def lcReview(self, fibre, eventList=[], save=False, saveName='default.png'):
"""
"""
time, flux, xpos, ypos, apts, msky, qual = self.getFullData(fibre)
TA = TimingAnalysis()
result, rms = TA.standardscore(time, flux, 2.0)
wmflux = result[0]
mSNR = np.median(wmflux/rms)
plt.figure(100, figsize=(8,12))
plt.clf()
plt.subplots_adjust(hspace=0.2)
plt.subplot(4,1,1)
plt.plot(time, flux, 'k+-', drawstyle='steps-mid')
plt.plot(time, wmflux, 'r-', label='averaged')
if len(eventList) == 0:
pass
else:
for value in eventList:
plt.axvline(x=value, color='red', ls='--')
plt.xlim(time[0], time[-1])
plt.ylim(0, np.median(flux) + 0.5*np.median(flux))
plt.ylabel('Flux (count)')
plt.xticks(visible=False)
plt.legend()
plt.title('{}, fibre {}. mSNR: {:.2f}'.format(self.filename[:-5], fibre, mSNR))
plt.subplot(4,1,2, sharex=plt.subplot(4,1,1))
plt.plot(time, xpos, 'b+', time, ypos, 'r+')
plt.xlim(time[0], time[-1])
plt.ylim(5,35)
plt.xticks(visible=False)
plt.ylabel('Position (pixel)')
plt.subplot(4,1,3, sharex=plt.subplot(4,1,1))
plt.plot(time, apts, 'k+')
plt.xlim(time[0], time[-1])
plt.ylim(0, np.mean(apts) + 0.5*np.mean(apts))
plt.xticks(visible=False)
plt.ylabel('Apt Size (pixel)')
plt.subplot(4,1,4, sharex=plt.subplot(4,1,1))
plt.plot(time, msky, 'k+')
plt.xlim(time[0], time[-1])
plt.ylim(0, np.median(msky) + 0.5*np.median(msky))
plt.xlabel('Time (s)')
plt.ylabel('Mean Sky Value (count)')
plt.show()
def marks(channel, begin, end, unit_index, show_original=False):
signal = channel['raw' if bool(show_original) else 'filtered']
plt.plot(signal[int(begin):int(end)], color='b')
peaks = channel['peaks']
units = channel['units']
times_in_range = peaks.value[np.where(units.value == int(unit_index))[0]]
plt.axhline(-channel.attrs['threshold'], color='r')
for t in times_in_range:
if t < int(begin):
continue
if t > int(end):
break
plt.axvline(t, color='g')
plt.show()
def panel_cluster_mean(cluster_id, cluster_means, cluster_predictive_score, cluster_poly_proportion, count, vlim, color, cid, lines=True, xlabels=True, ylabels=True):
plt.imshow(cluster_means[cluster_id], interpolation='none', origin='lower', cmap=cm.bwr, aspect=0.3, vmin=-vlim, vmax=vlim);
plt.axvline(x=16, ymin=0.0, ymax = 1.0, linewidth=1.0, color='r', ls='--');
if lines:
plt.axvline(x=19, ymin=0.0, ymax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axvline(x=24, ymin=0.0, ymax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axvline(x=32, ymin=0.0, ymax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=4, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=10, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=27, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=56, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
if xlabels:
plt.xticks(np.arange(0, 48, 3), np.asarray((np.arange(0, 769, 48) - 256) / 512.0 * 1000, dtype='int'), size=15, rotation=90);
else:
plt.xticks([])
if ylabels:
plt.yticks(np.arange(0, 146, 10), np.arange(4, 150, 10), size=15);
#plt.ylabel('Frequency (Hz)', size=16);
else:
plt.yticks([])
plt.title('Activity of %s (%d) probes' % (color.upper(), count), size=16, color=color);
plt.text(1, 129, str(cluster_id + 1), fontsize=20)
per_cid_stds = [0.11, 0.10, 0.10, 0.09, 0.10, 0.08, 0.10, 0.12]
plt.text(26, 132, 'F1 = %.4f ± %.2f' % (cluster_predictive_score[cluster_id], per_cid_stds[cid]), fontsize=15)
plt.text(31, 118, 'Poly %d' % cluster_poly_proportion[cluster_id] + '%', fontsize=15)
def panel_importance(importances, title, lines):
plt.imshow(importances, interpolation='none', origin='lower', cmap=cm.Blues, aspect='auto');
cb = plt.colorbar();
cb.ax.tick_params(labelsize=16);
plt.axvline(x=16, ymin=0.0, ymax = 1.0, linewidth=1.0, color='r', ls='--')
if lines:
plt.axvline(x=19, ymin=0.0, ymax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axvline(x=24, ymin=0.0, ymax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axvline(x=32, ymin=0.0, ymax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=4, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=10, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=27, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=56, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
# small axis
#plt.xticks(np.arange(0, 48, 1.5), np.asarray((np.arange(0, 769, 24) - 256) / 512.0 * 1000, dtype='int'), size=11, rotation=90);
#plt.yticks(np.arange(0, 146, 5), np.arange(4, 150, 5), size=12);
# med axis
plt.xticks(np.arange(0, 48, 2), np.asarray((np.arange(0, 769, 32) - 256) / 512.0 * 1000, dtype='int'), size=18, rotation=90);
plt.yticks(np.arange(0, 146, 7), np.arange(4, 150, 7), size=18);
# big axis
#plt.xticks(np.arange(0, 48, 3), np.asarray((np.arange(0, 769, 48) - 256) / 512.0 * 1000, dtype='int'), size=24, rotation=90);
#plt.yticks(np.arange(0, 146, 9), np.arange(4, 150, 9), size=20);
plt.ylabel('Frequency (Hz)', size=24);
plt.xlabel('Time (ms)', size=24);
if title is not None:
plt.title(title, size=26);
def panel_fitfdiff(diff, title, lines):
cm2rb = LinearSegmentedColormap.from_list('red_blue', ['blue', 'white', 'gray', 'red'], N=4)
plt.imshow(diff, interpolation='none', origin='lower', cmap=cm2rb, aspect='auto', vmin=-1.0, vmax=2.0);
plt.axvline(x=16, ymin=0.0, ymax = 1.0, linewidth=1.0, color='r', ls='--')
if lines:
plt.axvline(x=19, ymin=0.0, ymax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axvline(x=24, ymin=0.0, ymax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axvline(x=32, ymin=0.0, ymax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=4, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=10, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=27, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
plt.axhline(y=56, xmin=0.0, xmax = 1.0, linewidth=0.5, color='gray', ls='-')
# small axis
#plt.xticks(np.arange(0, 48, 1.5), np.asarray((np.arange(0, 769, 24) - 256) / 512.0 * 1000, dtype='int'), size=16, rotation=90);
#plt.yticks(np.arange(0, 146, 7), np.arange(4, 150, 7), size=16);
# big axis
plt.xticks(np.arange(0, 48, 3), np.asarray((np.arange(0, 769, 48) - 256) / 512.0 * 1000, dtype='int'), size=24, rotation=90);
plt.yticks(np.arange(0, 146, 9), np.arange(4, 150, 9), size=24);
plt.ylabel('Frequency (Hz)', size=24);
plt.xlabel('Time (ms)', size=24);
if title is not None:
plt.title(title, size=16);
def plot_cdf(self):
import matplotlib
import matplotlib.pylab as plt
matplotlib.rcParams.update({'font.size': 16.0})
fig=plt.figure(figsize=(11,8))
fig.set_facecolor('w')
self.data.hist(cumulative=True, density=1,bins=500)
perc95=self.data.quantile(q=0.95)
plt.axvline(perc95,color='r')
plt.title('CDF of JJA daily precip over Champaign, IL')
plt.xlabel('Daily precipitation (mm)')
plt.text(20.2,0.8,'95th percentile = '+str(perc95))
def draw_reward_zone():
for stripe in range(8):
if stripe % 2 == 0:
plt.axvline(91.25 + stripe * 2.5,
color='limegreen',
linewidth=5.5,
alpha=0.4,
zorder=0)
else:
plt.axvline(91.25 + stripe * 2.5,
color='k',
linewidth=5.5,
alpha=0.4,
zorder=0)
def plot_ccf(w,tspec,mspec):
lag,tmccf = ccf(tspec,mspec)
dv = restwav.loglambda_wls_to_dv(w)
dv = lag*dv
dvmax = ccs.findpeak(dv,tmccf)
plt.plot(dv,tmccf,'k',label='tspec')
plt.axvline(dvmax,color='RoyalBlue',lw=2,alpha=0.4,zorder=0)
AddAnchored("dv (max) = %.2f km/s" % dvmax,**annkw)
plt.xlim(-50,50)
plt.xlabel('dv (km/s)')
return dvmax
def test_prox_hinge_2(q, rho=0.8, doplot=True):
from matplotlib import pylab as plt
n = 100000
p = np.linspace(-0.5, 0.5, n)
res = ww(p) + 0.5 * rho * (p-q)**2
index_min = np.argmin(res)
p_min = p[index_min]
plt.clf()
plt.plot(p, res, color='red')
print 'p_min: %s' % p_min
plt.axvline(p_min, color='blue')
qq = np.array([q])
prox = prox_ww(qq, rho)
plt.axvline(p_min, color='orange', linestyle='--')
assert abs(prox-p_min) < 1e-5
def plot_ccf(w,tspec,mspec):
lag,tmccf = ccf(tspec,mspec)
dv = restwav.loglambda_wls_to_dv(w)
dv = lag*dv
dvmax = ccs.findpeak(dv,tmccf)
plt.plot(dv,tmccf,'k',label='tspec')
plt.axvline(dvmax,color='RoyalBlue',lw=2,alpha=0.4,zorder=0)
AddAnchored("dv (max) = %.2f km/s" % dvmax,**annkw)
plt.xlim(-50,50)
plt.xlabel('dv (km/s)')
return dvmax
def butter_lowpass_filter(data, sample_rate, cutoff=10, order=4, plot=False):
"""
`Low-pass filter <http://stackoverflow.com/questions/25191620/
creating-lowpass-filter-in-scipy-understanding-methods-and-units>`_ data by the [order]th order zero lag Butterworth filter
whose cut frequency is set to [cutoff] Hz.
:param data: time-series data,
:type data: numpy array of floats
:param: sample_rate: data sample rate
:type sample_rate: integer
:param cutoff: filter cutoff
:type cutoff: float
:param order: order
:type order: integer
:return y: low-pass-filtered data
:rtype y: numpy array of floats
:Examples:
>>> from mhealthx.signals import butter_lowpass_filter
>>> data = np.random.random(100)
>>> sample_rate = 10
>>> cutoff = 5
>>> order = 4
>>> y = butter_lowpass_filter(data, sample_rate, cutoff, order)
"""
nyquist = 0.5 * sample_rate
normal_cutoff = cutoff / nyquist
b, a = butter(order, normal_cutoff, btype='low', analog=False)
if plot:
w, h = freqz(b, a, worN=8000)
plt.subplot(2, 1, 1)
plt.plot(0.5*sample_rate*w/np.pi, np.abs(h), 'b')
plt.plot(cutoff, 0.5*np.sqrt(2), 'ko')
plt.axvline(cutoff, color='k')
plt.xlim(0, 0.5*sample_rate)
plt.title("Lowpass Filter Frequency Response")
plt.xlabel('Frequency [Hz]')
plt.grid()
plt.show()
y = lfilter(b, a, data)
return y
def plotGeneral(self, initFlux, normFlux, xpos, ypos, quality, direction, variance, threshold):
plt.figure('General')
plt.clf()
plt.subplot(5,1,1)
plt.plot(self.time, initFlux, 'k-', drawstyle='steps-mid')
for event in self.eventList:
plt.axvline(x=self.time[event], color='red', ls='--')
plt.xlim(self.time[0], self.time[-1])
plt.ylabel('Original LCs')
plt.xticks(visible=False)
plt.title('{}, f{}'.format(self.fileName, self.fibre))
plt.subplot(5,1,2, sharex=plt.subplot(5,1,1))
plt.plot(self.time, normFlux, 'g+')
plt.plot(self.time, normFlux, 'k-', drawstyle='steps-mid')
for event in self.eventList:
plt.axvline(x=self.time[event], color='red', ls='--')
plt.xlim(self.time[0], self.time[-1])
plt.ylim(0.0, 1.5)
plt.ylabel('Normalised LCs')
plt.xticks(visible=False)
plt.subplot(5,1,3, sharex=plt.subplot(5,1,1))
plt.plot(self.time, quality, 'k-', drawstyle='steps-mid', label='quality')
plt.plot(self.time, direction, 'r-', drawstyle='steps-mid', label='direction')
plt.xlim(self.time[0], self.time[-1])
plt.ylim(-2, 2)
plt.xticks(visible=False)
plt.legend()
plt.subplot(5,1,4, sharex=plt.subplot(5,1,1))
plt.plot(self.time, xpos, 'b-', drawstyle='steps-mid', label='x')
plt.plot(self.time, ypos, 'r-', drawstyle='steps-mid', label='y')
plt.xlim(self.time[0], self.time[-1])
plt.ylim(1,40)
plt.xticks(visible=False)
plt.legend()
plt.subplot(5,1,5, sharex=plt.subplot(5,1,1))
plt.plot(self.time, variance, 'k-', drawstyle='steps-mid')
plt.plot(self.time, threshold, 'r-', label=r'{}$\sigma$'.format(self.dTL))
plt.xlim(self.time[0], self.time[-1])
plt.ylabel('Variance')
plt.xlabel('Time (s)')
plt.legend()
plt.show()
def k_sensitivity(mutant_expression: float):
system = S_OPEN_2
enz = get_parameter_set()
initial_con = get_random_concentrations(1, system)
s_array = np.linspace(0.1, 10, 30).tolist()
s_array.append(1)
pa_level = []
print(enz.get(E_SINK).v)
for f in s_array:
enz.get(E_SOURCE).k *= f
if f == 1:
print(enz.get(E_SOURCE).k)
wt_output = get_concentration_profile(system, initial_con, enz,
ode_end_time, ode_slices)
enz[E_DAGK].mutate(mutant_expression)
rdga_output = get_concentration_profile(system, initial_con, enz,
ode_end_time, ode_slices)
enz[E_DAGK].mutate(1 / mutant_expression)
enz[E_LAZA].mutate(mutant_expression)
laza_output = get_concentration_profile(system, initial_con, enz,
ode_end_time, ode_slices)
enz[E_LAZA].mutate(1 / mutant_expression)
rdga = [
get_pa_ratio(wt_output[-1], rdga_output[-1]),
get_dag_ratio(wt_output[-1], rdga_output[-1])
]
laza = [
get_pa_ratio(wt_output[-1], laza_output[-1]),
get_dag_ratio(wt_output[-1], laza_output[-1])
]
pa_level.append(get_pa_ratio(wt_output[-1], laza_output[-1]))
enz.get(E_SOURCE).k /= f
plt.scatter(s_array, pa_level)
plt.xlabel("Factor (x $k_{source}$)")
plt.ylabel("PA/Pi ratio in LAZA")
plt.title(system)
plt.axvline(1)
plt.axhline(2.5)
plt.show()
def onClick(self, event):
"""
Process a mouse click event. If a mouse is right clicked within a
subplot, the return value is set to a (subPlotNr, xVal, yVal) tuple and
the plot is closed. With right-clicking and dragging, the plot can be
moved.
Arguments:
event -- a MouseEvent event
"""
if event.button == 1:
# for i in range(self.nSubPlots):
# subPlot = self.selectSubPlot(i)
marker = plot.axvline(event.xdata, 0, 1, linestyle='--', \
linewidth=2, color='gray')
self.markers.append(marker)
self.fig.canvas.draw()
self.retVal['x'] = np.append(self.retVal['x'], event.xdata)
self.retVal['y'] = np.append(self.retVal['y'], event.ydata)
if event.button == 3:
plot.close()
def raw_signal_plot(self): self.assert_data_intern() f = pl.figure(figsize = (24,24)) for x in range(len(self.trial_indices)): s = f.add_subplot(len(self.trial_indices), 1, x+1) pl.plot(self.timestamps_pt[x][::100], self.pupil_bp_pt[x][::100], 'k') if len(self.events) != 0: events_this_trial = self.events[(self.events['EL_timestamp'] > self.timestamps_pt[x][0]) & (self.events['EL_timestamp'] < self.timestamps_pt[x][-1])] for sc, scancode in enumerate(self.scancode_list): these_event_times = events_this_trial[events_this_trial['scancode'] == scancode]['EL_timestamp'] for tet in these_event_times: pl.axvline(x = tet, c = self.colors[sc], lw = 5.0) sn.despine(offset=10) pl.tight_layout() pl.savefig(os.path.join(self.analyzer.fig_dir, self.file_alias + '_raw.pdf'))
def graphs_distribution_shifts():
""" This graphs plots the distribution of latent utilities for varying levels of the location
parameter.
"""
grid = np.linspace(-3, 3, 100)
ax = plt.figure(figsize=(12, 8)).add_subplot(111)
negative_mean = norm.pdf(grid, -1, 1)
zero_mean = norm.pdf(grid, 0, 1)
plt.plot(grid, negative_mean, label=r"$\theta$", linewidth=5, color='red')
plt.plot(grid, zero_mean, label=r"$\theta'$", linewidth=5, color='blue')
ax.tick_params(labelsize=18,
direction='out',
axis='both',
top='off',
right='off')
plt.axvline(x=0, linewidth=5, color='black')
ax.set_ylabel('Density Function', fontsize=16)
ax.set_xlabel(r'Latent Utility', fontsize=16)
ax.yaxis.get_major_ticks()[0].set_visible(False)
ax.set_xlim(-3, 3)
ax.set_ylim(0, 0.45)
ax.text(-2.5, 0.4, r'$D = 0$', fontsize=30)
ax.text(+1.8, 0.4, r'$D = 1$', fontsize=30)
ax.fill_between(grid,
zero_mean,
negative_mean,
where=grid > 0.0,
color='lightblue')
ax.legend(loc='upper center',
bbox_to_anchor=(0.5, -0.10),
fancybox=False,
frameon=False,
shadow=False,
ncol=3,
fontsize=20)
plt.savefig('../images/distribution_shift.png',
bbox_inches='tight',
format='png')
def plotDifference(bst, dtest, target = None):
p = bst.predict(dtest)
l = 0
if (target is None):
l = dtest.get_label()
else:
l = target
res = np.abs((l-p)/l)
res = res[~np.isnan(res)]
res = res[~np.isinf(res)]
xmax = 0.2
for y in np.arange(0,xmax,xmax/8):
plt.axvline(y, color='g', linestyle='dashed')
plt.hist(res, range=(0,xmax), bins=50, color='red')
plt.axvline(res.mean(), color='c', linestyle='dashed', linewidth=2)
for y in range(200,1600,200):
plt.axhline(y, color='g', linestyle='dashed')
def plot(model, x_obs, y_obs, argmin_a_x, a, x):
y_mean, y_sigma = model.predict(x, return_std=True)
y_sigma = np.atleast_2d(y_sigma).T
a_x = a(x)
plt.plot(x, y_mean, 'r-')
plt.plot(x_obs, y_obs, 'o')
plt.axvline(argmin_a_x)
plt.plot(
x,
a_x*(1/np.max(a_x)),
'g--',
)
plt.plot(x, f(x), 'm--')
plot_confidences(x, y_mean, y_sigma, confidences=[1])
def plot(self,plt=None):
u = self.solver.u
t = self.solver.t
if plt is None:
#import scitools.std as plt
import matplotlib.pylab as plt
plt.plot(t,u,"r")
plt.axvline(self.solver.t_r) # mark a straight line at t = t_r
plt.hold("on")
theta2name = {0:"FE", 1:"BE", 0.5:"CN"}
name = theta2name.get(self.solver.theta,"")
legends = ["numerical %s" %name]
plt.legend(legends)
plt.xlabel("t")
plt.ylabel("u")
plt.title("theta = %g , dt = %g" %(self.solver.theta, self.solver.dt))
return plt
def rDist(r,sd1 = 10, sd2 = 10):
mup = 50 + (100*(r/2))
mlow = 50 - (100*(r/2))
y2 = np.random.normal(mup,sd1,10000)
y1 = np.random.normal(mlow,sd1,10000)
plt.grid(True)
plt.hist(y1,50, label = '$Control\ Group$', alpha = .7, color = 'b')
plt.hist(y2,50, label = '$Experimental\ Group$', alpha = .5, color = 'g')
plt.xlim(0, 100)
plt.legend( loc= 'right')
plt.title('$Binomial\ Effect\ Size\ Display\ (BESD).$')
plt.xlabel('Bin number for each one percentage bin')
plt.ylabel('Frequency of each value occurring')
plt.axvline(mup, ms = 3, color= 'r')
plt.axvline(mlow, ms = 3, color = 'r')
plt.show()
return
def plotPredictiveMarginals(self, plotGridSize=0.001, matrixPlotSide=(2, 2)):
plt.figure(177)
# For each parameter
for ii in range(self.nPars):
plt.subplot(matrixPlotSide[0], matrixPlotSide[1], ii + 1)
# Form grid for parameter
grid1 = np.arange(self.lowerBounds[ii], self.upperBounds[
ii], plotGridSize)
grid1 = grid1.reshape((len(grid1), 1))
# Stack grids together, fix all other parameters to thhat
grid2 = np.zeros((len(grid1), 1))
for kk in range(self.nPars):
if (kk == ii):
grid2 = np.hstack((grid2, grid1))
else:
grid2 = np.hstack(
(grid2, np.ones((len(grid1), 1)) * self.thhat[kk]))
# Remove the first column
grid2 = grid2[:, range(1, self.nPars + 1)]
# Make prediction
ypred, s2 = self.m.predict(grid2)
# Compensate for normalization
ypred = (ypred * np.sqrt(self.ynormVar)) + self.ynormMean
s2 = s2 * self.ynormVar
# Plot 95% CIs
plt.plot(grid1, ypred + 1.96 * np.sqrt(s2),
linewidth=0.5, color='k')
plt.plot(grid1, ypred - 1.96 * np.sqrt(s2),
linewidth=0.5, color='k')
# Plot mean function and data
plt.plot(grid1, ypred)
plt.plot(self.x[:, ii], self.y, 'k.')
# Plot thhat
plt.axvline(self.thhat[ii], linewidth=2, color='k')
def fplot(x0):
"""plot f(x) in the neighborhood of the initial guess"""
#build x and f vectors
points = 200
xmin = x0 - 5.0
xmax = x0 + 5.0
xvec = linspace(xmin,xmax, num=points,endpoint = True)
fvec = matrix (0, (points, 1), 'd')
for item, x in enumerate(xvec):
fvec[item] = Function.fcall(x)
# graphical commands
fig = pyplot.figure()
pyplot.hold(True)
pyplot.plot(xvec, fvec, 'k')
pyplot.axhline(linestyle=':',color = 'k')
pyplot.axvline(linestyle=':',color = 'k')
pyplot.xlabel('$x$')
pyplot.ylabel('$f(x)$')
pyplot.savefig('zeroplot.eps',format='eps')
pyplot.show()
def plot_spikes(time,voltage,APTimes,titlestr):
"""
plot_spikes takes four arguments - the recording time array, the voltage
array, the time of the detected action potentials, and the title of your
plot. The function creates a labeled plot showing the raw voltage signal
and indicating the location of detected spikes with red tick marks (|)
"""
plt.figure()
plt.title(titlestr)
plt.xlabel("Time (s)")
plt.ylabel("Voltage (uV)")
plt.plot(time, voltage)
#plt.axhline(np.mean(voltage), color='green')
#plt.axhline(3*np.std(voltage), color='green')
#plt.axhline(-3*np.std(voltage), color='green')
for x in APTimes:
plt.axvline(x=x, ymin=0.9, linewidth=1, color='red')
plt.show()
def drawDataLine(self):
#--------- Update position indicator ---------
plt.figure('Data')
if len(self.vLine) > 0:
for item in self.vLine:
item.remove()
self.vLine = []
self.vLine.append(plt.axvline(self.currentIndex.get(),ls='dashed',c='k'))
plt.tight_layout()
self.canvas['Data'].draw()
return
def plot_rough(data=None, use_fb=True, levels=20, colorbars=False):
if data is None: data = read_rough('rough')
(x, y) = ('fb_x', 'fb_y') if use_fb else ('x', 'y')
fig = pl.figure()
#pos = np.genfromtxt("rough_pos")
pos = None
print pos
for n,signal in enumerate(['psd_x', 'psd_y', 'sum_x', 'sum_y']):
pl.subplot(2,2,n+1)
pl.contourf(data[x][:,:,0], data[y][:,:,0], data[signal][:,:,0], levels)
pl.title(signal)
pl.axis('equal')
pl.axis('tight')
if colorbars:
pl.colorbar()
if pos is not None:
pl.axvline(pos[0], alpha=0.3)
pl.axhline(pos[1], alpha=0.3)
fig.show()
def plot_abc(self, uarg, param):
"""Plot a() and b() functions on the same plot.
"""
plt.figure(figsize=(8, 4))
plt.subplot(1, 3, 1)
plt.plot(uarg, self.afun(uarg, param))
plt.axhline(0)
plt.axvline(0)
plt.ylabel('$a(u)$')
plt.xlabel('$u$')
plt.subplot(1, 3, 2)
plt.plot(uarg, self.bfun(uarg, param))
plt.axhline(0)
plt.axvline(0)
plt.ylabel('$b(u)$')
plt.xlabel('$u$')
plt.subplot(1, 3, 3)
plt.plot(uarg, self.cfun(uarg, param))
plt.axhline(0)
plt.axvline(0)
plt.ylabel('$c(u)$')
plt.xlabel('$u$')
plt.tight_layout()
plt.show()
def plot_days_after_sales(messages=None, purchase_dates=None):
count_of_days = sales_days_from_messages(messages=messages, purchase_dates=purchase_dates, randomize=False)
n_days, n_sales = days_sales(count_of_days)
plt.clf()
plt.subplot(2, 1, 1)
plt.plot(n_days, n_sales, color='blue', marker='o', linestyle='-')
plt.axvline(x=0, linestyle='--', color='red')
plt.title('Normal')
plt.xlabel('N days after message')
plt.ylabel('N sales')
count_of_days_randomized = sales_days_from_messages(messages=messages, purchase_dates=purchase_dates, randomize=True)
n_days_randomized, n_sales_randomized = days_sales(count_of_days_randomized)
plt.subplot(2, 1, 2)
plt.plot(n_days_randomized, n_sales_randomized, color='blue', marker='o', linestyle='-')
plt.axvline(x=0, linestyle='--', color='red')
plt.title('Users randomized')
plt.xlabel('N days after message')
plt.ylabel('N sales')
def plotMadMedian(self, events, figsize=(5, 5), save=False,
figname='mam-median-evts', figtype='png'):
""" Plots the median and the medan absolute value of the input
array events
**Parameters**
events : double
The spike events
figsize : float
A tuple of the sizes of the figure
save : boolean
Indicates if the figure will be saved
figname : string
The name of the saved figure
figtype : string
The type of the saved figure (supports png and pdf)
"""
events_median = np.apply_along_axis(np.median, 0, events)
events_mad = np.apply_along_axis(mad, 0, events)
plt.figure(figsize=figsize)
plt.plot(events_median, color='red', lw=2)
plt.axhline(y=0, color='black')
for i in np.arange(0, 400, 100):
plt.axvline(x=i, c='k', lw=2)
for i in np.arange(0, 400, 10):
plt.axvline(x=i, c='grey')
plt.plot(events_median, 'r', lw=2)
plt.plot(events_mad, 'b', lw=2)
if save:
if figtype == 'pdf':
plt.savefig(figname+'pdf', dpi=90)
else:
plt.savefig(figname+'png')
def plot_spikes(time,voltage,APTimes,titlestr):
"""
plot_spikes takes four arguments - the recording time array, the voltage
array, the time of the detected action potentials, and the title of your
plot. The function creates a labeled plot showing the raw voltage signal
and indicating the location of detected spikes with red tick marks (|)
"""
plt.figure()
##Your Code Here
plt.figure()
plt.title(titlestr)
plt.xlabel("Time (s)")
plt.ylabel("Voltage (uV)")
plt.plot(time, voltage)
for i in APTimes:
plt.axvline(x=i, ymin=0.93, ymax=0.96, color='red')
plt.show()
