def layout(self, ax):
if not self.is_leaf:
[child.layout(ax) for child in self.contents]
plt.box('off')
self.set_width(ax)
self.set_height(ax)
ax.clear()
def plot(label):
if not GRAPHS:
return
for i, f in enumerate(c.codebook):
plt.plot([i + 1] * len(f), 'k-', lw=0.5, alpha=0.5, aa=True)
plt.plot(i + 1 + f, 'k-', lw=1, alpha=0.8, aa=True)
o = rng.randint(0, len(train) - width - 1)
plt.plot(train[o:o+width], 'r-', aa=True)
plt.gca().set_yticks([])
plt.box(False)
plt.savefig(os.path.join(GRAPHS, '%s-w%03d-c%03d-%05d-basis.png' % (label, width, codebook, seq)))
plt.clf()
def plot_correlation(self, other_interface, lines=False, bounds=None):
""" Plot this interface's view on the underlying product vs
another interface's view.
Each vulnerability will be represented as a point, with the x coordinate
representing the likelihood that this interface will discover the
vulnerability in the next round, and the y coordinate representing
the likelihood that the other interface will discover it this round.
This plot is helpful for understanding the discovery correlation that
arises with learning.
Parameters
----------
other_interface: Interface object
The interface object must be built upon the same underlying 'product'
as the present interface
lines: True/False
If true, will overlay horizontal and vertical lines representing the
mean discovery profile for each actor, and label them with the mean
value.
bounds: None or float
If float will set the x and y limits to this value.
TODO
----
It might be a good idea to make the bounds an x/y tuple if we want to
initialize the interfaces with different `max_area` values.
"""
plt.plot(self.circles.area, other_interface.circles.area, '.', alpha=.1)
if bounds == None:
window_size = max(self.circles.area.max(), other_interface.circles.area.max())
else:
window_size = bounds
if lines:
y_mean = np.mean(other_interface.circles.area)
x_mean = np.mean(self.circles.area)
plt.hlines(y_mean, 0, window_size)
plt.text(window_size, y_mean, 'mean=%f'%y_mean, ha='right', va='bottom')
plt.vlines(x_mean, 0, window_size)
plt.text(x_mean, window_size, 'mean=%f'%x_mean, rotation=90, ha='right', va='top')
plt.xlim(0, window_size)
plt.ylim(0, window_size)
plt.box('off')
plt.xlabel(self.name + ' likelihood of discovery', fontsize=14)
plt.ylabel(other_interface.name + ' likelihood of discovery', fontsize=14)
def plot_stroke(region: SpliceRegion, font_size: float = 5):
strokes = sorted(region.stroke, key=lambda x: [x.start, x.end])
for i, stroke in enumerate(strokes):
pylab.hlines(y=i,
xmin=stroke.start,
xmax=stroke.end,
color=stroke.color,
lw=2)
pylab.text(stroke.center - len(stroke.label) / 2,
i + .2,
stroke.label,
fontsize=font_size)
pylab.xlim(left=0, right=len(region))
pylab.ylim(bottom=-1, top=len(strokes))
pylab.box(on=False)
pylab.xticks([])
pylab.yticks([])
def export(self, filename, limits=None):
import matplotlib.pylab as plt
plt.style.use('dark_background')
if limits is None:
xmin, xmax, ymin, ymax = self.get_limits()
else:
xmin, xmax, ymin, ymax = limits
for x in range(xmin,xmax+1):
plt.plot([x,x],[ymin,ymax],"w-")
for y in range(ymin,ymax+1):
plt.plot([xmin,xmax],[y,y],"w-")
for x,y in self.alive:
if xmin <= x < xmax and ymin <= y < ymax:
plt.fill([x,x+1,x+1,x,x],[y,y,y+1,y+1,y],"w")
plt.tick_params(axis='x',which='both',bottom='off',top='off',labelbottom='off')
plt.tick_params(axis='y',which='both',left='off',right='off',labelleft='off')
plt.axis("equal")
plt.box("off")
plt.savefig(filename)
plt.clf()
def generate_MAPE_3D(loop_num, pred_time):
if pred_time == 5:
temp = pd.read_csv(
r'D:\Users\yyh\Pycharm_workspace\CNN_response_simulation\data\CNN\{}min\l'
r'oop{}_res_error.csv'.format(pred_time, loop_num))
else:
temp = pd.read_csv(
r'D:\Users\yyh\Pycharm_workspace\CNN_response_simulation\data\CNN\{}min\l'
r'oop{}_res_error{}.csv'.format(pred_time, loop_num, pred_time))
mape_pd = pd.DataFrame(temp.MAPE.values.reshape(10, 10),
index=[
'space4', 'space8', 'space12', 'space16',
'space20', 'space24', 'space28', 'space32',
'space36', 'space40'
],
columns=[
'time_lag4', 'time_lag8', 'time_lag12',
'time_lag16', 'time_lag20', 'time_lag24',
'time_lag28', 'time_lag32', 'time_lag36',
'time_lag40'
])
mae_pd = pd.DataFrame(temp.MAE.values.reshape(10, 10),
index=[
'space4', 'space8', 'space12', 'space16',
'space20', 'space24', 'space28', 'space32',
'space36', 'space40'
],
columns=[
'time_lag4', 'time_lag8', 'time_lag12',
'time_lag16', 'time_lag20', 'time_lag24',
'time_lag28', 'time_lag32', 'time_lag36',
'time_lag40'
])
fig = plt.figure(figsize=(8, 6))
ax = Axes3D(fig)
X = np.arange(10)
Y = np.arange(10)
X, Y = np.meshgrid(X, Y)
Z = np.array(mape_pd)[X, Y]
plt.rcParams['savefig.dpi'] = 100 # 图片像素
plt.rcParams['figure.dpi'] = 100 # 分辨率
ax.plot_surface((X + 1) * 4, (Y + 1) * 4,
Z,
rstride=1,
cstride=1,
cmap='rainbow')
ax.set_title("NO.{} Loop Detector {} min Traffic Flow Prediction".format(
loop_num, pred_time),
fontsize=16)
ax.set_xlabel("Loop Detector Number", fontsize=16)
ax.set_ylabel("Observation Time Lags", fontsize=16)
ax.set_zlabel("Mean Absolute Percentage Error(MAPE)", fontsize=16)
ax.xaxis.set_tick_params(labelsize=12)
ax.yaxis.set_tick_params(labelsize=12)
ax.zaxis.set_tick_params(labelsize=12)
plt.box()
plt.show()
fig = plt.figure(figsize=(8, 6))
ax = Axes3D(fig)
X = np.arange(10)
Y = np.arange(10)
X, Y = np.meshgrid(X, Y)
Z = np.array(mae_pd)[X, Y]
plt.rcParams['savefig.dpi'] = 100 # 图片像素
plt.rcParams['figure.dpi'] = 100 # 分辨率
ax.plot_surface((X + 1) * 4, (Y + 1) * 4,
Z,
rstride=1,
cstride=1,
cmap='rainbow')
ax.set_title("NO.{} Loop Detector {} min Traffic Flow Prediction".format(
loop_num, pred_time),
fontsize=16)
ax.set_xlabel("Loop Detector Number", fontsize=16)
ax.set_ylabel("Observation Time Lags", fontsize=16)
ax.set_zlabel("Mean Absolute Error(MAE)", fontsize=16)
ax.xaxis.set_tick_params(labelsize=12)
ax.yaxis.set_tick_params(labelsize=12)
ax.zaxis.set_tick_params(labelsize=12)
plt.box()
plt.show()
ax = plt.subplot()
mape_pd.plot(ax=ax)
ax.xaxis.set_tick_params(rotation=30, labelsize=12)
plt.show()
ax = plt.subplot()
mape_pd.T.plot(ax=ax)
ax.xaxis.set_tick_params(rotation=30, labelsize=12)
plt.show()
def x():
dithering = False
#% from test_lor3c2
#% 2) down sampling changes SNR
tau_s = 25./1.
std_s = 3.53
tau_n = 12./1.
std_n = 5.55
methid = 0
#%NTA=2.^[4:5];
#%NTA=2.^[4:8,9];
#NTA = np.power(2, np.array(np.hstack((np.arange(4, 7), 8, 10, 12))))
#NTA = np.power(2, np.array([4, 6, 8])) #12
NTA = np.power(2, np.array([4])) #12
nt_generate = np.max(NTA)
b_msec = 7. #3,5,1
fs_Hz = 1000.
siglen_msec = 10000.
#%kerlenratio=5;
siglen_msec = math.floor(siglen_msec / b_msec)* b_msec
#%uses fs_Hz, and then downsamples. The downsampling is not quite correct.
downsample_b = int(b_msec/1000. * fs_Hz + 0.00001)
#print downsample_b #7
assert downsample_b == 7
#%happens to be equal to b, if fs=1000
if False:
r2_raw = makelorresponse(tau_s, std_s, tau_n, std_n, nt_generate, siglen_msec, fs_Hz, [], downsample_b)
else:
#test only
r2_raw=np.random.randn(nt_generate, int((siglen_msec / b_msec))) #temporary
if False:
print r2_raw.shape #1428x256
print nt_generate
print nt_generate
print nt_generate
del nt_generate
siglen_b = (siglen_msec / b_msec)
del siglen_msec
#%M=4;
#%M=8;
#%M=4;
M = 5
#%M=8;
#%M=15;
#%M=3;
[resp_dig, dithinfo1] = discr(r2_raw, M)
#%not dithered
#assert is_any_int_type(r2_raw[0,0])
#r2_raw ois float
[resp_dith, dithinfo2] = dith_unsure(r2_raw, (dithinfo1['centres']))
#%not dithered
resp_dig = resp_dith
#del dithinfo
resp_dig = resp_dig-1
assert is_any_int_type(resp_dig[0,0])
resp_cont = r2_raw
sz=resp_cont.shape
#print sz #1428 * 256
resp_cont=resp_cont.flatten(1)
resp_cont = resp_cont-np.mean(resp_cont.flatten(1))
#%resp_cont=resp_cont/std(resp_cont(:))/2;
#%resp_cont=resp_cont/std(resp_cont(:))/2*1.5*4*4;
#resp_cont = matdiv(np.dot(matdiv(resp_cont, np.std(resp_cont.flatten(1)))/2.*1., M), M-1.)
#resp_cont=resp_cont/std(resp_cont(:))/2*1*M/(M-1);
resp_cont = resp_cont / np.std(resp_cont.flatten()) /2.* M / (M-1.)
#% [-1,+1]
resp_cont = (resp_cont+1.)/2.
#% [0,1]
resp_cont = resp_cont * (M-1.)
if 1:
resp_cont[(resp_cont<0.)] = 0
resp_cont[(resp_cont > M-1.)] = M-1
resp_cont = resp_cont.reshape(sz)
#print "HERE"
#exit(0)
#%clear r2_raw;
#% analytical formula
#%fs_Hz is used for Nyquist frequency
#%ami=analytical_lor(tau_s,std_s, tau_n, std_n, fs_Hz, 0.0001);
#%ami_perbin=mi/fs_Hz*b_msec;
#% %WHY?!
#%a=analytical_lor(tau_s/b_msec,std_s, tau_n/b_msec, std_n, fs_Hz/b_msec, 0.0001);
#%ami_perbin=a / (fs_Hz/b_msec);
#% (tau_s_msec, sigma_s, tau_n_msec, sigma_n, fs_Hz, d_freq)
#%Ia_bits_per_sec
#% Ia_bps --> ami_bps = analytical mi
ami_bps = analytical_lor(tau_s, std_s, tau_n, std_n, (1./b_msec/1000.), 0.0001)
#%ami_perbin=ami_bps* (b_msec/1000);
#% 1/ (fs_Hz/b_msec) = b_msec / fs = above (bcoz, fs=1000)
#% previous: 0.2362
#% new: 2.4512e-04
binlen_sec = b_msec/1000.
#%used later for normalization
#del a
del b_msec
#%clearvars -except resp_cont resp_dig M NTA binlen_sec siglen_b tau_s tau_n ami_bps ...
#% r2_raw std_* methid;
don_plot_this = False
#%size(respcut_dig)
if don_plot_this:
#%%
#%mean(mean(resp_dig,1))
[c, d] = plt.xcorr((matdiv(np.mean(resp_dig, 1.)-1.-(M-1.)/2.+1., M)*2.), 'unbiased')
plt.figure(10.)
plt.clf
#% / sqrt(std_s^2+std_n^2)
h = plt.plot((np.dot(d, binlen_sec)*1000.), matdiv(c, std_s**2.), 'k.-')
set(h, 'linewidth', 2.)
set(h, 'displayname', 'signal')
plt.xlim((np.array(np.hstack((-1., 1.)))*100.*1.))
#%set(gca,'xtick',-200:10:200);
plt.title('\\tau_s, \\tau_n = %g,%g [msec]'%( tau_s, tau_n))
#nn = matcompat.size(resp_dig, 1.)
nn = resp_dig.shape[1-1]
c1 = 0.
for tri in np.arange(1., (nn)+1):
#%mean(resp_dig(tri,:))
#MISSING CODE!!!
[c,d]=np.xcorr((resp_dig[tri,:]-1-(M-1)/2+1)/M*2,'unbiased');
c1=c1+c/nn;
pass
del nn
plt.hold(on)
h = plt.plot((np.dot(d, binlen_sec)*1000.), matdiv(c1, std_n**2.), 'r.-')
set(h, 'linewidth', 2.)
set(h, 'displayname', 'noise')
tt = np.dot(d, binlen_sec)
h = plt.plot((tt*1000.), np.dot(binlen_sec, np.exp(matdiv(-np.abs(tt), tau_s/1000.))), 'k--')
set(h, 'displayname', 'signal analytical')
h = plt.plot((tt*1000.), np.dot(binlen_sec, np.exp(matdiv(-np.abs(tt), tau_n/1000.))), 'r--')
set(h, 'displayname', 'noise analytical')
h = plt.legend('show')
set(h, 'box', 'off')
set(h, 'location', 'NorthWest')
plt.xlabel('Time [msec]')
plt.title('cross correlation')
#% my_save_png('test_lor4f1---signal-xcorr-v12-temp',{},[4,3]);
begintime = time.time()
#tic=time.time()
#%estims=cell(4,4);
#%LARR=[1,4,8,10];
#%LARR=[1,2:2:10];
#%LARR=[1,2:2:8];
#%LARR=[1,2,3,6];
#%LARR=[1,2,3,6,7];
#%LARR=[1]; %
#LARR = np.array(np.hstack((1., 3., 6., 7.)))
#LARR = np.array(np.hstack((1+1, 3, 6, 7)))
#LARR = [1+1, 3, 6, 7]
LARR = [1,1+1, 4]
MAX_L_DIRECT = np.Inf
#estims_cell=[[],[],[],[]]
#estims_cell=[[{}],[{}],[{}],[{}]]
#estims_cell=[[{}]]
estims_cell=[]
#len(NTA)
#print len(LARR),len(NTA), "******************"
for i in range(0,len(LARR)):
estims_cell.append([])
for j in range(0,len(NTA)):
print i,j
estims_cell[i].append({})
#%for nti=10:len(NTA)
for nti in range(1, len(NTA)+1):
nt = int(NTA[int(nti)-1])
for li in range(1, len(LARR)+1):
L = LARR[int(li)-1]
#%lenL=floor(siglen_msec/b_msec/L)*L;
#%lenL=floor(siglen_msec/L/b_msec)*L*b_msec;
lenL = (int((siglen_b/ L)) * L)
#%respcut=resp(:,1:lenL)';
#% respcut=resp(1:nt,1:lenL)';
if dithering:
respcut_cont = resp_cont[0:nt,0:lenL].conj().T
#print "HERE"
#exit(0)
#print nt, max(NTA) #16,256
#print resp_cont.shape #1428x256
#print resp_dig.shape
#print "000"
respcut_dig = resp_dig[0:nt,0:lenL].conj().T
#% len x trials
#%spk0 = zeros(1,LNum,size(signal,1), newlen );
#%spk=reshape(respcut, [1,L,size(resp)]);
#% spk__=reshape(respcut, 1,L,lenL/L,[]);
#%dithering = False
if dithering:
print "Using dithering"
#spk__cont = np.reshape(respcut_cont, 1., L, matdiv(lenL, L), np.array([]))
spk__cont = np.reshape(respcut_cont, [1, L, int(lenL/ L), -1])
#% 1 x L x len x trials
#spk2_cont = permute(spk__cont, np.array(np.hstack((1., 2., 4., 3.))))
spk2_cont = spk__cont.transpose([1-1, 2-1, 4-1, 3-1]) #, np.array(np.hstack((1., 2., 4., 3.))))
assert spk2_cont.shape == (1, L, nt, int(lenL/ L))
#clear(spk__c)
# #%slow
else:
print "Not using dithering"
#% 1 x L x trials x len
#print respcut_dig.shape, "*1" #256 x 16
#print (lenL,L,nt), "*2" #1428.0, 1.0, 16
spk__dig = np.reshape(respcut_dig, [1, L, int(lenL/ L), -1])
spk2_dig = spk__dig.transpose([1-1, 2-1, 4-1, 3-1]) #permute(spk__dig, np.array(np.hstack((1., 2., 4., 3.))))
assert spk2_dig.shape == (1, L, nt, int(lenL/ L))
assert is_any_int_type(spk2_dig[0,0,0,0])
del spk__dig
#%slow
assert type(nt) is int
#nts = np.dot(np.ones(1., matdiv(lenL, L)), nt)
#nts = np.ones([(lenL/ L)]) * nt
nts = np.array([nt]*(lenL/ L), dtype=int) #np.ones([(lenL/ L)]) * nt
#[nt]*int(lenL/ L)
#print nts
#assert type(nts[0]) is int
#print type(nts), type(nts[0])
print 'spk2: %dx%dx%dx%d ['%spk2_dig.shape
if L<=MAX_L_DIRECT:
ns = int(lenL/ L)
#nta = np.arange(1., (ns)+1)*0.+nt
nta = np.array([nt]*ns)
if dithering:
#%[prs3,ps3]=my_prs_dith1(spk2, nta);
#% [prs3_dith,ps3]=my_prs_dith1(spk2_c-1, nta);
#%[prs3_dith,ps3]=my_prs_dith1(spk2_cont-0, nta);
(prs_dith, ps_dith) = my_prs_dith1((spk2_cont-0.), nta)
#% [prs3_dig,ps3]=my_prs(spk1, nta);
#% sum(abs(prs3_dith(:)-prs3_dig(:)))
#% if 0
#% %[prs1,ps1]=my_prs(spk2, nta);
#% [prs1,ps1]=my_prs(spk2_dig, nta);
#% end
(prs_dig, ps_dig) = my_prs(spk2_dig, nta)
#print(repr((prs_dig, ps_dig)))
#%prs=prs3_dith;
#%ps=ps3;
fprintf('p')
hrs0_th = my_hrs(prs_dith, ps_dith, methid)
pr_dith = my_pr(prs_dith, ps_dith)
hr0_th = my_hr(pr_dith, methid)
#%hr1=hr(spk2_dig,nts,methid);
#%hrs1=hrs(spk2_dig,nts,methid);
hrs_dig = my_hrs(prs_dig, ps_dig, methid)
pr_dig = my_pr(prs_dig, ps_dig)
hr_dig = my_hr(pr_dig, methid)
#%[ my_hr(ps_dith, methid),my_hr(ps_dig, methid)]
#%m22= [...
#% my_hr(pr_dith, methid),my_hr(pr_dig, methid);
#% my_hrs(prs_dith,ps_dith, methid),my_hrs(prs_dig,ps_dig, methid)];
#%
vv1 = my_hr(pr_dith, methid)
my_hr(pr_dig, methid)
vv2 = my_hrs(prs_dith, ps_dith, methid)
my_hrs(prs_dig, ps_dig, methid)
m22 = vertcat(vv1, vv2)
#m22
#print li, nti
#%myminmax(spk2_dig(:)) % 1--4
#%myminmax(spk2_cont(:)) % 0--3
#estims.cell[int(li)-1,int(nti)-1]['hr_d'] = hr_dig
estims_cell[int(li)-1][int(nti)-1]['hr_d'] = hr_dig
#%hr1;
estims_cell[int(li)-1][int(nti)-1]['hrs_d'] = hrs_dig
#%hrs1;
estims_cell[int(li)-1][int(nti)-1]['hr_th'] = hr0_th
estims_cell[int(li)-1][int(nti)-1]['hrs_th'] = hrs0_th
#print type(nts), type(nts[0])
hr1_dig = hr(spk2_dig, nts, methid)
hrs1_dig = hrs(spk2_dig, nts, methid)
#print li, nti #1.0, 1.0
#print int(li)-1,int(nti)-1
#print estims_cell[int(li)-1][int(nti)-1]
zz=estims_cell[int(li)-1][int(nti)-1]
zz['hr_d'] = 1
#print hr1_dig
estims_cell[int(li)-1][int(nti)-1]['hr_d'] = hr1_dig
#%hr1;
estims_cell[int(li)-1][int(nti)-1]['hrs_d'] = hrs1_dig
#%hrs1;
if 1:
#print "***********"
#print nts
#%no dithering
estims_cell[int(li)-1][int(nti)-1]['hrs_sh'] = hrs_shuff(spk2_dig, nts, methid)
estims_cell[int(li)-1][int(nti)-1]['hrs_ind'] = hrsind(spk2_dig, nts, methid)
estims_cell[int(li)-1][int(nti)-1]['_xi'] = xi(spk2_dig, nts, methid)
#
else:
estims_cell[int(li)-1][int(nti)-1]['_hr'] = 0.
estims_cell[int(li)-1][int(nti)-1]['_hrs'] = 0.
estims_cell[int(li)-1][int(nti)-1]['hrs_sh'] = 0.
estims_cell[int(li)-1][int(nti)-1]['hrs_ind'] = 0.
estims_cell[int(li)-1][int(nti)-1]['_xi'] = 0.
#%we need: q-model in which , up to q0(=0) is shuffled: model=q, shuffle=0
#%shuffle across:R (not S)
#%if 1
#print "HERE2"
#exit(0)
q = 1
estims_cell[int(li)-1][int(nti)-1]['_hqrs'] = hqrs(spk2_dig, nts, q, methid)
estims_cell[int(li)-1][int(nti)-1]['_hqr'] = hqr(spk2_dig, nts, q, methid)
estims_cell[int(li)-1][int(nti)-1]['_xiq'] = xiq(spk2_dig, nts, q, methid)
#%spk_q=q_shuffle(spk,nts,q);
spk_q = q_shuffle(spk2_dig, nts, q)
#%estims{li,nti}['hrs_q']=hrs(spk_q,nts,methid);
estims_cell[int(li)-1][int(nti)-1]['hrs_q_sh'] = hrs(spk_q, nts, methid)
#%estims{li,nti}.hqrs0=hqrs(spk,nts,q,meth);
#%estims{li,nti}.hrss0=hrs_shuff(spk,nts,meth);
#%estims{li,nti}.spks=q_shuffle(spk,nts,q);
#%estims{li,nti}.hqrss0=hrs(spks,nts,meth);
#%estims{li,nti}.hr0=hr(spk,nts,meth);
#%estims{li,nti}.hqr0=hqr(spk,nts,q,meth);
#%estims{li,nti}.hrs0=hrs(spk,nts,meth);
#%estims{li,nti}.hrsi0=hrsind(spk,nmiu,meth);
#%estims{li,nti}.xiq0=xiq(spk,nmiu,q,meth);
#%estims{li,nti}.xi0=xi(spk,nmiu,meth);
#%end
estims_cell[int(li)-1][int(nti)-1]['L'] = L
estims_cell[int(li)-1][int(nti)-1]['len'] = lenL/ L
estims_cell[int(li)-1][int(nti)-1]['nt'] = nt
print(']'),
#print' (%g sec.)'%(np.floor(toc),)
print('\n')
#%estims{li,nti}
#Takes long up to here. Cleaned up.
#print "HERE"
#exit(0)
#%% -
#%a2d1_th=[];
#a2d1_d = [] #np.array([])
a2d1_d = [] #np.array([])
a2d2_qd = [] #np.array([])
a2d3_dsh = [] #np.array([])
nta1d = [] #np.array([])
for ntj in range(1, nti+1):
a2d1_d.append([])
assert len(a2d1_d)-1 == ntj-1 #assert index number
a2d3_dsh.append([])
assert len(a2d3_dsh)-1 == ntj-1 #assert index number
a2d2_qd.append([])
assert len(a2d2_qd)-1 == ntj-1 #assert index number
#ee=estims_cell[li-1][ntj-1]
#nta1d.append( ee['nt'] )
nta1d.append( estims_cell[0][ntj-1]['nt'] )
assert len(nta1d)-1 == ntj-1
for li in range(1, len(LARR)+1 ):
#%L=LARR(li);
#ee=estims{li,ntj};
print estims_cell #list of list of dict
#print estims_cell.shape
print estims_cell[0][0]
print li,ntj
ee=estims_cell[li-1][ntj-1]
#%if L<=MAX_L_DIRECT
if 'hrs_d' in ee: #haskey(ee, 'hrs_d'):
#% mi1=(ee['_hr']-ee['_hrs'] -ee['hrs_ind'] + ee['hrs_sh'] )/ee['L'];
#%mi1=(ee['hr_th']-ee['hrs_th'] )/ee['L'];
#%mi1=(ee['hr_d']-ee['hrs_d'] -ee['hrs_ind'] + ee['hrs_sh'] )/ee['L'];
#%mi2=(ee['hr_d']-ee['hrs_d'])/ee['L'];
assert not type(ee['hr_d']) is list
#mi1_plugin = matdiv(ee['hr_d']-ee['hrs_d'], ee['L'])
#mi1_sh = matdiv(ee['hr_d']-ee['hrs_d']-ee['hrs_ind']+ee['hrs_sh'], ee['L'])
mi1_plugin = (ee['hr_d']-ee['hrs_d']) / ee['L']
mi1_sh = (ee['hr_d']-ee['hrs_d']-ee['hrs_ind']+ee['hrs_sh']) / ee['L']
else:
mi1_plugin = 0.
#%NaN;
mi1_sh = 0.
print mi1_plugin
#%a2d1_th(ntj,li)=mi1;
#a2d1_d[int(ntj)-1,int(li)-1] = mi1_plugin
a2d1_d[ntj-1].append(mi1_plugin)
assert len(a2d1_d[ntj-1])==li-1+1
#a2d3_dsh[int(ntj)-1,int(li)-1] = mi1_sh
a2d3_dsh[ntj-1].append( mi1_sh )
assert len(a2d3_dsh[ntj-1])==li-1+1
#%mi2=(ee['_xi']-ee['hrs_ind'])/ee['L'];
#%mi2=(ee['_hqr']-ee['_hrs'] -ee['_hqrs'] + ee['hrs_q'] )/ee['L'];
#%mi2=(ee['_xiq']-ee['hrs_q'] +ee['hrs_sh'] - ee['hrs_ind'] )/ee['L']; %DID NOT
#%WORK
#%mi2=(ee['_hqr']-ee['hrs_q'])/ee['L']; %+ee['hrs_sh'] - ee['hrs_ind'] )/ee['L'];
#%slightly biased (uses hrs_q-sh)
#% ************ CHECK THIS *************
#mi2 = matdiv(ee['_xiq']-ee['_hqrs'], ee['L'])
mi2 = (ee['_xiq']-ee['_hqrs']) / ee['L']
#%mi2=(ee['_hqr']-ee['_hqrs'])/ee['L'];
#% ... %+ee['hrs_sh'] - ee['hrs_ind'] )/ee['L'];
#%mi2=(ee['_xi']-ee['hrs_ind'])/ee['L'];
#%mi2=(ee.hr1-ee.hrs1)/ee['L'];
#%mi2=(ee['hr_d']-ee['hrs_d'])/ee['L'];
#a2d2_qd[int(ntj)-1,int(li)-1] = mi2
a2d2_qd[ntj-1].append( mi2 )
assert len(a2d2_qd[ntj-1]) -1 == li-1
#%mi3=(ee['_hqr']-ee['hrs_q'])/ee['L']; %+ee['hrs_sh'] - ee['hrs_ind'] )/ee['L'];
#%mi3=(ee['_xiq']-ee['hrs_q'])/ee['L'];
#nta1d[int(ntj)-1] = ee['nt']
#nta1d.append( ee['nt'] )
#print len(nta1d),ntj
#print nta1d
#assert len(nta1d)-1 == ntj-1
#assert len(nta1d)-1 == ntj-1 ##COMPILE_TIME:CHECK_PATTERN: MATCH LAST_INDEX(nta1d) == ntj-1 #PLANGNOTE
assert nta1d[ntj-1] == ee['nt']
#% end
#%end
if False:
plt.figure(5.)
plt.clf
ax = np.array([])
#%ax(1)=subplot(1,3,1:2);
ax[0] = plt.subplot(2., 3., 1.)
plt.hold(on)
#%box on;
lha = np.array([])
#%h = plot(nta1d,a2d1_th/binlen_sec);
h = plt.plot(nta1d, matdiv(a2d1_d, binlen_sec))
#%if isempty(h)
#% h=plot(0,0,'w.');
#%end
set(h, 'linewidth', 2.)
set(h, 'Displayname', 'L-direct')
#%L-bin
#%set(h,'Displayname','dithered'); %L-bin
#%lha(1)=h(1);
plt.ylabel('Information rate [bits/sec]')
#% set(gca,'xscale','log');
plt.title('direct plug-in')
#%MARKOV
ax[2] = plt.subplot(2., 3., 3.)
h = plt.plot(nta1d, matdiv(a2d2_qd, binlen_sec), '-')
#%if isempty(h)
#% h=plot(0,0,'w.');
#%end
#%plot(nta1d,a2d3,':');
set(h, 'Displayname', 'q-Markov')
#%L-bin
#%set(h,'Displayname','L-direct');
set(h, 'linewidth', 2.)
#%lha(2)=h(1);
#% q=NaN;
#%title('q=1');
#%plot((ee['nt']),mi,'.');
#%text((ee['nt']),mi, sprintf(' L=%d',ee['L']));
#% set(gca,'xscale','log');
#%end
#% end
#%hold on;
#%plot(nta1d, ami_perbin + nta1d*0, 'k:');
#%nta1d+100
#% nta1d_temp=myminmax(nta1d); nta1d_temp(end)=nta1d(end)+100; nta1d_temp(1)=90;
#% h=plot(nta1d_temp, ami_bps + nta1d_temp*0, 'k-.');
#% set(h,'Displayname','analytical');
#%lha(3)=h;
plt.hold(on)
#% plot(nta1d, nta1d*0, 'k:');
#% xlabel('Trials');
#%ylabel('Information [bits/bin]');
#%xlim([10,(max(NTA)+100)*1.1]);
#%xlim([min(NTA)-2,(max(NTA)+100)*1.1]);
plt.title('q-Markov')
lta=[]
for li in np.arange(1., (len(LARR))+1):
#% text(nta1d(1),a2d1_d(1,li)/binlen_sec, sprintf(' L=%d',LARR(li)));
lta[li]=' L=%d'%(LARR(li),);
pass
if False:
lh = plt.legend(lta)
set(lh, 'box', 'off')
set(lh, 'Location', 'SouthWest')
set(lh, 'FontSize', 7.)
#% PANEL 2
#% h=legend(lha,'location','SouthEast'); set(h,'box','off');
ax[1] = plt.subplot(2., 3., 2.)
h = plt.plot(nta1d, matdiv(a2d3_dsh, binlen_sec), '-')
#%if isempty(h)
#% h=plot(0,0,'w.');
#%end
set(h, 'Displayname', 'direct-sh')
#%L-bin
lha[2] = h[0]
#% set(gca,'xscale','log');
set(h, 'linewidth', 2.)
plt.title('direct-sh')
for pani in np.arange(1., 4.0):
set(plt.gcf, 'CurrentAxes', ax[int(pani)-1])
plt.hold(on)
nta1d_temp = myminmax(nta1d)
nta1d_temp[int(0)-1] = nta1d[int(0)-1]+100.
nta1d_temp[0] = 20.
#%90;
#%h=plot(ax(pani),
h = plt.plot(nta1d_temp, (ami_bps+nta1d_temp*0.), 'k--')
set(h, 'Displayname', 'analytical')
set(plt.gca, 'xscale', 'log')
plt.plot(nta1d, (nta1d*0.), 'k:')
plt.xlabel('Trials')
set(plt.gca, 'xtick', np.unique(np.array(np.hstack(((2 ** np.array(np.hstack((5., 7., 9., np.log2(matcompat.max(NTA)))))))))))
plt.ylim(np.array(np.hstack((-50., 100.))))
plt.box(off)
linkaxes(ax, 'y')
linkaxes(ax, 'x')
nta1d_temp = myminmax(nta1d)
nta1d_temp[int(0)-1] = nta1d[int(0)-1]+1000.
nta1d_temp[0] = nta1d_temp[0]-4.
plt.xlim(nta1d_temp)
#%a=[a2d3_dsh(:)/binlen_sec ; a2d1_d(:)/binlen_sec ; a2d2_qd(:)/binlen_sec ];
a = vertcat(matdiv(a2d3_dsh.flatten(1), binlen_sec), matdiv(a2d1_d.flatten(1), binlen_sec), matdiv(a2d2_qd.flatten(1), binlen_sec))
#%ylim(myminmax(a)*1.5);
#%ax(4)=
plt.subplot(2., 3., 4.)
plt.hold(on)
WARR = np.dot(LARR, binlen_sec)*1000.
#%bar(LARR,a2d2_qd(end,:) /binlen_sec);
plt.plot(WARR, matdiv(a2d2_qd[int(0)-1,:], binlen_sec), 'ko-', 'displayname', 'q-Markov')
plt.plot(WARR, matdiv(a2d1_d[int(0)-1,:], binlen_sec), 'r--', 'displayname', 'direct-sh')
LA2 = np.array(np.hstack((WARR, WARR[int(0)-1]+1.)))
h = plt.plot(LA2, (ami_bps+LA2*0.), 'k--')
set(h, 'Displayname', 'analytical')
#%xlabel('L');
plt.xlabel('W [msec]')
lh = plt.legend('show')
set(lh, 'box', 'off')
set(lh, 'Location', 'NorthEast')
#%set(lh,'FontSize',7);
#%linkaxes(ax, 'y')
#%ylabel('Information rate [bits/sec]');
plt.xlim(np.array(np.hstack((0.1, matcompat.max(LA2)+1.))))
plt.ylabel('Information rate [bits/sec]')
title_on_top2(sprintf('q=%d, DITHER, QE=%d, W=%g[ms] \\tau_s,\\tau_n=%g,%g [ms]', q, methid, (1000.*binlen_sec), tau_s, tau_n), 0.)
#%darbareye hichi be ghatiyat nemirese. va in kheili Pernicious, va
#%PErvesaive, va daaem va hart dafe hastesh. bayad MM javab bekhad ta
#%begam.
#%save test_lor4???_all
#% my_save_png('test_lor4f1---dither-v2',{},[7,5]);
time.sleep(0.2)
print("sleep")
finishtime = time.time() #now()
#toc=time.time()
print('.')
print estims_cell
maxc = 0
collect_keys={}
for i in range(0,len(estims_cell)):
for j in range(0,len(estims_cell[i])):
for k in estims_cell[i][j]:
collect_keys[k]=0
if maxc < j+1:
maxc = j+1
print collect_keys.keys()
print
ka={}
for k in collect_keys:
ka[k]=np.zeros((len(estims_cell),maxc))
for i in range(0,len(estims_cell)):
for j in range(0,len(estims_cell[i])):
for k in collect_keys:
ka[k][i,j]=estims_cell[i][j][k]
for k in collect_keys:
print k+":",
print ka[k].T
return
dont_plot_this = False
#%% - plots
if dont_plot_this:
DOUBLEPANEL = 0.
plt.figure(6.)
plt.clf
if DOUBLEPANEL:
plt.subplot(1., 2., 1.)
#plt.hold(on)
#%box on;
styc = 'rgbmkckkk'
for li in np.arange(1., (len(LARR))+1):
lnt = np.array([])
mi = np.array([])
for ntj in np.arange(1., (nti)+1):
ee = estims_cell[int(li)-1,int(ntj)-1]
#%mi(ntj)=(ee['_hr']-ee['_hrs'])/ee['L'];
#%mi(ntj)=(ee['_hr']-ee['_hrs'] -ee['hrs_ind'] + ee['hrs_sh'] )/ee['L'];
#%mi(ntj)=(ee.hr1-ee.hrs1 -ee['hrs_ind'] + ee['hrs_sh'] )/ee['L'];
mi[int(ntj)-1] = matdiv(ee['hr_d']-ee['hrs_d']-ee['hrs_ind']+ee['hrs_sh'], ee['L'])
#%lnt(ntj)=log2(ee['nt']);
lnt[int(ntj)-1] = matdiv(1., ee['nt'])
plt.plot(lnt[int(ntj)-1], mi[int(ntj)-1], np.array(np.hstack((styc[int(li)-1], 'o'))))
plt.text(lnt[int(ntj)-1], mi[int(ntj)-1], sprintf(' L=%d', (ee['L'])))
h = plt.plot(lnt, mi, np.array(np.hstack((styc[int(li)-1], '--'))))
set(h, 'LineWidth', 2.)
h1[int(li)-1] = h
#%set(gca,'xlim',[4,1+log2(max(NTA))]);
ami_perbin = np.dot(ami_bps, binlen_sec)
plt.plot(lnt, (ami_perbin+lnt*0.), 'k--')
plt.xlabel('log_2(trials)')
plt.ylabel('information (bits)')
ylim = plt.get(plt.gca, 'ylim')
#%set(gca,'ylim',[0,ylim(2)]);
#%set(gca,'ylim',[0,0.5]);
plt.title('direct method')
#% legend(h1, cell_sprintf('L=%d',LARR));
#%%
#%prs_dig(1,:)=[];
#%%
plt.figure(4.)
plt.clf
plt.plot(resp_cont[0,:])
#plt.hold(on)
plt.plot((resp_dig[0,:]-0.), 'r')
plt.figure(10.)
plt.clf
mypcolor(prs_dig[0:,199:220.])
plt.title('trunc')
plt.figure(11.)
plt.clf
mypcolor(prs_dith[:,199:220.])
plt.title('dith')
plt.figure(12.)
plt.clf
plt.hist(np.array(np.hstack((prs_dith.flatten(1), prs_dig.flatten(1)))))
#%%
plt.figure(13.)
plt.clf
a = resp_cont[0,:]
b = resp_dig[0,:]-0.
c = r2_raw[0,:]
plt.plot(a, (b+np.dot(plt.randn(matcompat.size(b)), 0.1)), 'k.')
mm = myminmax((c.flatten(1)+np.dot(plt.randn(matcompat.size(a.flatten(1))), 0.01)))
cx = np.arange(mm[0], (mm[1])+(np.diff(mm)/40.), np.diff(mm)/40.)
h1 = histc(c.flatten(1), cx)
h1 = matdiv(h1, np.sum(h1))
#% *mean(diff(cx))
plt.figure(14.)
plt.clf
plt.subplot(1., 2., 1.)
plt.plot(c, (a+np.dot(plt.randn(matcompat.size(a)), 0.05)), 'k.', 'markersize', 1.)
plt.hold(on)
plt.plot(cx, (h1*20.+0.5), 'r')
plt.subplot(1., 2., 2.)
plt.plot(c, (b+np.dot(plt.randn(matcompat.size(a)), 0.05)), 'k.', 'markersize', 1.)
plt.hold(on)
plt.plot(cx, (h1*20.+0.5), 'r')
for i in np.arange(1., 3.0):
plt.subplot(1., 2., i)
for x0 in np.array(np.hstack((-4., 4.))):
plt.plot((x0+np.array(np.hstack((0., 0.)))), np.array(np.hstack((0., M))), 'b--', 'linewidth', 1.)
#% my_save_png('test_lor4e2-v13-meth=1',{},[5,4]);
#%%
#%close all
plt.figure(101.)
plt.clf
plt.plot(pr_dig, 'displayname', 'discrete')
plt.hold(on)
plt.plot(pr_dith, 'r.-', 'displayname', 'dith')
np.array(np.hstack((np.sum(pr_dith), np.sum(pr_dig))))
plt.legend(show)
return estims_cell
def plot_transcripts(tx_start,
transcripts,
graph_coords,
reverse_minus,
font_size,
show_gene=False,
distance_ratio=0.3):
"""
[original description]
draw the gene structure.
[now]
due to i changed the mrna class, therefore, this function need be modified
:param tx_start: the very start of this plot
:param graph_coords: numpy array, convert the coord of genome to the coord in this plot
:param reverse_minus:
:param transcripts: list of Transcript
:param font_size: the font size of transcript label
:param show_gene: Boolean value to decide whether to show gene id in this plot
:param distance_ratio: distance between transcript label and transcript line
"""
y_loc = 0
exon_width = .3
"""
@2018.12.26
Maybe I'm too stupid for this, using 30% of total length of x axis as the gap between text with axis
"""
distance = distance_ratio * (max(graph_coords) - min(graph_coords))
# @2018.12.19
# @2018.12.21
# the API of SpliceRegion has changed, the transcripts here should be sorted
for transcript in transcripts:
# narrows = math.floor(narrows * (transcript.length / len(graphcoords)))
# @2018.12.20 add transcript id, based on fixed coordinates
if show_gene:
pylab.text(x=-1 * distance,
y=y_loc + 0.15,
s=transcript.gene,
fontsize=font_size)
pylab.text(x=-1 * distance,
y=y_loc - 0.25,
s=transcript.transcript,
fontsize=font_size)
else:
pylab.text(x=-1 * distance,
y=y_loc - 0.1,
s=transcript.transcript,
fontsize=font_size)
strand = "+"
# @2018.12.19
# s and e is the start and end site of single exon
for exon in transcript.exons:
s, e, strand = exon.start, exon.end, exon.strand
s = s - tx_start
e = e - tx_start
x = [
graph_coords[s], graph_coords[e], graph_coords[e],
graph_coords[s]
]
y = [
y_loc - exon_width / 2, y_loc - exon_width / 2,
y_loc + exon_width / 2, y_loc + exon_width / 2
]
pylab.fill(x, y, 'k', lw=.5, zorder=20)
# @2018.12.21
# change the intron range
# Draw intron.
intron_sites = [
graph_coords[transcript.start - tx_start],
graph_coords[transcript.end - tx_start]
]
pylab.plot(intron_sites, [y_loc, y_loc], color='k', lw=0.5)
# @2018.12.23 fix intron arrows issues
# Draw intron arrows.
max_ = graph_coords[transcript.end - tx_start]
min_ = graph_coords[transcript.start - tx_start]
length = max_ - min_
narrows = math.ceil(length / max(graph_coords) * 50)
spread = .2 * length / narrows
for i in range(narrows):
loc = float(i) * length / narrows + graph_coords[transcript.start -
tx_start]
if strand == '+' or reverse_minus:
x = [loc - spread, loc, loc - spread]
else:
x = [loc + spread, loc, loc + spread]
y = [y_loc - exon_width / 5, y_loc, y_loc + exon_width / 5]
pylab.plot(x, y, lw=.5, color='k')
y_loc += 1
pylab.xlim(0, max(graph_coords))
pylab.ylim(-.5, len(transcripts) + .5)
pylab.box(on=False)
pylab.xticks([])
pylab.yticks([])
# Define synapse filter (i.e. which filters by roi, type, confidence)
ellipsoid_synapses = synapse_criteria = SC(rois='EB', primary_only=True)
'''i.e. get only synapses are found in the ellipsoid body (EB)'''
# Get synapses (from neuron)
synapses = fetch_synapses(fanshapedNeurons, ellipsoid_synapses)
# Plot the synapse positions in a 2D projection
fig, ax = plt.subplots(1, 1)
fig.set_figwidth(7)
fig.set_figheight(8)
ax.scatter(synapses['x'], synapses['z'], s=3)
ax.invert_yaxis()
plt.grid()
plt.box(False)
plt.show()
# ------------------------------------------
# Synapse connections
# ------------------------------------------
''' Fetch all synapse-synapse connections from a set of neurons. Provide a NeuronCriteria for the source
or target neurons (or both) to filter the neurons of interest, and optionally filter the synapses themselves
via SynapseCriteria
'''
ellipsoid_conns = fetch_synapse_connections(
source_criteria=fanshapedNeurons,
target_criteria=None,
synapse_criteria=ellipsoid_synapses)
# ellipsoid_conns.head()
def draw_barchart(Time):
df_frame = (df[df["date"].eq(Time)].sort_values(
by="counts", ascending=True).tail(num_of_elements))
ax.clear()
normal_colors = dict(
zip(df["country"].unique(), rgb_colors_opacity))
dark_colors = dict(zip(df["country"].unique(),
rgb_colors_dark))
ax.barh(
df_frame["country"],
df_frame["counts"],
color=[normal_colors[x] for x in df_frame["country"]],
height=0.8,
edgecolor=([dark_colors[x] for x in df_frame["country"]]),
linewidth="6",
)
dx = float(df_frame["counts"].max()) / 200
for i, (value, name) in enumerate(
zip(df_frame["counts"], df_frame["country"])):
ax.text(
value + dx,
i + (num_of_elements / 50),
" " + name,
size=14,
weight="bold",
ha="left",
va="center",
fontdict={"fontname": "Trebuchet MS"},
)
ax.text(
value + dx * 10,
i - (num_of_elements / 50),
f" {value:,.0f}",
size=14,
ha="left",
va="center",
)
time_unit_displayed = re.sub(r"\^(.*)", r"", str(Time))
ax.text(
1.0,
1.14,
time_unit_displayed,
transform=ax.transAxes,
color="#666666",
size=14,
ha="right",
weight="bold",
fontdict={"fontname": "Trebuchet MS"},
)
# ax.text(-0.005, 1.06, 'Number of confirmed cases', transform=ax.transAxes, size=14, color='#666666')
ax.text(
-0.005,
1.14,
"Number of {} cases ".format(field),
transform=ax.transAxes,
size=14,
weight="bold",
ha="left",
fontdict={"fontname": "Trebuchet MS"},
)
ax.xaxis.set_major_formatter(
ticker.StrMethodFormatter("{x:,.0f}"))
ax.xaxis.set_ticks_position("top")
ax.tick_params(axis="x", colors="#666666", labelsize=12)
ax.set_yticks([])
ax.set_axisbelow(True)
ax.margins(0, 0.01)
ax.grid(which="major", axis="x", linestyle="-")
plt.locator_params(axis="x", nbins=4)
plt.box(False)
plt.subplots_adjust(
left=0.075,
right=0.75,
top=0.825,
bottom=0.05,
wspace=0.2,
hspace=0.2,
)
def heatmap(x, y, tfs=12, bkg_color='#F1F1F1', separate_first=0, **kwargs):
""" Calculate a heatmap
Based on: https://towardsdatascience.com/better-heatmaps-and-correlation-matrix-plots-in-python-41445d0f2bec
"""
if 'color' in kwargs:
color = kwargs['color']
else:
color = [1] * len(x)
if 'palette' in kwargs:
palette = kwargs['palette']
n_colors = len(palette)
else:
n_colors = 256 # Use 256 colors for the diverging color palette
palette = sns.diverging_palette(
359, 122, s=90, n=500) #sns.color_palette("BrBG", n_colors)
if 'color_range' in kwargs:
color_min, color_max = kwargs['color_range']
else:
color_min, color_max = min(color), max(
color
) # Range of values that will be mapped to the palette, i.e. min and max possible correlation
def value_to_color(val):
if color_min == color_max:
return palette[-1]
else:
val_position = float((val - color_min)) / (
color_max - color_min
) # position of value in the input range, relative to the length of the input range
val_position = min(max(val_position, 0),
1) # bound the position betwen 0 and 1
ind = int(val_position *
(n_colors - 1)) # target index in the color palette
return palette[ind]
if 'size' in kwargs:
size = kwargs['size']
else:
size = [1] * len(x)
if 'size_range' in kwargs:
size_min, size_max = kwargs['size_range'][0], kwargs['size_range'][1]
else:
size_min, size_max = min(size), max(size)
size_scale = kwargs.get('size_scale', 500)
def value_to_size(val):
if size_min == size_max:
return 1 * size_scale
else:
val_position = (val - size_min) * 0.99 / (
size_max - size_min
) + 0.01 # position of value in the input range, relative to the length of the input range
val_position = min(max(val_position, 0),
1) # bound the position betwen 0 and 1
return val_position * size_scale
if 'x_order' in kwargs:
x_names = [t for t in kwargs['x_order']]
else:
x_names = [t for t in sorted(set([v for v in x]))]
x_to_num = {p[1]: p[0] for p in enumerate(x_names)}
if 'y_order' in kwargs:
y_names = [t for t in kwargs['y_order']]
else:
y_names = [t for t in sorted(set([v for v in y]))]
y_to_num = {p[1]: p[0] for p in enumerate(y_names)}
plot_grid = plt.GridSpec(1, 30, hspace=0.2,
wspace=0.1) # Setup a 1x10 grid
ax = plt.subplot(plot_grid[:, :-1]
) # Use the left 14/15ths of the grid for the main plot
marker = kwargs.get('marker', 's')
kwargs_pass_on = {
k: v
for k, v in kwargs.items() if k not in [
'color', 'palette', 'color_range', 'size', 'size_range',
'size_scale', 'marker', 'x_order', 'y_order'
]
}
ax.scatter(x=[x_to_num[v] for v in x],
y=[y_to_num[v] for v in y],
marker=marker,
s=[value_to_size(v) for v in size],
c=[value_to_color(v) for v in color],
**kwargs_pass_on)
ax.set_xticks([v for k, v in x_to_num.items()])
ax.set_xticklabels([k for k in x_to_num],
rotation=45,
horizontalalignment='right',
fontsize=tfs)
ax.set_yticks([v for k, v in y_to_num.items()])
ax.set_yticklabels([k for k in y_to_num], fontsize=tfs)
ax.grid(False, 'major')
ax.grid(True, 'minor')
ax.set_xticks([t + 0.5 for t in ax.get_xticks()], minor=True)
ax.set_yticks([t + 0.5 for t in ax.get_yticks()], minor=True)
ax.set_xlim([-0.5, max([v for v in x_to_num.values()]) + 0.5])
ax.set_ylim([-0.5, max([v for v in y_to_num.values()]) + 0.5])
ax.set_facecolor(bkg_color)
if separate_first:
l = np.sqrt(len(x))
plt.axvline(separate_first - .5, color='gray')
plt.axhline(l - .5 - separate_first, color='gray')
# Add color legend on the right side of the plot
if color_min < color_max:
ax = plt.subplot(plot_grid[:,
-1]) # Use the rightmost column of the plot
#ax.axis('off')
plt.box(on=None)
col_x = [0] * len(palette) # Fixed x coordinate for the bars
bar_y = np.linspace(
color_min, color_max,
n_colors) # y coordinates for each of the n_colors bars
bar_height = bar_y[1] - bar_y[0]
print(bar_height)
ax.barh(
y=bar_y,
width=[15] * len(palette), # Make bars 5 units wide
left=col_x, # Make bars start at 0
height=bar_height,
color=palette,
linewidth=0)
ax.set_ylim(-2, 2)
ax.set_xlim(
0, 5
) # Bars are going from 0 to 5, so lets crop the plot somewhere in the middle
ax.grid(False) # Hide grid
ax.set_facecolor('white') # Make background white
ax.set_xticks([]) # Remove horizontal ticks
ax.set_yticks(
np.linspace(min(bar_y), max(bar_y),
3)) # Show vertical ticks for min, middle and max
ax.yaxis.tick_right() # Show vertical ticks on the right
plt.sca(plt.subplot(plot_grid[:, :-1]))
#%% Synopsis of GAN hessian consistency
fig, ax = plt.subplots()
plt.errorbar(GAN_geom_summary.lin_corr_mean,
GAN_geom_summary.log_corr_mean,
yerr=GAN_geom_summary.log_corr_std,
xerr=GAN_geom_summary.lin_corr_std,
fmt='o')
plt.xlim([0, 1])
for i, GAN in enumerate(GAN_geom_summary.index):
ax.annotate(
GAN,
(GAN_geom_summary.lin_corr_mean[i], GAN_geom_summary.log_corr_mean[i]),
fontsize=12)
plt.ylabel("log scale corr")
plt.xlabel("lin scale corr")
plt.box(True)
plt.savefig(join(summarydir, "Hess_corrmat_synopsis.png"))
plt.savefig(join(summarydir, "Hess_corrmat_synopsis.pdf"))
plt.show()
#%% Plot an Example of Hessian consistency
BGHpath = "E:\Cluster_Backup\BigGANH"
eigval_col, eigvec_col, feat_col, meta = scan_hess_npz(BGHpath,
"Hess_cls(\d*).npz",
evakey='eigvals',
evckey='eigvects',
featkey='vect')
#%%
figdir = join(summarydir, "BigGAN")
plot_consistency_example(eigval_col,
eigvec_col,
def plot_correlation(self, other_interface, lines=False, bounds=None):
""" Plot this interface's view on the underlying product vs
another interface's view.
Each vulnerability will be represented as a point, with the x coordinate
representing the likelihood that this interface will discover the
vulnerability in the next round, and the y coordinate representing
the likelihood that the other interface will discover it this round.
This plot is helpful for understanding the discovery correlation that
arises with learning.
Parameters
----------
other_interface: Interface object
The interface object must be built upon the same underlying 'product'
as the present interface
lines: True/False
If true, will overlay horizontal and vertical lines representing the
mean discovery profile for each actor, and label them with the mean
value.
bounds: None or float
If float will set the x and y limits to this value.
TODO
----
It might be a good idea to make the bounds an x/y tuple if we want to
initialize the interfaces with different `max_area` values.
"""
plt.plot(self.circles.area,
other_interface.circles.area,
'.',
alpha=.1)
if bounds == None:
window_size = max(self.circles.area.max(),
other_interface.circles.area.max())
else:
window_size = bounds
if lines:
y_mean = np.mean(other_interface.circles.area)
x_mean = np.mean(self.circles.area)
plt.hlines(y_mean, 0, window_size)
plt.text(window_size,
y_mean,
'mean=%f' % y_mean,
ha='right',
va='bottom')
plt.vlines(x_mean, 0, window_size)
plt.text(x_mean,
window_size,
'mean=%f' % x_mean,
rotation=90,
ha='right',
va='top')
plt.xlim(0, window_size)
plt.ylim(0, window_size)
plt.box('off')
plt.xlabel(self.name + ' likelihood of discovery', fontsize=14)
plt.ylabel(other_interface.name + ' likelihood of discovery',
fontsize=14)
