python nextpow2_Python numpy.hamming() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

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

Example 2

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))

Example 3

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

Example 4

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

Example 5

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

Example 6

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

Example 7

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

Example 8

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]

Example 9

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)

Example 10

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

Example 11

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

Example 12

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)

Example 13

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)

Example 14

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')

Example 15

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)]

Example 16

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

Example 17

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

Example 18

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

Example 19

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

Example 20

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

Example 21

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 :

####################################################################

Example 22

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

Example 23

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

Example 24

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))

Example 25

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))

Example 26

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)]

Example 27

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

Example 28

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

Example 29

def smooth(values, window):

#weights = numpy.repeat(1.0, window)/window

weights = numpy.hamming(window)

sma = numpy.convolve(values, weights, 'valid')

sma = sma[0:len(values)]

return sma

# https://github.com/tcort/va2epr-tnc/blob/master/firmware/aprs.c

# Thomas Cort

# update a CRC with one new byte.

# initial crc should be 0xffff.

Example 30

def hamming(self):

"""Apply a Hamming window to the wave.

"""

self.ys *= np.hamming(len(self.ys))

Example 31

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')

Example 32

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)

Example 33

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)

Example 34

def hamming(self):

"""Apply a Hamming window to the wave.

"""

self.ys *= np.hamming(len(self.ys))

Example 35

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)

Example 36

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 = []

Example 37

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

Example 38

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)

Example 39

def local_hamming(vec):

return(hamming(len(vec)))

Example 40

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)]

Example 41

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')

Example 42

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)

Example 43

def _filterRows(X, filtLength):

filt = np.hamming(filtLength)

return filters.convolve1d(X, weights=filt, axis=1, mode='constant')

Example 44

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')

Example 45

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

Example 46

def _filterRows(X, filtLength):

filt = np.hamming(filtLength)

return filters.convolve1d(X, weights=filt, axis=1, mode='constant')

Example 47

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

Example 48

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

Example 49

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

Example 50

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