Ejemplo n.º 1
0
 def merge(self):
     A_m, C_m, nr_m, merged_ROIs, P_m = mergeROIS(self.Y_res,
                                                  self.A.tocsc(),
                                                  self.b,
                                                  np.array(self.C),
                                                  self.f,
                                                  self.Y.shape[0],
                                                  self.Y.shape[1],
                                                  self.Pnew,
                                                  sn=self.P['sn'])
Ejemplo n.º 2
0
#%% nmf

Y_res = Yr - np.dot(Ain,Cin)
model = ProjectedGradientNMF(n_components=1, init='random', random_state=0)
model.fit(np.maximum(Y_res,0)) 

fin = model.components_.squeeze()

#%% update spatial components

t1 = time()
A,b = update_spatial_components(Yr, Cin, fin, Ain, d1=d1, d2=d2, sn = P['sn'])
t_elSPATIAL = time() - t1

#%% 
t1 = time()
C,f,Y_res,Pnew = update_temporal_components(Yr,A,b,Cin,fin,ITER=2)
t_elTEMPORAL1 = time() - t1

#%%  solving using spgl1 for deconvolution
t1 = time()
C2,f2,Y_res2,Pnew2 = update_temporal_components(Yr,A,b,Cin,fin,ITER=2,deconv_method = 'spgl1')
t_elTEMPORAL2 = time() - t1


#%%
t1 = time()
A_m,C_m,nr_m,merged_ROIs,P_m=mergeROIS(Y_res,A.tocsc(),b,np.array(C2),f2,d1,d2,Pnew2,sn=P['sn'],deconv_method = 'spgl1')
t_elMERGE = time() - t1
 def merge(self):
     A_m,C_m,nr_m,merged_ROIs,P_m=mergeROIS(self.Y_res,self.A.tocsc(),self.b,np.array(self.C),self.f,self.Y.shape[0],self.Y.shape[1],self.Pnew,sn=self.P['sn'])
fin = model.components_.squeeze()
#%%
t1 = time()
A,b,Cin = update_spatial_components(Yr, Cin, fin, Ain, d1=d1, d2=d2, sn = P['sn'],dist=2,max_size=8,min_size=3)
t_elSPATIAL = time() - t1
#%%
crd = plot_contours(A,Cn2,thr=0.9,cmap=pl.cm.gray)
#%%
t1 = time()
C,f,Y_res,Pnew = update_temporal_components(Yr,A,b,Cin,fin,ITER=2,deconv_method = 'spgl1')
t_elTEMPORAL2 = time() - t1
#%%
t1 = time()
A_sp=A.tocsc();
A_m,C_m,nr_m,merged_ROIs,P_m=mergeROIS(Y_res,A_sp,b,np.array(C),f,d1,d2,Pnew,sn=P['sn'],thr=.7,deconv_method='spgl1',min_size=3,max_size=8,dist=2)
t_elMERGE = time() - t1
#%%
crd = plot_contours(A_m,Cn2,thr=0.9)
#%%
A2,b2,C_m_ = update_spatial_components(Yr, C_m, f, A_m, d1=d1, d2=d2, sn = P['sn'],dist=3,max_size=8,min_size=3)
C2,f2,Y_res2,Pnew2 = update_temporal_components(Yr,A2,b2,C_m_,f,ITER=2,deconv_method = 'spgl1')
#%%
crd = plot_contours(A2,Cn2,thr=0.9,cmap=pl.cm.gray)

#%%


A_or, C_or, srt = order_components(A2,C2)
C_df = extract_DF_F(Yr,A2,C2)
crd = plot_contours(coo_matrix(A_or[:,::-1]),Cn,thr=0.9)
Ejemplo n.º 5
0
#%%
t1 = time()
C, f, Y_res, Pnew = update_temporal_components(Yr, A, b, Cin, fin, ITER=2)
t_elTEMPORAL1 = time() - t1

#%%  solving using spgl1 for deconvolution
t1 = time()
C2, f2, Y_res2, Pnew2 = update_temporal_components(Yr,
                                                   A,
                                                   b,
                                                   Cin,
                                                   fin,
                                                   ITER=2,
                                                   deconv_method='spgl1')
t_elTEMPORAL2 = time() - t1

#%%
t1 = time()
A_m, C_m, nr_m, merged_ROIs, P_m = mergeROIS(Y_res,
                                             A.tocsc(),
                                             b,
                                             np.array(C2),
                                             f2,
                                             d1,
                                             d2,
                                             Pnew2,
                                             sn=P['sn'],
                                             deconv_method='spgl1')
