def dolpc(x, modelorder = 8):
nbands, nframes = x.shape
ncorr = 2 * (nbands - 1)
R = np.zeros((ncorr, nframes))
R[0:nbands, :] = x
for i in range(nbands - 1):
R[i + nbands - 1, :] = x[nbands - (i + 1), :]
r = fft.ifft(R.T).real.T
r = r[0:nbands, :]
y = np.ones((nframes, modelorder + 1))
e = np.zeros((nframes, 1))
if modelorder == 0:
for i in range(nframes):
_ , e_tmp, _ = spectrum.LEVINSON(r[:, i], modelorder, allow_singularity = True)
e[i, 0] = e_tmp
else:
for i in range(nframes):
y_tmp, e_tmp, _ = spectrum.LEVINSON(r[:, i], modelorder, allow_singularity = True)
y[i, 1:modelorder + 1] = y_tmp
e[i, 0] = e_tmp
y = np.divide(y.T, np.add(np.tile(e.T, (modelorder + 1, 1)), 1e-8))
return y
def dolpc(x, modelorder=8):
"""
y = dolpc(x,modelorder)
@About: compute autoregressive model from spectral magnitude samples
where, x : input signal
row_x, col_x = x.shape()
row_x : critical band
col_y : nframes
modelorder : order of model, defaults to 8
y : lpc coeff.
row_y, col_y = y.shape()
row_y :
"""
nbands, nframes = x.shape
ncorr = 2 * (nbands - 1)
# @TO-DO : This need optimisation
R = np.zeros((ncorr, nframes))
R[0:nbands, :] = x
for i in range(nbands - 1):
R[i + nbands - 1, :] = x[nbands - (i + 1), :]
# Calculate autocorrelation
r = fft.ifft(R.T).real.T
# First half only
r = r[0:nbands, :]
y = np.ones((nframes, modelorder + 1))
e = np.zeros((nframes, 1))
# Find LPC coeffs by durbin
if modelorder == 0:
for i in range(nframes):
_, e_tmp, _ = spectrum.LEVINSON(r[:, i],
modelorder,
allow_singularity=True)
e[i, 0] = e_tmp
else:
for i in range(nframes):
y_tmp, e_tmp, _ = spectrum.LEVINSON(r[:, i],
modelorder,
allow_singularity=True)
y[i, 1:modelorder + 1] = y_tmp
e[i, 0] = e_tmp
# Normalize each poly by gain
y = np.divide(y.T, np.add(np.tile(e.T, (modelorder + 1, 1)), 1e-8))
return y
def levinson(correlation, order):
"""
Calculate the predictor coefficients for autoregressive linear prediction
using the Levinson-Durbin algorithm
Parameters
----------
correlation : numpy array
The autocorrelation function of a signal.
order : int
The order of the prediction.
Returns
-------
coeffs : numpy array
The calculated prediction coefficients
energy : float
The estimated residual error energy after
prediction
Notes
-----
* The first coefficient, 1, is left out.
"""
if not order > 0:
raise ValueError("order must be greater than zero")
coeffs, energy, reflectioncoeffs = spectrum.LEVINSON(correlation, order)
energy /= correlation[0]
return (coeffs, energy)
def dolpc(x, model_order=8):
"""
Function dolpc computes the autoregressive model from spectral magnitude samples.
@param x: Critical band filters.
@param model_order: Order of model. Default is 8.
@returns: Autoregressive model from spectral magnitude samples.
"""
num_bands, num_frames = x.shape
# Calculate autocorrelation
R = np.zeros((2 * (num_bands - 1), num_frames))
R[0:num_bands, :] = x
for i in range(num_bands - 1):
R[i + num_bands - 1, :] = x[num_bands - (i + 1), :]
r = fft.ifft(R.T).real.T
r = r[0:num_bands, :]
y = np.ones((num_frames, model_order + 1))
e = np.zeros((num_frames, 1))
# Find LPC coeffs by durbin
if model_order == 0:
for i in range(num_frames):
_, e_tmp, _ = spectrum.LEVINSON(r[:, i],
model_order,
allow_singularity=True)
e[i, 0] = e_tmp
else:
for i in range(num_frames):
y_tmp, e_tmp, _ = spectrum.LEVINSON(r[:, i],
model_order,
allow_singularity=True)
y[i, 1:model_order + 1] = y_tmp
e[i, 0] = e_tmp
# Normalize each poly by gain.
y = np.divide(y.T, np.add(np.tile(e.T, (model_order + 1, 1)), 1e-8))
return y