信号分帧的方法对比

1. 背景

　　当一段时域信号很长时，一般咱们须要将一长段信号切成一小段一小段的信号进行处理，好比 短时傅里叶变换stft或小波wavelet变换等等。

　　一般，为了信号的平滑过渡，N个一小段信号中 ， 前一个小段信号与后一个小段信号之间存在着一段重合的部分，咱们叫作overlap。

　　在前一段随笔（如何将声学的spectrogram（声谱图）从新反变换成时域语音信号 ）中，咱们也遇到过这种分帧形式。

 

 

 

 

 

2. 实现方法 (python代码为主)

　　不管哪一种方法，首先咱们要获取一个概况：

　　假设咱们有一个信号 sigData, 数据总长为sigLen，咱们每一帧的数据个数为blkSize, 重合的百分比为 Overlap

　　stepSize : 那么每次咱们向前移动的数据个数stepSize 为 int( blkSize*(1-Overlap) ) ,且必须大于1。

　　frameNumSize: 一共会分为的数据块个数 frameNumSize : frameNumSize = 1+ floor ( (Length(sigData) - blkSize) / stepSize )

 

　　2.1 循环取数的方法

#%% method 1
import numpy as np
def cut_to_sigBlks_test1(sigData,blkSize,Overlap):
 
    if Overlap > 1:
        Overlap = Overlap/100
        
    # 1.获取其实idx的step ，因为overlap 存在 ，stepSize 小于等于blkSize
    sigLen = np.size(sigData)
    stepSize = int( np.floor(blkSize*(1-Overlap)) )
    
    if stepSize < 1:
        stepSize =int(1)
        
    frameNumSize = int( ((sigLen-blkSize)//stepSize) +1)  # 得到一共有多少个 片断
   
    # 2.3 循环得到数据
    sigBlks = np.zeros((frameNumSize,blkSize),dtype= sigData.dtype)for i in np.arange(frameNumSize):
        sigBlks[i,:] = sigData[i*stepSize:i*stepSize+blkSize]
    return sigBlks

#%% Test
sigData = np.arange(20)
blkSize = 7
Overlap = 0.3
sigBlks = cut_to_sigBlks_test1(sigData,blkSize,Overlap)

print('sigData: \n',sigData)
print('sigBlks: \n',sigBlks)

　　显示结果为：

　　sigData:
　　[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
　　sigBlks:
　　[[ 0   1  2   3    4   5    6]
　　 [ 4   5  6   7    8   9   10]
　　 [ 8   9  10 11  12 13 14]
　　 [12 13 14 15 16 17 18 ] ]

 

　　2.2 引索取数方法

　　

#%% method 2
import numpy as np
def cut_to_sigBlks_test2(sigData,blkSize,Overlap):
 
    if Overlap > 1:
        return print('overlap need less than 1')
        Overlap = Overlap/100
        
    # 1.获取其实idx的step ，因为overlap 存在 ，stepSize 小于等于blkSize
    sigLen = np.size(sigData)
    stepSize = int( np.floor(blkSize*(1-Overlap)) )
    
    if stepSize < 1:
        stepSize =int(1)
        
    frameNumSize = int( ((sigLen-blkSize)//stepSize) +1)  # 得到一共有多少个 片断
   
    # 2.2 method 2 得到idxArray, [向量化方法]
    
    # 生成 引索数组， 大小为 row nums = frameNumSize, col nums = blocksize 
    # 生成开始引索序列，间隔为 stepSize ，考虑上 overlap 
    startIdxArry = np.arange(0,stepSize*frameNumSize,stepSize)  
    # 生成信号分块的引索数组，按行分块
    idxArray = np.tile(np.r_[0:blkSize],(frameNumSize,1)) + startIdxArry[:,np.newaxis] 
    sigBlks = sigData[idxArray]
    return sigBlks
#%% Test

sigData = np.arange(20)
sigData.astype(np.float64)
blkSize = 7
Overlap = 0.3
# sigBlks = cut_to_sigBlks_test1(sigData,blkSize,Overlap)
sigBlks = cut_to_sigBlks_test2(sigData,blkSize,Overlap)

print('sigData: \n',sigData)
print('sigBlks: \n',sigBlks)

　　显示结果为：

　　sigData:
　　[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
　　sigBlks:
　　[[ 0   1  2   3    4   5    6]
　　 [ 4   5  6   7    8   9   10]
　　 [ 8   9  10 11  12 13 14]
　　 [12 13 14 15 16 17 18 ] ]

 

　　2.3 使用python 中 as_strides 方法，至关于引索，不过是numpy内置的引索函数，不过要求必须是内存中连续存放的一段数据。 stride至关于上文中的step

 　　

#%% method 3
import numpy as np
def cut_to_sigBlks_test3(sigData,blkSize,Overlap,axis=0):
 
    if Overlap > 1:
        return print('overlap need less than 1')
        Overlap = Overlap/100
        
    # 1.获取其实idx的step ，因为overlap 存在 ，stepSize 小于等于blkSize
    sigLen = np.size(sigData)
    stepSize = int( np.floor(blkSize*(1-Overlap)) )
    
    if stepSize < 1:
        stepSize =int(1)
        
    frameNumSize = int( ((sigLen-blkSize)//stepSize) +1)  # 得到一共有多少个 片断
   
    # 2.2 method 3 得到idxArray, [向量化方法]
    sigData = np.ascontiguousarray(sigData) # 将x转化为连续内存存储

    strides = np.asarray(sigData.strides)
    new_stride = np.prod(strides[strides > 0] // sigData.itemsize) * sigData.itemsize
    axis=0 # 切分数据 按行存储
    if axis == -1:
        shape = list(sigData.shape)[:-1] + [blkSize, frameNumSize]
        strides = list(strides) + [stepSize * new_stride]
    elif axis == 0:
        shape = [frameNumSize, blkSize] + list(sigData.shape)[1:]
        strides = [stepSize * new_stride] + list(strides) 
    else:
       print('error')

    sigBlks = np.lib.stride_tricks.as_strided(sigData, shape=shape, strides=strides)

    return sigBlks

#%% Test

sigData = np.arange(20)
sigData.astype(np.float64)
blkSize = 7
Overlap = 0.3
# sigBlks = cut_to_sigBlks_test1(sigData,blkSize,Overlap)
# sigBlks = cut_to_sigBlks_test2(sigData,blkSize,Overlap)
sigBlks = cut_to_sigBlks_test3(sigData,blkSize,Overlap)
print('sigData: \n',sigData)
print('sigBlks: \n',sigBlks)

　　显示结果为：

　　sigData:
　　[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
　　sigBlks:
　　[[ 0   1  2   3    4   5    6]
　　 [ 4   5  6   7    8   9   10]
　　 [ 8   9  10 11  12 13 14]
　　 [12 13 14 15 16 17 18 ] ]

 

3.比较这3中运算的时间效率

　　这三种方法中，无疑越日后方法越好，第一种是方便理解的循环思惟，第二种是向量化思惟，第三种也是向量化思惟同时运用了一个numpy库的as_stride性质

　　第三种的运算时间比较短

　　建立一个1000000个数据点，每1024个点分帧，overlap = 0.3。每种方法循环1000次，用的时间分别为：

#%% Test cost time
import time as time
sigData = np.arange(1000000)
sigData = np.array(sigData,dtype='float64')
blkSize = 1024
Overlap = 0.3

st= time.time()
for i in np.arange(100):
    sigBlks1 = cut_to_sigBlks_test1(sigData,blkSize,Overlap)
et= time.time()
print('cut_to_sigBlks_test1:',et-st)


st= time.time()
for i in np.arange(100):
    sigBlks2 = cut_to_sigBlks_test2(sigData,blkSize,Overlap)
et= time.time()
print('cut_to_sigBlks_test2:',et-st)

st= time.time()
for i in np.arange(100):
    sigBlks3 = cut_to_sigBlks_test3(sigData,blkSize,Overlap)
et= time.time()
print('cut_to_sigBlks_test3:',et-st)

 

cut_to_sigBlks_test1: 1.0691425800323486
cut_to_sigBlks_test2: 1.8650140762329102
cut_to_sigBlks_test3: 0.003989458084106445

可见耗时 为 method 3 < method 1 < method 2

原本觉得第一种比第二种方法耗时间长，实验出乎意料啊。不过第二种写法更优美，哈哈！