t_elMERGE = time() - t1
Ejemplo n.º 6
0
C2,f2,Y_res_temp2,P_temp2 = update_temporal_components(Yr,A,b,Cin,fin,ITER=2,method='constrained_foopsi',deconv_method = 'spgl1', g='None')
t_elTEMPORAL2 = time() - t1
#%% compare with matlab
demo_results= sio.loadmat('demo_results.mat', struct_as_record=False, squeeze_me=True)
C_m=demo_results['C']*1.0
f_m=demo_results['f']*1.0
P_temp_m=demo_results['P_temp']
Y_res_temp_m=demo_results['Y_res_temp']*1.0

C_cor=np.squeeze(np.array([np.array(ca-pt['b']) for pt,ca in zip(P_temp,C)]))
C_cor_m=np.squeeze(np.array([(ca-P_temp_m.b[idx]) if np.size(P_temp_m.b[idx])>0 else ca for idx,ca in enumerate(C)]))

print np.sum(np.abs(C_cor-C_cor_m))/np.sum(np.abs(C)) # should give 0.087370193480
print np.sum(np.abs(f-f_m))/np.sum(np.abs(f)) # should give  0.0038846142374
print np.sum(np.abs(Y_res_temp-Y_res_temp_m))/np.sum(np.abs(Y_res_temp)) # 0.065985398437
pl.plot(np.sum(np.abs(C_cor-C_cor_m),axis=1))
#%%
#demo_results= sio.loadmat('demo_results.mat', struct_as_record=False, squeeze_me=True)
#Y_res_temp=demo_results['Y_res_temp']*1.0
#A=demo_results['A']*1.0
#b=np.expand_dims(demo_results['b']*1.0,axis=1)
#C=demo_results['C']*1.0
#f=demo_results['f']*1.0
##P_temp=demo_results['P_temp']


#%%
t1 = time()
Am,Cm,nrm,merged_ROIs,Pm=mergeROIS(Y_res_temp,A.tocsc(),b,np.array(C),f,d1,d2,P_temp,sn=P['sn'])
t_elMERGE = time() - t1
print t_elMERGE
#Cin=demo_['C_in'];
#g=demo_['g']
#sn=demo_['sn']
#d1=demo_['d1']
#d2=demo_['d2']
#P=demo_['P

#%%
P_=np.load('after_temporal.npz')['arr_3']
thr=0.8
mx=50
d1=P.d1
d2=P.d2
sn=P.sn
#%%
A_m,C_m,nr_m,merged_ROIs,P_m=mergeROIS(Y_res,A,b,C,f,d1,d2,P_,sn=sn)
#%%
#efty_params_after = sio.loadmat('workspace_after_merge.mat',struct_as_record=False) # load as structure matlab like
#A_ef=efty_params_after['Am']*1.0
#C_ef=efty_params_after['Cm']*1.0
#merged_ROIs_ef=efty_params_after['merged_ROIs']*1.0
#P_new_ef=efty_params_after['P'][0,0]
##%%
#np.sum(np.abs(A_m-A_ef).todense())/np.sum(np.abs(A_m).todense())
#np.sum(np.abs(C_m-C_ef))/np.sum(np.abs(C_m))
##%%
#display_merging=1;
#for roi in merged_ROIs:
#
#    ln = len(roi)
#    pl.figure()
A,b = update_spatial_components(Yr, Cin, fin, Ain, d1=d1, d2=d2, sn = P['sn'])
t_elSPATIAL = time() - t1

#%% 
#t1 = time()
#C,f,Y_res,Pnew = update_temporal_components(Yr,A,b,Cin,fin,ITER=2)
#t_elTEMPORAL1 = time() - t1

#%%  solving using spgl1 for deconvolution (necessary files not in repo yet)
t1 = time()
C,f,Y_res,Pnew = update_temporal_components(Yr,A,b,Cin,fin,ITER=2,deconv_method = 'spgl1')
t_elTEMPORAL2 = time() - t1

#%%
t1 = time()
A_m,C_m,nr_m,merged_ROIs,P_m=mergeROIS(Y_res,A.tocsc(),b,np.array(C),f,d1,d2,Pnew,sn=P['sn'])
t_elMERGE = time() - t1

#%%
A2,b2 = update_spatial_components(Yr, C_m, f, A_m, d1=d1, d2=d2, sn = P['sn'])
C2,f2,Y_res2,Pnew2 = update_temporal_components(Yr,A2,b2,C_m,f,ITER=2,deconv_method = 'spgl1')

#%% order components

A_or, C_or, srt = order_components(A2,C2)
C_df = extract_DF_F(Yr,A2,C2)

#%% plot ordered components

view_patches(Yr,coo_matrix(A_or),C_or,b,f,d1,d2)
#%%