我们从Python开源项目中，提取了以下49个代码示例，用于说明如何使用numpy.hamming()。
def phormants(x, Fs): N = len(x) w = numpy.hamming(N) # Apply window and high pass filter. x1 = x * w x1 = lfilter([1], [1., 0.63], x1) # Get LPC. ncoeff = 2 + Fs / 1000 A, e, k = lpc(x1, ncoeff) #A, e, k = lpc(x1, 8) # Get roots. rts = numpy.roots(A) rts = [r for r in rts if numpy.imag(r) >= 0] # Get angles. angz = numpy.arctan2(numpy.imag(rts), numpy.real(rts)) # Get frequencies. frqs = sorted(angz * (Fs / (2 * math.pi))) return frqs
def hamming(M): """Returns the Hamming window. The Hamming window is defined as .. math:: w(n) = 0.54 - 0.46\\cos\\left(\\frac{2\\pi{n}}{M-1}\\right) \\qquad 0 \\leq n \\leq M-1 Args: M (:class:`~int`): Number of points in the output window. If zero or less, an empty array is returned. Returns: ~cupy.ndarray: Output ndarray. .. seealso:: :func:`numpy.hamming` """ if M < 1: return from_data.array([]) if M == 1: return basic.ones(1, float) n = ranges.arange(0, M) return 0.54 - 0.46 * trigonometric.cos(2.0 * numpy.pi * n / (M - 1))
def cochleagram_extractor(xx, sr, win_len, shift_len, channel_number, win_type): fcoefs, f = make_erb_filters(sr, channel_number, 50) fcoefs = np.flipud(fcoefs) xf = erb_frilter_bank(xx, fcoefs) if win_type == 'hanning': window = np.hanning(channel_number) elif win_type == 'hamming': window = np.hamming(channel_number) elif win_type == 'triangle': window = (1 - (np.abs(channel_number - 1 - 2 * np.arange(1, channel_number + 1, 1)) / (channel_number + 1))) else: window = np.ones(channel_number) window = window.reshape((channel_number, 1)) xe = np.power(xf, 2.0) frames = 1 + ((np.size(xe, 1)-win_len) // shift_len) cochleagram = np.zeros((channel_number, frames)) for i in range(frames): one_frame = np.multiply(xe[:, i*shift_len:i*shift_len+win_len], np.repeat(window, win_len, 1)) cochleagram[:, i] = np.sqrt(np.mean(one_frame, 1)) cochleagram = np.where(cochleagram == 0.0, np.finfo(float).eps, cochleagram) return cochleagram
def log_power_spectrum_extractor(x, win_len, shift_len, win_type, is_log=False): samples = x.shape[0] frames = (samples - win_len) // shift_len stft = np.zeros((win_len, frames), dtype=np.complex64) spect = np.zeros((win_len // 2 + 1, frames), dtype=np.float64) if win_type == 'hanning': window = np.hanning(win_len) elif win_type == 'hamming': window = np.hamming(win_len) elif win_type == 'rectangle': window = np.ones(win_len) for i in range(frames): one_frame = x[i*shift_len: i*shift_len+win_len] windowed_frame = np.multiply(one_frame, window) stft[:, i] = np.fft.fft(windowed_frame, win_len) if is_log: spect[:, i] = np.log(np.power(np.abs(stft[0: win_len//2+1, i]), 2.)) else: spect[:, i] = np.power(np.abs(stft[0: win_len//2+1, i]), 2.) return spect
def stft_extractor(x, win_len, shift_len, win_type): samples = x.shape[0] frames = (samples - win_len) // shift_len stft = np.zeros((win_len, frames), dtype=np.complex64) spect = np.zeros((win_len // 2 + 1, frames), dtype=np.complex64) if win_type == 'hanning': window = np.hanning(win_len) elif win_type == 'hamming': window = np.hamming(win_len) elif win_type == 'rectangle': window = np.ones(win_len) for i in range(frames): one_frame = x[i*shift_len: i*shift_len+win_len] windowed_frame = np.multiply(one_frame, window) stft[:, i] = np.fft.fft(windowed_frame, win_len) spect[:, i] = stft[: win_len//2+1, i] return spect
def rasta_plp_extractor(x, sr, plp_order=0, do_rasta=True): spec = log_power_spectrum_extractor(x, int(sr*0.02), int(sr*0.01), 'hamming', False) bark_filters = int(np.ceil(freq2bark(sr//2))) wts = get_fft_bark_mat(sr, int(sr*0.02), bark_filters) bark_spec = np.matmul(wts, spec) if do_rasta: bark_spec = np.where(bark_spec == 0.0, np.finfo(float).eps, bark_spec) log_bark_spec = np.log(bark_spec) rasta_log_bark_spec = rasta_filt(log_bark_spec) bark_spec = np.exp(rasta_log_bark_spec) post_spec = postaud(bark_spec, sr/2.) if plp_order > 0: lpcas = do_lpc(post_spec, plp_order) else: lpcas = post_spec return lpcas
def spectrum_extractor(x, win_len, shift_len, win_type, is_log): samples = x.shape[0] frames = (samples - win_len) // shift_len stft = np.zeros((win_len, frames), dtype=np.complex64) spectrum = np.zeros((win_len // 2 + 1, frames), dtype=np.float64) if win_type == 'hanning': window = np.hanning(win_len) elif win_type == 'hamming': window = np.hamming(win_len) elif win_type == 'triangle': window = (1 - (np.abs(win_len - 1 - 2 * np.arange(1, win_len + 1, 1)) / (win_len + 1))) else: window = np.ones(win_len) for i in range(frames): one_frame = x[i*shift_len: i*shift_len+win_len] windowed_frame = np.multiply(one_frame, window) stft[:, i] = np.fft.fft(windowed_frame, win_len) if is_log: spectrum[:, i] = np.log(np.abs(stft[0: win_len//2+1, i])) else: spectrum[:, i] = np.abs(stft[0: win_len // 2 + 1:, i]) return spectrum
def smooth(s,lengthscale,parallel=True): """smoothes s vertically""" if len(s.shape) == 1: s=s[...,None] nChans = s.shape[1] lengthscale=2*round(float(lengthscale)/2) W = np.hamming(min(lengthscale,s.shape[0])) W/= np.sum(W) if s.shape[1]>1: if parallel: njobs=JOBLIB_NCORES else: njobs=1 slidingMean = (Parallel(n_jobs=njobs,backend=JOBLIB_BACKEND,temp_folder=JOBLIB_TEMPFOLDER) (delayed(smoothLine)(s[:,chan],W) for chan in range(nChans))) return np.array(slidingMean).T else: return smoothLine(s[:,0],W)[...,None]
def __init__(self, sampling_rate=16000, frame_width=0.032, frame_shift=0.01, num_mel_filters=40, window_func="hanning", using_delta=True, using_delta_delta=True): assert window_func in ["hanning", "hamming"] self.sampling_rate = sampling_rate self.frame_width = frame_width self.sampling_rate = sampling_rate self.frame_width = frame_width self.frame_shift = frame_shift self.num_fft = int(sampling_rate * frame_width) self.num_mel_filters = num_mel_filters if window_func == "hanning": self.window_func = lambda x:np.hanning(x) elif winfunc == "hamming": self.window_func = lambda x:np.hamming(x) self.using_delta = using_delta self.using_delta_delta = using_delta_delta self.fbank = fft.get_filterbanks(nfft=self.num_fft, nfilt=num_mel_filters, samplerate=sampling_rate)
def Specgram(X, W, H): """A function to compute the spectrogram of a signal :parm X: N x 1 Audio Signal :param W: Window Size :param H HopSize :returns: S, an N x NBins spectrogram array """ Q = W/H if Q - np.floor(Q) > 0: print('Warning: Window size is not integer multiple of hop size\n') win = np.hamming(W) NWin = int(np.floor((len(X) - W)/float(H)) + 1) S = np.zeros((NWin, W)) for i in range(NWin): x = X[i*H:i*H+W] S[i, :] = np.abs(np.fft.fft(win*x)) #Second half of the spectrum is redundant for real signals if W % 2 == 0: #Even Case S = S[:, 0:W/2] else: #Odd Case S = S[:, 0:(W-1)/2+1] return S
def _mfcc_and_labels(audio, labels): """ Convert to MFCC features and corresponding (interpolated) labels. Returns: A tuple, `(mfcc_features, mfcc_labels)`. A 1-D float array and a 1-D int array, both with the same shape. """ mfcc_sample_rate = 100.0 winfunc = lambda x: np.hamming(x) mfcc_features = python_speech_features.mfcc(audio, samplerate=timit.SAMPLE_RATE, winlen=0.025, winstep=1.0/mfcc_sample_rate, lowfreq=85.0, highfreq=timit.SAMPLE_RATE/2, winfunc=winfunc) t_audio = np.linspace(0.0, audio.shape[0] * 1.0 / timit.SAMPLE_RATE, audio.size, endpoint=False) t_mfcc = np.linspace(0.0, mfcc_features.shape[0] * 1.0 / mfcc_sample_rate, mfcc_features.shape[0], endpoint=False) interp_func = scipy.interpolate.interp1d(t_audio, labels, kind='nearest') mfcc_labels = interp_func(t_mfcc) return mfcc_features, mfcc_labels
def make_spectrogram(self, seg_length, window_func=np.hamming): """Computes the spectrogram of the wave. seg_length: number of samples in each segment window_func: function used to compute the window returns: Spectrogram """ n = len(self.ys) window = window_func(seg_length) start, end, step = 0, seg_length, seg_length / 2 spec_map = {} while end < n: ys = self.ys[start:end] * window hs = np.fft.rfft(ys) t = (start + end) / 2.0 / self.framerate spec_map[t] = Spectrum(hs, self.framerate) start += step end += step return Spectrogram(spec_map, seg_length, window_func)
def discontinuity(num_periods=30, hamming=False): """Plots the spectrum of a sinusoid with/without windowing. num_periods: how many periods to compute hamming: boolean whether to apply Hamming window """ signal = thinkdsp.SinSignal(freq=440) duration = signal.period * num_periods wave = signal.make_wave(duration) if hamming: wave.hamming() print(len(wave.ys), wave.ys[0], wave.ys[-1]) spectrum = wave.make_spectrum() spectrum.plot(high=60)
def three_spectrums(): """Makes a plot showing three spectrums for a sinusoid. """ thinkplot.preplot(rows=1, cols=3) pyplot.subplots_adjust(wspace=0.3, hspace=0.4, right=0.95, left=0.1, top=0.95, bottom=0.05) xticks = range(0, 900, 200) thinkplot.subplot(1) thinkplot.config(xticks=xticks) discontinuity(num_periods=30, hamming=False) thinkplot.subplot(2) thinkplot.config(xticks=xticks) discontinuity(num_periods=30.25, hamming=False) thinkplot.subplot(3) thinkplot.config(xticks=xticks) discontinuity(num_periods=30.25, hamming=True) thinkplot.save(root='windowing1')
def _smooth(params, win, type="HAMMING"): win = int(win+0.5) if win >= len(params)-1: win = len(params)-1 if win % 2 == 0: win+=1 s = np.r_[params[win-1:0:-1],params,params[-1:-win:-1]] if type=="HAMMING": w = np.hamming(win) third = int(win/5) #w[:third] = 0 else: w = np.ones(win) y = np.convolve(w/w.sum(),s,mode='valid') return y[(win/2):-(win/2)]
def __init__(self, master, input_connect=None): Component.__init__(self, master, input_connect) self.master = master self.progeny = [] self.dur_since_last_birth = 0 self.curr_period = default.CURR_GEN_PERIOD self.curr_dur = default.CURR_GRAIN_LEN self.curr_lag = default.CURR_GEN_LAG self.curr_period_jitter = default.CURR_GEN_PERIOD_JITTER self.curr_dur_jitter = default.CURR_GRAIN_LEN_JITTER self.curr_lag_jitter = default.CURR_LAG_JITTER def generate_envelope(length): """ Generates hamming windowing function. """ envelope = list(np.hamming(length)) return(envelope) self.envelope_generator = generate_envelope
def iFFT(Y, output_length=None, window=False): """ Inverse real-valued Fourier Transform Parameters ---------- Y : array_like Frequency domain data [Nsignals x Nbins] output_length : int, optional Lenght of returned time-domain signal (Default: 2 x len(Y) + 1) win : boolean, optional Weights the resulting time-domain signal with a Hann Returns ------- y : array_like Reconstructed time-domain signal """ Y = _np.atleast_2d(Y) y = _np.fft.irfft(Y, n=output_length) if window: if window not in {'hann', 'hamming', 'blackman', 'kaiser'}: raise ValueError('Selected window must be one of hann, hamming, blackman or kaiser') no_of_signals, no_of_samples = y.shape if window == 'hann': window_array = _np.hanning(no_of_samples) elif window == 'hamming': window_array = _np.hamming(no_of_samples) elif window == 'blackman': window_array = _np.blackman(no_of_samples) elif window == 'kaiser': window_array = _np.kaiser(no_of_samples, 3) y = window_array * y return y
def synthesis_speech(noisy_speech, ideal_mask, win_type, win_len, shift_len, syn_method='A&R'): samples = noisy_speech.shape[0] frames = (samples - win_len) // shift_len if win_type == 'hanning': window = np.hanning(win_len) elif win_type == 'hamming': window = np.hamming(win_len) elif win_type == 'rectangle': window = np.ones(win_len) to_ifft = np.zeros(win_len, dtype=np.complex64) clean_speech = np.zeros((frames-1)*shift_len+win_len, dtype=np.float32) window_sum = np.zeros((frames-1)*shift_len+win_len, dtype=np.float32) for i in range(frames): one_frame = noisy_speech[i * shift_len: i * shift_len + win_len] windowed_frame = np.multiply(one_frame, window) stft = np.fft.fft(windowed_frame, win_len) masked_abs = np.abs(stft[:win_len//2+1]) * ideal_mask[:, i] to_ifft[:win_len//2+1] = masked_abs * np.exp(1j * np.angle(stft[:win_len//2+1])) to_ifft[win_len//2+1:] = np.conj(to_ifft[win_len//2-1:0:-1]) speech_seg = np.real(np.fft.ifft(to_ifft, win_len)) if syn_method == 'A&R' or syn_method == 'ALLEN & RABINER': clean_speech[i*shift_len:i*shift_len+win_len] += speech_seg window_sum[i*shift_len:i*shift_len+win_len] += window elif syn_method == 'G&L' or syn_method == 'GRIFFIN & LIM': speech_seg = np.multiply(speech_seg, window) clean_speech[i * shift_len:i * shift_len + win_len] += speech_seg window_sum[i * shift_len:i * shift_len + win_len] += np.power(window, 2.) # if i > 0: # clean_speech[i*shift_len: (i-1)*shift_len+win_len] *= 0.5 window_sum = np.where(window_sum < 1e-2, 1e-2, window_sum) return clean_speech / window_sum
def synthesis_speech(ns, mk, win_type, win_len, shift_len, syn_method='A&R'): samples = ns.shape[0] frames = (samples - win_len) // shift_len if win_type == 'hanning': window = np.hanning(win_len) elif win_type == 'hamming': window = np.hamming(win_len) elif win_type == 'rectangle': window = np.ones(win_len) to_ifft = np.zeros(win_len, dtype=np.complex64) clean_speech = np.zeros((frames-1)*shift_len+win_len, dtype=np.float32) window_sum = np.zeros((frames-1)*shift_len+win_len, dtype=np.float32) for i in range(frames): one_frame = ns[i * shift_len: i * shift_len + win_len] windowed_frame = np.multiply(one_frame, window) stft = np.fft.fft(windowed_frame, win_len) masked_abs = np.abs(stft[:win_len//2+1]) * mk[:, i] to_ifft[:win_len//2+1] = masked_abs * np.exp(1j * np.angle(stft[:win_len//2+1])) to_ifft[win_len//2+1:] = np.conj(to_ifft[win_len//2-1:0:-1]) speech_seg = np.real(np.fft.ifft(to_ifft, 320)) if syn_method == 'A&R' or syn_method == 'ALLEN & RABINER': clean_speech[i*shift_len:i*shift_len+win_len] += speech_seg window_sum[i*shift_len:i*shift_len+win_len] += window elif syn_method == 'G&L' or syn_method == 'GRIFFIN & LIM': speech_seg = np.multiply(speech_seg, window) clean_speech[i * shift_len:i * shift_len + win_len] += speech_seg window_sum[i * shift_len:i * shift_len + win_len] += np.power(window, 2.) # if i > 0: # clean_speech[i*shift_len: (i-1)*shift_len+win_len] *= 0.5 window_sum = np.where(window_sum < 1e-2, 1e-2, window_sum) return clean_speech / window_sum
def fir1(n, wn): # Variables definition : nbands = len(wn) + 1 ff = np.array((0, wn[0], wn[0], wn[1], wn[1], 1)) f0 = np.mean(ff[2:4]) l = n + 1 mags = np.array(range(nbands)) % 2 aa = np.ravel(np.matlib.repmat(mags, 2, 1), order='F') # Get filter coefficients : h = firls(l - 1, ff, aa) # Apply a window to coefficients : wind = np.hamming(l) b = np.matrix(h.T * wind) c = np.matrix(np.exp(-1j * 2 * np.pi * (f0 / 2) * np.array(range(l)))) b = b / abs(c * b.T) return np.squeeze(np.array(b)), 1
def fir1(N, Wn): # Variables definition : nbands = len(Wn) + 1 ff = np.array((0, Wn[0], Wn[0], Wn[1], Wn[1], 1)) f0 = np.mean(ff[2:4]) L = N + 1 mags = np.array(range(nbands)) % 2 aa = np.ravel(repmat(mags, 2, 1), order='F') # Get filter coefficients : h = firls(L - 1, ff, aa) # Apply a window to coefficients : Wind = np.hamming(L) b = np.matrix(h.T * Wind) c = np.matrix(np.exp(-1j * 2 * np.pi * (f0 / 2) * np.array(range(L)))) b = b / abs(c * b.T) return np.ndarray.squeeze(np.array(b)), 1 #################################################################### # - Filt the signal : ####################################################################
def __init__(self, sample_rate, frame_length): ''' Initialize MFCC Calculator. @param sample_rate: audio sample rate @param input_size: length of magnitude spectrum (half of FFT size assumed) ''' self.sample_rate = sample_rate self.nyquist = sample_rate / 2.0 self.min_hz = 0 self.max_hz = self.nyquist self.input_size = frame_length / 2 self.num_bands = 40 self.window = np.hamming(frame_length) self.filter_matrix = None return
def __init__(self, samplerate, framelen): ''' Initialize perceptual loudness using samplerate and framelength ''' self.framelen = framelen self.window = np.hamming(framelen) self.filter = np.zeros(framelen / 2) for i in xrange(framelen / 2): self.filter[i] = self.__weightA(float(i * samplerate) / framelen) return
def __init__(self, path, time_wnd = 25, time_off = 10): wave_src = wave.open(path, "rb") para_src = wave_src.getparams() self.rate = int(para_src[2]) self.cur_size = 0 self.tot_size = int(para_src[3]) # default 400 160 self.wnd_size = int(self.rate * 0.001 * time_wnd) self.wnd_rate = int(self.rate * 0.001 * time_off) self.ham = np.hamming(self.wnd_size+1) self.ham = np.sqrt(self.ham[0:self.wnd_size]) self.ham = self.ham / np.sqrt(np.sum(np.square(self.ham[range(0,self.wnd_size, self.wnd_rate)]))) self.data = np.fromstring(wave_src.readframes(wave_src.getnframes()), dtype=np.int16) self.upper_bound = np.max(np.abs(self.data))
def getFFT(data,rate): """Given some data and rate, returns FFTfreq and FFT (half).""" data=data*np.hamming(len(data)) fft=np.fft.fft(data) fft=np.abs(fft) #fft=10*np.log10(fft) freq=np.fft.fftfreq(len(fft),1.0/rate) return freq[:int(len(freq)/2)],fft[:int(len(fft)/2)]
def smooth(x,window_len=11,window='hanning'): if x.ndim != 1: raise ValueError, "smooth only accepts 1 dimension arrays." if x.size < window_len: return x # raise ValueError, "Input vector needs to be bigger than window size." if window_len<3: return x if not window in ['flat', 'hanning', 'hamming', 'bartlett', 'blackman']: raise ValueError, "Window is one of 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'" s=numpy.r_[x[window_len-1:0:-1],x,x[-1:-window_len:-1]] if window == 'flat': #moving average w=numpy.ones(window_len,'d') else: w=eval('numpy.'+window+'(window_len)') y=numpy.convolve(w/w.sum(),s,mode='valid') y = y[(window_len/2-1) : -(window_len/2)-1] return y
def smooth(values, window): oavg = numpy.mean(abs(values)) #weights = numpy.repeat(1.0, window)/window weights = numpy.hamming(window) sma = numpy.convolve(values, weights, 'valid') sma = sma[0:len(values)] navg = numpy.mean(abs(sma)) sma = sma * (oavg / navg) return sma
def hamming(self): """Apply a Hamming window to the wave. """ self.ys *= np.hamming(len(self.ys))
def window_plot(): """Makes a plot showing a sinusoid, hamming window, and their product. """ signal = thinkdsp.SinSignal(freq=440) duration = signal.period * 10.25 wave1 = signal.make_wave(duration) wave2 = signal.make_wave(duration) ys = numpy.hamming(len(wave1.ys)) window = thinkdsp.Wave(ys, wave1.framerate) wave2.hamming() thinkplot.preplot(rows=3, cols=1) pyplot.subplots_adjust(wspace=0.3, hspace=0.3, right=0.95, left=0.1, top=0.95, bottom=0.05) thinkplot.subplot(1) wave1.plot() thinkplot.config(axis=[0, duration, -1.07, 1.07]) thinkplot.subplot(2) window.plot() thinkplot.config(axis=[0, duration, -1.07, 1.07]) thinkplot.subplot(3) wave2.plot() thinkplot.config(axis=[0, duration, -1.07, 1.07], xlabel='time (s)') thinkplot.save(root='windowing2')
def standard_specgram(signal): "Return specgram matrix, made using the audio-layer config" return np.array(specgram(signal, NFFT=audioframe_len, noverlap=audioframe_len-audioframe_stride, window=np.hamming(audioframe_len))[0][specbinlow:specbinlow+specbinnum,:], dtype=float32)
def make_wave(self): """Inverts the spectrogram and returns a Wave. returns: Wave """ res = [] for t, spectrum in sorted(self.spec_map.items()): wave = spectrum.make_wave() n = len(wave) window = 1 / np.hamming(n) wave.window(window) i = wave.find_index(t) start = i - n // 2 end = start + n res.append((start, end, wave)) starts, ends, waves = zip(*res) low = min(starts) high = max(ends) ys = np.zeros(high-low, np.float) for start, end, wave in res: ys[start:end] = wave.ys # ts = np.arange(len(ys)) / self.framerate return Wave(ys, framerate=wave.framerate)
def make_spectrogram(self, seg_length, win_flag=True): """Computes the spectrogram of the wave. seg_length: number of samples in each segment win_flag: boolean, whether to apply hamming window to each segment returns: Spectrogram """ if win_flag: window = np.hamming(seg_length) i, j = 0, seg_length step = seg_length / 2 # map from time to Spectrum spec_map = {} while j < len(self.ys): segment = self.slice(i, j) if win_flag: segment.window(window) # the nominal time for this segment is the midpoint t = (segment.start + segment.end) / 2 spec_map[t] = segment.make_spectrum() i += step j += step return Spectrogram(spec_map, seg_length)
def __init__(self, block_length=1024, fft_length=None, step=None, wfunc=np.hamming, fs=1., donorm=True): self.block_length = block_length self.fft_length = fft_length self.step = step self.wfunc = wfunc self.fs = fs self.donorm = donorm self.psd = []
def __init__(self, block_length=1024, fft_length=None, step=None, wfunc=np.hamming, fs=1.): super(Coherence, self).__init__(block_length=block_length, fft_length=fft_length, step=step, wfunc=wfunc, fs=fs) self.coherence = None
def __init__(self, block_length=1024, fft_length=None, step=None, wfunc=np.hamming, fs=1.): super(Bicoherence, self).__init__(block_length=block_length, fft_length=fft_length, step=step, wfunc=wfunc, fs=fs)
def local_hamming(vec): return(hamming(len(vec)))
def FFT(data,rate): """given some data points and a rate, return [freq,power]""" data=data*np.hamming(len(data)) fft=np.fft.fft(data) fft=10*np.log10(np.abs(fft)) freq=np.fft.fftfreq(len(fft),1/rate) return freq[:int(len(freq)/2)],fft[:int(len(fft)/2)]
def filterSimMat(simMat, filtLength, filtType, scaleFilterMethod='max1'): if filtType == 'hamming': filt = np.hamming(filtLength) elif filtType == 'flat': filt = np.ones(filtLength) else: raise RuntimeError("Unknown/unsupported filter type {}".format(filtType)) if scaleFilterMethod == 'max1': filt /= np.max(filt) elif scaleFilterMethod == 'sum1': filt /= np.sum(filt) # print filt # filt = np.tile(filt, (simMat.shape[0], 1)) # print filt.shape return filters.convolve1d(simMat, weights=filt, axis=1, mode='constant')
def preprocessFeatureMat(X, Lfilt): """ Binarizes and blurs the feature matrix Parameters ---------- X : 2D array The original feature matrix (presumably output by buildFeatureMat()) Lfilt : int The width of the hamming filter used to blur the feature matrix. Returns ------- X : 2D array The modified feature matrix without blur Xblur : 2D array The modified feature matrix with blur """ Xblur = _filterRows(X, Lfilt) # ensure that the maximum value in Xblur is 1; we do this by dividing # by the largets value within Lfilt / 2, rather than just clamping, so # that there's a smooth dropoff as you move away from dense groups of # 1s in X; otherwise it basically ends up max-pooled maxima = filters.maximum_filter1d(Xblur, Lfilt // 2, axis=1, mode='constant') Xblur[maxima > 0] /= maxima[maxima > 0] # have columns be adjacent in memory return np.asfortranarray(X), np.asfortranarray(Xblur)
def _filterRows(X, filtLength): filt = np.hamming(filtLength) return filters.convolve1d(X, weights=filt, axis=1, mode='constant')
def filterRows(X, filtLength, filtType='hamming', scaleFilterMethod='max1'): if filtType == 'hamming': filt = np.hamming(filtLength) elif filtType == 'flat': filt = np.ones(filtLength) else: raise RuntimeError("Unknown/unsupported filter type {}".format(filtType)) if scaleFilterMethod == 'max1': filt /= np.max(filt) elif scaleFilterMethod == 'sum1': filt /= np.sum(filt) return filters.convolve1d(X, weights=filt, axis=1, mode='constant')
def notSoRandomWalk(shape, std=1, trendFilterLength=32, lpfLength=16): """bandpass filter a random walk so that the low-frequency trend / drift is eliminated and the high-frequency noise is attenuated""" walk = randwalk(shape, std=std) filt = np.hamming(trendFilterLength) filt /= np.sum(filt) whichAxis = len(walk.shape) > 1 # 0 iff 1d, else 1 # subtract baseline drift, roughly trend = filters.convolve1d(walk, weights=filt, axis=whichAxis, mode='reflect') walk -= trend # subtract noisey spikes walk = filters.convolve1d(walk, weights=np.hamming(lpfLength), axis=whichAxis, mode='reflect') return walk
def compute_feature_vector(eegdata, Fs): """ Extract the features from the EEG Arguments: eegdata: array of dimension [number of samples, number of channels] Fs: sampling frequency of eegdata Outputs: feature_vector: np.array of shape [number of feature points; number of different features] """ #Delete last column (Status) eegdata = np.delete(eegdata, -1 , 1) # 1. Compute the PSD winSampleLength, nbCh = eegdata.shape # Apply Hamming window w = np.hamming(winSampleLength) dataWinCentered = eegdata - np.mean(eegdata, axis=0) # Remove offset dataWinCenteredHam = (dataWinCentered.T*w).T NFFT = nextpow2(winSampleLength) Y = np.fft.fft(dataWinCenteredHam, n=NFFT, axis=0)/winSampleLength PSD = 2*np.abs(Y[0:NFFT/2,:]) f = Fs/2*np.linspace(0,1,NFFT/2) # SPECTRAL FEATURES # Average of band powers # Delta <4 ind_delta, = np.where(f<4) meanDelta = np.mean(PSD[ind_delta,:],axis=0) # Theta 4-8 ind_theta, = np.where((f>=4) & (f<=8)) meanTheta = np.mean(PSD[ind_theta,:],axis=0) # Alpha 8-12 ind_alpha, = np.where((f>=8) & (f<=12)) meanAlpha = np.mean(PSD[ind_alpha,:],axis=0) # Beta 12-30 ind_beta, = np.where((f>=12) & (f<30)) meanBeta = np.mean(PSD[ind_beta,:],axis=0) feature_vector = np.concatenate((meanDelta, meanTheta, meanAlpha, meanBeta), axis=0) feature_vector = np.log10(feature_vector) return feature_vector
def fft_continuous(data, n=None, psd=False, log='log', fs=None, window='hamming'): """Apply the Fast Fourier Transform on continuous data. Apply the Fast Fourier Transform algorithm on continuous data to get the spectrum. Steps: 1- Demeaning 2- Apply hamming window 3- Compute FFT 4- Grab lower half Args: data (numpy.ndarray): shape (`n_samples`, `n_channels`). Data for which to get the FFT Keyword Args: n (int): length of the FFT. If longer than `n_samples`, zero-padding is used; if smaller, then the signal is cropped. If None, use the same number as the number of samples psd (bool): if True, return the Power Spectral Density log (string): can be 'log' (log10(x)), 'log+1' (log10(x+1)) or None fs (float): Sampling rate of `data`. window (string): if 'no_window' do not use a window before applying the FFT. Otherwise, use as the window function. Currently only supports 'hamming'. Returns: (numpy.ndarray) Fourier Transform of the original signal (numpy.ndarray): array of frequency bins """ if data.ndim == 1: data = data.reshape((-1, 1)) [n_samples, n_channels] = data.shape data = data - data.mean(axis=0) if window.lower() == 'hamming': H = np.hamming(n_samples).reshape((-1, 1)) elif window.lower() == 'no_window': H = np.ones(n_samples).reshape((-1, 1)) else: raise ValueError('window value {} is not supported'.format(window)) L = np.min([n_samples, n]) if n else n_samples Y = np.fft.fft(data * H, n, axis=0) / L freq_bins = (fs * np.arange(0, Y.shape[0] / 2 + 1) / Y.shape[0]) \ if fs is not None else None out = Y[0:int(Y.shape[0] / 2) + 1, :] out[:, 0] = 2 * out[:, 0] if psd: out = np.abs(out) ** 2 if log == 'log': out = np.log10(out) elif log == 'log+1': out = np.log10(out + 1) return out, freq_bins
def mfcc_extractor(xx, sr, win_len, shift_len, mel_channel, dct_channel, win_type, include_delta): my_melbank = get_fft_mel_mat(win_len, sr, mel_channel) pre_emphasis_weight = 0.9375 # x = xx * (1-pre_emphasis_weight) x = np.append(xx[0], xx[1:] - pre_emphasis_weight * xx[:-1]) dctcoef = np.zeros((dct_channel, mel_channel), dtype=np.float32) for i in range(dct_channel): n = np.linspace(0, mel_channel-1, mel_channel) dctcoef[i, :] = np.cos((2 * n + 1) * i * np.pi / (2 * mel_channel)) w = 1 + 6 * np.sin(np.pi * np.linspace(0, dct_channel-1, dct_channel) / (dct_channel-1)) w /= w.max() w = np.reshape(w, newshape=(dct_channel, 1)) samples = x.shape[0] frames = (samples - win_len) // shift_len stft = np.zeros((win_len, frames), dtype=np.complex64) spectrum = np.zeros((win_len // 2 + 1, frames), dtype=np.float32) mfcc = np.zeros((dct_channel, frames), dtype=np.float32) if win_type == 'hanning': window = np.hanning(win_len) elif win_type == 'hamming': window = np.hamming(win_len) elif win_type == 'triangle': window = (1-(np.abs(win_len - 1 - 2*np.arange(1, win_len+1, 1))/(win_len+1))) else: window = np.ones(win_len) for i in range(frames): one_frame = x[i * shift_len: i * shift_len + win_len] windowed_frame = np.multiply(one_frame, window) stft[:, i] = np.fft.fft(windowed_frame, win_len) spectrum[:, i] = np.power(np.abs(stft[0:win_len // 2 + 1, i]), 2) c1 = np.matmul(my_melbank, spectrum) c1 = np.where(c1 == 0.0, np.finfo(float).eps, c1) mfcc[:dct_channel, :] = np.multiply(np.matmul(dctcoef, np.log(c1)), np.repeat(w, frames, 1)) if include_delta: dtm = np.zeros((dct_channel, frames), dtype=np.float32) ddtm = np.zeros((dct_channel, frames), dtype=np.float32) for i in range(2, frames-2): dtm[:, i] = 2 * mfcc[:, i+2] + mfcc[:, i+1] - mfcc[:, i-1] - 2 * mfcc[:, i-2] dtm /= 3.0 for i in range(2, frames-2): ddtm[:, i] = 2 * dtm[:, i+2] + dtm[:, i+1] - dtm[:, i-1] - 2 * dtm[:, i-2] ddtm /= 3.0 mfcc = np.row_stack((mfcc[:, 4:frames-4], dtm[:, 4:frames-4], ddtm[:, 4:frames-4])) return mfcc, spectrum
