def test_decorrelation():
input = sumpf.modules.NoiseGenerator(distribution=sumpf.modules.NoiseGenerator.GaussianDistribution(),samplingrate=48000.0,
length=2**20).GetSignal()
# input = nlsp.NovakSweepGenerator_Sine()
# input = input.GetOutput()
decorr_input,k,mu = nlsp.wgn_hgm_decorrelate(input,5)
for i in range(len(decorr_input)):
for j in range(len(decorr_input)):
cross_corr = sumpf.modules.CorrelateSignals(signal1=decorr_input[i],signal2=decorr_input[j],mode=sumpf.modules.CorrelateSignals.SAME).GetOutput()
# csd = sumpf.modules.FourierTransform(cross_corr).GetSpectrum()
# plot.plot(cross_corr)
print nlsp.calculateenergy_time(cross_corr),i,j
print k
# test_decorrelation()
def plot_sdrvsfreq(input_signalorspectrum,
output_signalorspectrum,
label=None,
show=True):
if isinstance(input_signalorspectrum, list) != True:
observed_l = []
observed_l.append(input_signalorspectrum)
else:
observed_l = input_signalorspectrum
if isinstance(output_signalorspectrum, list) != True:
identified_l = []
identified_l.append(output_signalorspectrum)
else:
identified_l = output_signalorspectrum
for observed, identified in zip(observed_l, identified_l):
if isinstance(observed, (sumpf.Signal, sumpf.Spectrum)) and isinstance(
observed, (sumpf.Signal, sumpf.Spectrum)):
if isinstance(observed, sumpf.Signal):
observed = sumpf.modules.FourierTransform(
observed).GetSpectrum()
if isinstance(identified, sumpf.Signal):
identified = sumpf.modules.FourierTransform(
identified).GetSpectrum()
if len(observed) != len(identified):
merged_spectrum = sumpf.modules.MergeSpectrums(
spectrums=[observed, identified],
on_length_conflict=sumpf.modules.MergeSpectrums.
FILL_WITH_ZEROS).GetOutput()
observed = sumpf.modules.SplitSpectrum(
data=merged_spectrum, channels=[0]).GetOutput()
identified = sumpf.modules.SplitSpectrum(
data=merged_spectrum, channels=[1]).GetOutput()
# observed = nlsp.cut_spectrum(observed,[100,19000])
# identified = nlsp.cut_spectrum(identified,[100,19000])
identified = sumpf.modules.InverseFourierTransform(
identified).GetSignal()
observed = sumpf.modules.InverseFourierTransform(
observed).GetSignal()
noise = identified - observed
print nlsp.calculateenergy_time(noise)
if label is None:
pass
else:
noise = nlsp.relabel(noise, labels=label)
nlsp.common.plots.plot(noise, show=show)
else:
print "The given arguments is not a sumpf.Signal or sumpf.Spectrum"
def signal_to_noise_ratio_time(input_signalorspectrum,
output_signalorspectrum):
"""
Calculates the signal to noise ratio between two signals
This function calculates the signal to noise ratio in time domain. If the input is spectrum then it transforms it to
time domain. And in the case of length conflict zeros are appended.
:param input_signalorspectrum: the array of input signal or spectrum
:param output_signalorspectrum: the array of output signal or spectrum
:return: the array of signal to noise ratio between input and output
"""
if isinstance(input_signalorspectrum, list) != True:
observed_l = []
observed_l.append(input_signalorspectrum)
else:
observed_l = input_signalorspectrum
if isinstance(output_signalorspectrum, list) != True:
identified_l = []
identified_l.append(output_signalorspectrum)
else:
identified_l = output_signalorspectrum
snr = []
for observed, identified in zip(observed_l, identified_l):
if isinstance(observed, (sumpf.Signal, sumpf.Spectrum)) and isinstance(
observed, (sumpf.Signal, sumpf.Spectrum)):
if isinstance(observed, sumpf.Spectrum):
observed = sumpf.modules.InverseFourierTransform(
observed).GetSignal()
if isinstance(identified, sumpf.Spectrum):
identified = sumpf.modules.InverseFourierTransform(
identified).GetSignal()
if len(observed) != len(identified):
merged_signal = sumpf.modules.MergeSignals(
signals=[observed, identified],
on_length_conflict=sumpf.modules.MergeSignals.
FILL_WITH_ZEROS).GetOutput()
observed = sumpf.modules.SplitSignal(data=merged_signal,
channels=[0]).GetOutput()
identified = sumpf.modules.SplitSignal(
data=merged_signal, channels=[1]).GetOutput()
noise = observed - identified
noise_energy = nlsp.calculateenergy_time(noise)
input_energy = nlsp.calculateenergy_time(observed)
snr.append(10 * math.log10(input_energy[0] / noise_energy[0]))
else:
print "The given arguments is not a sumpf.Signal or sumpf.Spectrum"
return snr
def calculateenergy_betweenfreq_time(input, frequency_range):
"""
Calculates the energy of input signal between certain frequencies of input signal
:param input: the input signal or spectrum whose energy has to be calculated
:param frequency_range: the range of frequencies over which the energy has to be calculated
:return: the tuple of the energy of input spectrum in time domain
"""
if isinstance(input, (sumpf.Signal)):
ip = sumpf.modules.FourierTransform(signal=input).GetSpectrum()
else:
ip = input
spec = nlsp.cut_spectrum(ip, frequency_range)
energy = nlsp.calculateenergy_time(spec)
return energy
def clipping_adaptive_identification(
input_generator,
outputs,
branches=5,
iterations=1,
step_size=0.1,
filtertaps=2**11,
algorithm=nlsp.miso_nlms_multichannel,
init_coeffs=None,
Plot_SERvsIteration=False,
Print_SER=False,
nonlinear_func=nlsp.function_factory.hardclip):
clipping_thresholds = ([-1.1, 1.1], [-1.0, 1.0], [-0.9,
0.9], [-0.8,
0.8], [-0.7, 0.7])
if hasattr(input_generator, "GetOutput"):
input = input_generator.GetOutput()
else:
input = input_generator
impulse = sumpf.modules.ImpulseGenerator(
samplingrate=outputs.GetSamplingRate(), length=len(input)).GetSignal()
nl = []
for th in clipping_thresholds:
nl.append(nonlinear_func(th))
iden_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input,
nonlinear_functions=nl,
filter_irs=[
impulse,
] * branches,
max_harmonics=range(
1, branches + 1))
input_signal = []
for i in range(branches):
input_signal.append(
iden_nlsystem.GetHammersteinBranchNLOutput(i + 1).GetChannels()[0])
desired_signal = outputs.GetChannels()[0]
if init_coeffs is None:
w = numpy.zeros((len(input_signal), filtertaps))
else:
w = []
for k in init_coeffs:
w.append(numpy.asarray(k.GetChannels()[0]))
error_energy = numpy.zeros(iterations)
SNR = numpy.zeros(iterations)
iteration = numpy.zeros(iterations)
for i in range(iterations):
w = algorithm(input_signal,
desired_signal,
filtertaps,
step_size,
initCoeffs=w,
plot=Plot_SERvsIteration)
kernel = []
for k in w:
iden_filter = sumpf.Signal(channels=(k, ),
samplingrate=outputs.GetSamplingRate(),
labels=("filter", ))
kernel.append(iden_filter)
iden_nlsystem.SetFilterIRS(kernel)
error = sumpf.modules.SubtractSignals(
signal1=outputs, signal2=iden_nlsystem.GetOutput()).GetOutput()
SNR[i] = nlsp.snr(outputs, iden_nlsystem.GetOutput())[0]
error_energy[i] = nlsp.calculateenergy_time(error)[0]
iteration[i] = (i + 1) * (len(input) - filtertaps + 1)
if Print_SER is True:
print "SNR %r, iteration %r" % (SNR[i], iteration[i])
print "Error energy %r, iteration %r" % (error_energy[i],
iteration[i])
print
nl_func = nl
return kernel, nl_func
def adaptive_identification(
input_generator,
outputs,
branches=5,
iterations=1,
step_size=0.1,
filtertaps=2**11,
algorithm=nlsp.miso_nlms_multichannel,
init_coeffs=None,
Plot_SERvsIteration=False,
Print_SER=False,
nonlinear_func=nlsp.function_factory.legrendre_polynomial):
"""
Adaptive system identification.
:param input_generator: the input generator object or the input signal
:param outputs: the response of the system
:param branches: total number of branches
:param iterations: total number of iterations
:param step_size: the step size for adaptive filtering
:param filtertaps: the total number of filter taps
:param algorithm: the adaptation algorithm
:param init_coeffs: initial coefficients
:param Plot_SERvsIteration: plot ser vs iteration graph
:param Print_SER: print SER value for each iteration
:param nonlinear_func: the nonlinear function of the resulting model
:return: the array of filter kernels and the nonlinear functions
"""
if hasattr(input_generator, "GetOutput"):
input = input_generator.GetOutput()
else:
input = input_generator
impulse = sumpf.modules.ImpulseGenerator(
samplingrate=outputs.GetSamplingRate(), length=len(input)).GetSignal()
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input,
nonlinear_functions=nlsp.nl_branches(nonlinear_func, branches),
filter_irs=[
impulse,
] * branches,
max_harmonics=range(1, branches + 1))
input_signal = []
for i in range(branches):
input_signal.append(
iden_nlsystem.GetHammersteinBranchNLOutput(i + 1).GetChannels()[0])
desired_signal = outputs.GetChannels()[0]
if init_coeffs is None:
w = numpy.zeros((len(input_signal), filtertaps))
else:
w = []
for k in init_coeffs:
w.append(numpy.asarray(k.GetChannels()[0]))
error_energy = numpy.zeros(iterations)
SNR = numpy.zeros(iterations)
iteration = numpy.zeros(iterations)
for i in range(iterations):
w = algorithm(input_signal,
desired_signal,
filtertaps,
step_size,
initCoeffs=w,
plot=Plot_SERvsIteration)
kernel = []
for k in w:
iden_filter = sumpf.Signal(channels=(k, ),
samplingrate=outputs.GetSamplingRate(),
labels=("filter", ))
kernel.append(iden_filter)
iden_nlsystem.SetFilterIRS(kernel)
error = sumpf.modules.SubtractSignals(
signal1=outputs, signal2=iden_nlsystem.GetOutput()).GetOutput()
SNR[i] = nlsp.snr(outputs, iden_nlsystem.GetOutput())[0]
error_energy[i] = nlsp.calculateenergy_time(error)[0]
iteration[i] = (i + 1) * (len(input) - filtertaps + 1)
if Print_SER is True:
print "SNR %r, iteration %r" % (SNR[i], iteration[i])
print "Error energy %r, iteration %r" % (error_energy[i],
iteration[i])
print
nl_func = nlsp.nl_branches(nonlinear_func, branches)
return kernel, nl_func