def estim_diff(input_sig, input_seg_len, output_sig, output_seg_len, nperseg, num_of_seg, nperseg_step): """The difference between estimators in both directions. inputs: seg_num: number of segments to divide the music piece into. In practice we always divide the music to seg_num+1 segments ignoring to last segment. nperseg: initial Welch method window size """ res = np.empty(num_of_seg) for i in range(num_of_seg): # converting int16 wav file to a float signal and cutting the signal to # pieces of size seg_len. Also selecting the mono signal temp_input_sig = pcm2float( input_sig[input_seg_len * i:input_seg_len * (i + 1)], 'float32')[:, 0] temp_output_sig = pcm2float( output_sig[output_seg_len * i:output_seg_len * (i + 1)], 'float32')[:, 0] t = time() S_inp = welch(temp_input_sig, nperseg=nperseg * nperseg_step)[1] S_out = welch(temp_output_sig, nperseg=nperseg * nperseg_step)[1] res[i] = delta_estimator_3(S_out / S_inp, S_inp) - delta_estimator_3( S_inp / S_out, S_out) #out=float2pcm(output_sig,'int16') return res
def SIC_method(X,Y,order=100): #low-passing to take LFP only #h_for=AR_fit(X,Y,order) #y_new=signal.fftconvolve(h_for,X) #h_back=AR_fit(Y,X,order) #x_new=signal.fftconvolve(h_back,Y) #Sx=welch(x_new,nperseg=1000)[1] #Sy=welch(y_new,nperseg=1000)[1] Sy=welch(Y,nperseg=1000)[1] Sx=welch(X,nperseg=1000)[1] X_Y=delta_estimator_3(Sy/Sx,Sx) Y_X=delta_estimator_3(Sx/Sy,Sy) #mask1=Sy!=0 #mask2=Sx[mask1]!=0 #X_Y=eval('delta_estimator_'+str(method_no))(Sy[mask1][mask2][1:-1]/Sx[mask1][mask2][1:-1],Sx[mask1][mask2][1:-1]) #Y_X=eval('delta_estimator_'+str(method_no))(Sx[mask1][mask2][1:-1]/Sy[mask1][mask2][1:-1],Sy[mask1][mask2][1:-1]) #X_Y=eval('delta_estimator_'+str(method_no))(Sy[mask1][mask2][1:-1]/Sx[mask1][mask2][1:-1],Sx[mask1][mask2][1:-1]) #Y_X=eval('delta_estimator_'+str(method_no))(Sx[mask1][mask2][1:-1]/Sy[mask1][mask2][1:-1],Sy[mask1][mask2][1:-1]) #X_Y=np.var(y_new)/float(np.sum(h_for**2)*np.var(X)) #Y_X=np.var(x_new)/float(np.sum(h_back**2)*np.var(Y)) return X_Y,Y_X
def SIC_method(X, Y, method_no, order=200): #low-passing to take LFP only h_for = AR_fit(X, Y, order) y_new = signal.fftconvolve(h_for, X) h_back = AR_fit(Y, X, order) x_new = signal.fftconvolve(h_back, Y) Sx = welch(x_new, nperseg=500)[1] Sy = welch(y_new, nperseg=500)[1] #Sy=welch(Y,nperseg=500)[1] #Sx=welch(X,nperseg=500)[1] mask1 = Sy != 0 mask2 = Sx[mask1] != 0 #plt.plot(Sx) #plt.show() X_Y = eval('delta_estimator_' + str(method_no))(Sy[mask1][mask2][1:-1] / Sx[mask1][mask2][1:-1], Sx[mask1][mask2][1:-1]) Y_X = eval('delta_estimator_' + str(method_no))(Sx[mask1][mask2][1:-1] / Sy[mask1][mask2][1:-1], Sy[mask1][mask2][1:-1]) #return abs(X_Y)<abs(Y_X) return X_Y, Y_X
def estim_diff(input_sig, input_seg_len, output_sig, output_seg_len, nperseg, num_of_seg, nperseg_step): """The difference between estimators in both directions. inputs: seg_num: number of segments to divide the music piece into. In practice we always divide the music to seg_num+1 segments ignoring to last segment. nperseg: initial Welch method window size """ res=np.empty(num_of_seg) for i in range(num_of_seg): # converting int16 wav file to a float signal and cutting the signal to # pieces of size seg_len. Also selecting the mono signal temp_input_sig=pcm2float(input_sig[input_seg_len*i:input_seg_len*(i+1)],'float32')[:,0] temp_output_sig=pcm2float(output_sig[output_seg_len*i:output_seg_len*(i+1)],'float32')[:,0] t=time() S_inp=welch(temp_input_sig,nperseg=nperseg*nperseg_step)[1] S_out=welch(temp_output_sig,nperseg=nperseg*nperseg_step)[1] res[i]=delta_estimator_3(S_out/S_inp,S_inp)-delta_estimator_3(S_inp/S_out,S_out) #out=float2pcm(output_sig,'int16') return res
def SIC_method(X, Y, order=100): #low-passing to take LFP only #h_for=AR_fit(X,Y,order) #y_new=signal.fftconvolve(h_for,X) #h_back=AR_fit(Y,X,order) #x_new=signal.fftconvolve(h_back,Y) #Sx=welch(x_new,nperseg=1000)[1] #Sy=welch(y_new,nperseg=1000)[1] Sy = welch(Y, nperseg=1000)[1] Sx = welch(X, nperseg=1000)[1] X_Y = delta_estimator_3(Sy / Sx, Sx) Y_X = delta_estimator_3(Sx / Sy, Sy) #mask1=Sy!=0 #mask2=Sx[mask1]!=0 #X_Y=eval('delta_estimator_'+str(method_no))(Sy[mask1][mask2][1:-1]/Sx[mask1][mask2][1:-1],Sx[mask1][mask2][1:-1]) #Y_X=eval('delta_estimator_'+str(method_no))(Sx[mask1][mask2][1:-1]/Sy[mask1][mask2][1:-1],Sy[mask1][mask2][1:-1]) #X_Y=eval('delta_estimator_'+str(method_no))(Sy[mask1][mask2][1:-1]/Sx[mask1][mask2][1:-1],Sx[mask1][mask2][1:-1]) #Y_X=eval('delta_estimator_'+str(method_no))(Sx[mask1][mask2][1:-1]/Sy[mask1][mask2][1:-1],Sy[mask1][mask2][1:-1]) #X_Y=np.var(y_new)/float(np.sum(h_for**2)*np.var(X)) #Y_X=np.var(x_new)/float(np.sum(h_back**2)*np.var(Y)) return X_Y, Y_X
def SIC(X,Y): Sx=welch(X,nperseg=500)[1] Sy=welch(Y,nperseg=500)[1] Delta_X_Y=np.sum(Sy)/(np.sum(Sx)*np.sum(Sy/Sx)) Delta_Y_X=np.sum(Sx)/(np.sum(Sy)*np.sum(Sx/Sy)) if Delta_X_Y>Delta_Y_X: print "X_t causes Y_t" else: print "Y_t causes X_t"
def SIC_method(X,Y,method_no,order=200): #low-passing to take LFP only h_for=AR_fit(X,Y,order) y_new=signal.fftconvolve(h_for,X) h_back=AR_fit(Y,X,order) x_new=signal.fftconvolve(h_back,Y) Sx=welch(x_new,nperseg=500)[1] Sy=welch(y_new,nperseg=500)[1] #Sy=welch(Y,nperseg=500)[1] #Sx=welch(X,nperseg=500)[1] mask1=Sy!=0 mask2=Sx[mask1]!=0 #plt.plot(Sx) #plt.show() X_Y=eval('delta_estimator_'+str(method_no))(Sy[mask1][mask2][1:-1]/Sx[mask1][mask2][1:-1],Sx[mask1][mask2][1:-1]) Y_X=eval('delta_estimator_'+str(method_no))(Sx[mask1][mask2][1:-1]/Sy[mask1][mask2][1:-1],Sy[mask1][mask2][1:-1]) #return abs(X_Y)<abs(Y_X) return X_Y,Y_X
def linear_filter_SIC(FO=5, BO=5, ksim_size=1000, x_size=10000, AR_amp_upperbound=0.1, noise_amp=0.1, in_noise=False, out_noise=False, denoise=False, win_length=500): """ The main function for generating a toy model consisting of two linear filters. The input of the first filter is white noise and the output of it is feeded to the second filter as X_t (the cause). The output of the second filter in turn is considered to be Y_t. The coefficients of the filters are also i.i.d gaussian variables. The function finally returns the SDRs in both directions for a number of trials specified by ksim_size. The linear filters are defined according scipy IIR filters: scipy.signal.lfilter(b, a, x, axis=-1, zi=None) (**) (See "http://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.lfilter.html" for more info on IIR filters) input: FO: int: Forward order of IIR filter(length of b in (**)) BO: int: Backward order of IIR filter(length of a in (**)) ksim_size: int: the number of trials of these toy model x_size: int: the length of the input white noise to the first filter AR_amp_upperbound: float: a coefficient to control the largness of the feedback coefficients (to maitain BIBO stability) noise_amp: float: the amplitude of noise (standard deviation of the white additive noise) in_noise: boolean: whether there is input additive noise out_noise: boolean: whether there is output additive noise denoise: boolean: whether we denoise the observations by fitting an autoregressive filter in both directions (presummably the real model!) output: Dir numpy ndarray.float64: stored values of SDR for both directions for different trials and also the variances of X_t and Y_t """ #initializing Dir matrix Dir = np.empty((ksim_size, 2, 2)) #looping for different trials for ksim in xrange(ksim_size): #setting the initial coefficients of filter assuming that the first element of coefficients of filters in both directions is 1 (for symmetry) A_ = np.random.randn(FO) * AR_amp_upperbound A = np.hstack((np.ones(1), -A_)) B_ = np.random.randn(FO) * AR_amp_upperbound B = np.hstack((np.ones(1), -B_)) E_ = np.random.randn(BO - 1) * AR_amp_upperbound F_ = np.random.randn(BO - 1) * AR_amp_upperbound E = np.hstack((np.ones(1), -E_)) F = np.hstack((np.ones(1), -F_)) #re-setting the coefficients in case either of the two filters are not BIBO stable while np.any(np.abs(np.roots(E)) >= 0.99) or np.any( np.abs(np.roots(A)) >= 0.99): A_ = np.random.randn(FO) * AR_amp_upperbound A = np.hstack((np.ones(1), -A_)) E_ = np.random.randn(BO - 1) * AR_amp_upperbound E = np.hstack((np.ones(1), -E_)) while np.any(np.abs(np.roots(F)) > 0.99) or np.any( np.abs(np.roots(B)) >= 0.99): B_ = np.random.randn(FO) * AR_amp_upperbound B = np.hstack((np.ones(1), -B_)) F_ = np.random.randn(BO - 1) * AR_amp_upperbound F = np.hstack((np.ones(1), -F_)) # printing the final selected coefficients print("A:", A) print("B:", B) # generating the cause, X_t (here x) and the effect, Y_t (here y) x = signal.lfilter(A, E, np.random.randn(x_size)) y = signal.lfilter(B, F, x) # storing total variances of cause and effect time series Dir[ksim, 0, 0] = np.var(x) Dir[ksim, 1, 1] = np.var(y) # adding noise if out_noise: y += np.random.randn(x_size) * noise_amp if in_noise: x += np.random.randn(x_size) * noise_amp # denoising if necessarily if denoise: order = 20 #the AR order h_for = AR_fit(x, y, order) y_new = signal.fftconvolve(h_for, x) h_back = AR_fit(y, x, order) x_new = signal.fftconvolve(h_back, y) Dir[ksim, 0, 1] = np.var(y_new) / float(np.sum(h_for**2) * np.var(x)) Dir[ksim, 1, 0] = np.var(x_new) / float(np.sum(h_back**2) * np.var(y)) else: Sy = welch(y, nperseg=win_length)[1] Sx = welch(x, nperseg=win_length)[1] Dir[ksim, 0, 1] = SDR_estimator(Sy / Sx, Sx) Dir[ksim, 1, 0] = SDR_estimator(Sx / Sy, Sy) return Dir
def linear_filter_decreasing_impulse(FO=5, BO=5, ksim_size=1000, x_size=10000, AR_amp_upperbound=0.1, noise_amp=0.1, in_noise=False, out_noise=False, denoise=False): """linear_filter_SIC() rewritten where the coefficients of IR functions are picked in a way that their absolute value decreases by the increase of time. For the definitions of arguments or the description of the logic of the code, see the body of linear_filter_SIC().""" Dir = np.empty((ksim_size, 2, 2)) for ksim in xrange(ksim_size): A_ = np.random.randn(FO) * AR_amp_upperbound A_idx = abs(A_).argsort()[::-1] A = A_[A_idx] B_ = np.random.randn(FO) * AR_amp_upperbound B_idx = abs(B_).argsort()[::-1] B = B_[B_idx] E_ = np.random.randn(BO - 1) * AR_amp_upperbound F_ = np.random.randn(BO - 1) * AR_amp_upperbound E_idx = abs(E_).argsort()[::-1] F_idx = abs(F_).argsort()[::-1] E = np.hstack((np.ones(1), E_[E_idx])) F = np.hstack((np.ones(1), F_[F_idx])) while np.any(np.abs(np.roots(E)) >= 0.98) or np.any( np.abs(np.roots(A)) >= 0.98): A_ = np.random.randn(FO) * AR_amp_upperbound A_idx = abs(A_).argsort()[::-1] A = A_[A_idx] E_ = np.random.randn(BO - 1) * AR_amp_upperbound E_idx = abs(E_).argsort()[::-1] E = np.hstack((np.ones(1), E_[E_idx])) while np.any(np.abs(np.roots(F)) > 0.98) or np.any( np.abs(np.roots(B)) >= 0.98): B_ = np.random.randn(FO) * AR_amp_upperbound B_idx = abs(B_).argsort()[::-1] B = B_[B_idx] F_ = np.random.randn(BO - 1) * AR_amp_upperbound F_idx = abs(F_).argsort()[::-1] F = np.hstack((np.ones(1), F_[F_idx])) print("A:", A) print("B:", B) x = signal.lfilter(A, E, np.random.randn(x_size)) y = signal.lfilter(B, F, x) Dir[ksim, 0, 0] = np.var(x) Dir[ksim, 1, 1] = np.var(y) if out_noise: y += np.random.randn(x_size) * noise_amp if in_noise: x += np.random.randn(x_size) * noise_amp if denoise: order = 100 h_for = AR_fit(x, y, order) y_new = signal.fftconvolve(h_for, x) h_back = AR_fit(y, x, order) x_new = signal.fftconvolve(h_back, y) Dir[ksim, 0, 1] = np.var(y_new) / float(np.sum(h_for**2) * np.var(x)) Dir[ksim, 1, 0] = np.var(x_new) / float(np.sum(h_back**2) * np.var(y)) else: Sy = welch(y, nperseg=1000)[1] Sx = welch(x, nperseg=1000)[1] Dir[ksim, 0, 1] = SDR_estimator(Sy / Sx, Sx) Dir[ksim, 1, 0] = SDR_estimator(Sx / Sy, Sy) return Dir