def load_systemidentification(method, nlsystem, branches, length):
str_method = str(method)
f, func, rest, rest2 = str_method.split()
filename = '_'.join((nlsystem, func, str(branches), str(length)))
filename = ''.join((filename, ".npz"))
file = os.path.join(location, filename)
if os.path.isfile(file):
filter_impulse_response = sumpf.modules.SignalFile(
filename=file,
format=sumpf.modules.SignalFile.NUMPY_NPZ).GetSignal()
filter_ir = nlsp.multichanneltoarray(filter_impulse_response)
if "power" in func:
nl_functions = nlsp.nl_branches(nlsp.function_factory.power_series,
branches)
elif "cheby" in func:
nl_functions = nlsp.nl_branches(
nlsp.function_factory.chebyshev1_polynomial, branches)
elif "legendre" in func:
nl_functions = nlsp.nl_branches(
nlsp.function_factory.legrendre_polynomial, branches)
elif "hermite" in func:
nl_functions = nlsp.nl_branches(
nlsp.function_factory.hermite_polynomial, branches)
else:
filter_ir = None
nl_functions = None
return filter_ir, nl_functions
def doublehgm_samenl_evaluation(input_generator,
branches,
iden_method,
Plot,
reference=None):
input_signal = input_generator.GetOutput()
filter_spec_tofind1 = nlsp.log_bpfilter(branches=branches,
input=input_signal)
filter_spec_tofind2 = nlsp.log_chebyfilter(branches=branches,
input=input_signal)
ref_nlsystem = nlsp.HammersteinGroup_Series(
input_signal=input_signal,
nonlinear_functions=(nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
nlsp.nl_branches(
nlsp.function_factory.power_series,
branches)),
filter_irs=(filter_spec_tofind1, filter_spec_tofind2),
max_harmonics=(range(1, branches + 1), range(1, branches + 1)),
hgm_type=(nlsp.HammersteinGroupModel_up,
nlsp.HammersteinGroupModel_up))
found_filter_spec, nl_functions = iden_method(input_generator,
ref_nlsystem.GetOutput(2),
branches)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_signal))
ref_nlsystem = nlsp.HammersteinGroup_Series(
input_signal=reference,
nonlinear_functions=(nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
nlsp.nl_branches(
nlsp.function_factory.power_series,
branches)),
filter_irs=(filter_spec_tofind1, filter_spec_tofind2),
max_harmonics=(range(1, branches + 1), range(1, branches + 1)),
hgm_type=(nlsp.HammersteinGroupModel_up,
nlsp.HammersteinGroupModel_up))
iden_nlsystem.SetInput(reference)
if Plot is True:
plot.relabelandplotphase(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput(2)).GetSpectrum(),
"Reference System",
show=False)
plot.relabelandplotphase(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified System",
show=True)
print "SNR between Reference and Identified output for double hgm same nl: %r" % nlsp.snr(
ref_nlsystem.GetOutput(2), iden_nlsystem.GetOutput())
def linear_identification_temporalreversal(sweep_generator,
output_sweep,
branches,
length_ir=2**12):
"""
Linear identification of a system using temporal reversal method.
:param sweep_generator: the sweep generator object
:param output_sweep: the output sweep of the nonlinear system
:return: the filter kernels and the nonlinear functions of the HGM
"""
srate = output_sweep.GetSamplingRate()
rev = sweep_generator.GetReversedOutput()
rev_spec = sumpf.modules.FourierTransform(rev).GetSpectrum()
out_spec = sumpf.modules.FourierTransform(output_sweep).GetSpectrum()
out_spec = out_spec / output_sweep.GetSamplingRate()
tf = rev_spec * out_spec
ir_sweep = sumpf.modules.InverseFourierTransform(tf).GetSignal()
ir_sweep = sumpf.modules.CutSignal(signal=ir_sweep,
start=0,
stop=length_ir).GetOutput()
ir_sweep = [
ir_sweep,
]
nl_func = nlsp.nl_branches(nlsp.function_factory.power_series, branches)
for i in range(1, branches):
ir_sweep.append(
sumpf.modules.ConstantSignalGenerator(
value=0.0, samplingrate=srate, length=length_ir).GetSignal())
return ir_sweep, nl_func
def adaptive_differentlengthanditerations():
# generate virtual nonlinear system using HGM
ref_nlsystem = nlsp.HammersteinGroupModel_up(nonlinear_functions=nlsp.nl_branches(nlsp.function_factory.power_series,branches),
filter_irs=filter_spec_tofind_noise,
max_harmonics=range(1,branches+1))
# give input and get output from the virtual nlsystem
ref_nlsystem.SetInput(input)
output_noise = ref_nlsystem.GetOutput()
input_noise = input
# only noise based system identification
found_filter_spec_adapt_hermite, nl_function_adapt_hermite = nlsp.adaptive_identification_hermite(input_generator=input_noise,outputs=output_noise,
branches=branches,iterations=i,filtertaps=filter_taps,Print=True)
iden_nlsystem_adapt_hermite = nlsp.HammersteinGroupModel_up(max_harmonics=range(1,branches+1),nonlinear_functions=nl_function_adapt_hermite,
filter_irs=found_filter_spec_adapt_hermite)
# set reference input to virtual nlsystem and identified nl system
ref_nlsystem.SetInput(reference)
iden_nlsystem_adapt_hermite.SetInput(reference)
# calculate snr value
adaptive_hermite_snr = nlsp.snr(ref_nlsystem.GetOutput(),iden_nlsystem_adapt_hermite.GetOutput())
# print snr value
print "adaptive_hermite_snr: %r" %adaptive_hermite_snr
def comparereversedandsi():
sampling_rate = 48000
length = 2**16
branches = 5
excitation = nlsp.NovakSweepGenerator_Sine(start_frequency=20.0,stop_frequency=20000.0,
length=length,sampling_rate=sampling_rate)
input_signal = excitation.GetOutput()
input_spec = sumpf.modules.FourierTransform(input_signal).GetSpectrum()
prp = sumpf.modules.ChannelDataProperties()
prp.SetSignal(input_signal)
filter_spec_tofind = sumpf.modules.FilterGenerator(filterfunction=sumpf.modules.FilterGenerator.BUTTERWORTH(order=100),
frequency=20.0,transform=True,resolution=prp.GetResolution(),
length=prp.GetSpectrumLength()).GetSpectrum()
filter_spec_tofind = [sumpf.modules.InverseFourierTransform(filter_spec_tofind).GetSignal(),]*branches
ref_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(nlsp.function_factory.power_series,branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1,branches+1))
nlsp.plotstft(ref_nlsystem.GetOutput())
nlsp.plotstft(input_signal)
response = ref_nlsystem.GetOutput()
response_spec = sumpf.modules.FourierTransform(response).GetSpectrum()
reg_inv = sumpf.modules.RegularizedSpectrumInversion(spectrum=input_spec,start_frequency=20.0,stop_frequency=6000.0,epsilon_max=0.1).GetOutput()
reg_specdivision = sumpf.modules.MultiplySpectrums(spectrum1=reg_inv, spectrum2=response_spec)
reg_tf = reg_specdivision.GetOutput()
nl_ir_si = sumpf.modules.InverseFourierTransform(spectrum=reg_tf).GetSignal()
rev = excitation.GetReversedOutput()
rev_spec = sumpf.modules.FourierTransform(rev).GetSpectrum()
out_spec = response_spec / response.GetSamplingRate()
tf = rev_spec * out_spec
ir_sweep = sumpf.modules.InverseFourierTransform(tf).GetSignal()
plot.relabelandplot(nl_ir_si,"spectralinversion_ir",show=False)
plot.relabelandplot(ir_sweep,"reverse_ir",show=True)
def miso_identification(input_generator, output_wgn, branches):
"""
MISO approach of system identification.
:param input_generator: the input generator or the input signal
:param output_wgn: the response of the nonlinear system
:param branches: the number of branches
:return: the filter kernels and the nonlinear function of a HGM
"""
if hasattr(input_generator,"GetOutput"):
input_wgn = input_generator.GetOutput()
else:
input_wgn = input_generator
l = []
L = []
signal_matrix, k_matrix, mu_matrix = wgn_hgm_decorrelate(input_wgn,branches)
for branch in range(1,branches+1):
input_decorrelated = signal_matrix[branch-1]
cross_corr = sumpf.modules.CorrelateSignals(signal1=input_decorrelated,signal2=output_wgn,mode=sumpf.modules.CorrelateSignals.SPECTRUM).GetOutput()
num = sumpf.modules.FourierTransform(cross_corr).GetSpectrum()
den = sumpf.modules.FourierTransform(sumpf.modules.CorrelateSignals(signal1=input_decorrelated,
signal2=input_decorrelated,mode=sumpf.modules.CorrelateSignals.SPECTRUM).GetOutput()).GetSpectrum()
linear = sumpf.modules.DivideSpectrums(spectrum1=num, spectrum2=den).GetOutput()
kernel = sumpf.modules.InverseFourierTransform(linear).GetSignal()
signal = sumpf.Signal(channels=kernel.GetChannels(),samplingrate=input_wgn.GetSamplingRate(),labels=kernel.GetLabels())
l.append(signal)
L.append(sumpf.modules.FourierTransform(signal).GetSpectrum())
G = []
for row in range(0,branches):
A = sumpf.modules.ConstantSpectrumGenerator(value=0.0,resolution=L[0].GetResolution(),length=len(L[0])).GetSpectrum()
for column in range(0,branches):
temp = sumpf.modules.AmplifySpectrum(input=L[column],factor=k_matrix[row][column]).GetOutput()
A = A + temp
G.append(sumpf.modules.InverseFourierTransform(A + mu_matrix[row]).GetSignal())
nl_func = nlsp.nl_branches(nlsp.function_factory.power_series,branches)
return G,nl_func
def differentlength_evaluation(input_generator,
branches,
Plot,
reference=None):
length_ref = [2**15, 2**16, 2**17]
length_iden = [2**15, 2**16, 2**17]
input_generator_ref = input_generator
input_generator_iden = input_generator
for signal_length, ref_length in zip(length_iden, length_ref):
input_generator_ref.SetLength(ref_length)
input_ref = input_generator_ref.GetOutput()
filter_spec_tofind = nlsp.log_weightingfilter(branches=branches,
input=input_ref)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_ref,
nonlinear_functions=nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
sweep = nlsp.NovakSweepGenerator_Sine(
sampling_rate=input_ref.GetSamplingRate(), length=len(input_ref))
ref_nlsystem.SetInput(sweep.GetOutput())
init_coeffs, non = nlsp.nonlinearconvolution_powerseries_temporalreversal(
sweep, ref_nlsystem.GetOutput(), branches=branches)
init_coeffs = nlsp.change_length_filterkernels(init_coeffs,
filter_length)
ref_nlsystem.SetInput(input_ref)
found_filter_spec, nl_functions = nlsp.adaptive_identification_legendre(
input_generator=input_generator_ref,
outputs=ref_nlsystem.GetOutput(),
branches=branches,
init_coeffs=init_coeffs)
input_generator_iden.SetLength(signal_length)
input_iden = input_generator_iden.GetOutput()
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_iden,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_ref))
ref_nlsystem.SetInput(reference)
iden_nlsystem.SetInput(reference)
if Plot is True:
plot.relabelandplotphase(
sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference Output", False)
plot.relabelandplotphase(
sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Output", True)
print "SNR between Reference(length:%r) and Identified output(length:%r) : %r" % (
len(input_ref), len(input_iden),
nlsp.snr(ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput()))
def robustness_excitation_evaluation(input_generator,
branches,
Plot,
reference=None):
excitation_signal_amp = [0.5, 1.0]
sample_signal_amp = [0.5, 1.0, 2.0]
input = input_generator.GetOutput()
for excitation_amp, sample_amp in itertools.product(
excitation_signal_amp, sample_signal_amp):
input_signal = sumpf.modules.AmplifySignal(
input=input, factor=excitation_amp).GetOutput()
sample_signal = nlsp.WhiteGaussianGenerator(
sampling_rate=input_signal.GetSamplingRate(),
length=len(input_signal),
distribution=sumpf.modules.NoiseGenerator.UniformDistribution(
minimum=-sample_amp, maximum=sample_amp))
sample_signal = sample_signal.GetOutput()
filter_spec_tofind = nlsp.log_weightingfilter(branches=branches,
input=input_signal)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
sweep = nlsp.NovakSweepGenerator_Sine(
sampling_rate=input_signal.GetSamplingRate(),
length=len(input_signal))
ref_nlsystem.SetInput(sweep.GetOutput())
init_coeffs, non = nlsp.nonlinearconvolution_powerseries_temporalreversal(
sweep, ref_nlsystem.GetOutput(), branches=branches)
init_coeffs = nlsp.change_length_filterkernels(init_coeffs,
filter_length)
ref_nlsystem.SetInput(input_signal)
found_filter_spec, nl_functions = nlsp.adaptive_identification_legendre(
input_generator=input_generator,
outputs=ref_nlsystem.GetOutput(),
branches=branches,
init_coeffs=init_coeffs)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=sample_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
ref_nlsystem.SetInput(sample_signal)
if Plot is True:
nlsp.relabelandplotphase(
sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference Output Scaled", False)
nlsp.relabelandplot(
sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Output", True)
print "SNR between Scaled Identified with(amp:%r) and Tested with(amp:%r) output: %r" % (
excitation_amp, sample_amp,
nlsp.snr(ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput()))
def differentlength_evaluation(input_generator,
branches,
iden_method,
Plot,
reference=None):
"""
Evaluation of System Identification method by hgm virtual nl system
nonlinear system - virtual hammerstein group model with power series polynomials as nl function and bandpass filters
as linear functions
inputsignal - signal signal
plot - the original filter spectrum and the identified filter spectrum, the reference output and identified output
expectation - utmost similarity between the two spectrums
"""
length_ref = [2**15, 2**16, 2**17]
length_iden = [2**15, 2**16, 2**17]
input_generator_ref = input_generator
input_generator_iden = input_generator
for signal_length, ref_length in zip(length_iden, length_ref):
input_generator_ref.SetLength(ref_length)
input_ref = input_generator_ref.GetOutput()
filter_spec_tofind = nlsp.log_weightingfilter(branches=branches,
input=input_ref)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_ref,
nonlinear_functions=nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
found_filter_spec, nl_functions = iden_method(input_generator,
ref_nlsystem.GetOutput(),
branches)
input_generator_iden.SetLength(signal_length)
input_iden = input_generator_iden.GetOutput()
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_iden,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_ref))
ref_nlsystem.SetInput(reference)
iden_nlsystem.SetInput(reference)
if Plot is True:
plot.relabelandplotphase(
sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference Output", False)
plot.relabelandplotphase(
sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Output", True)
print "SNR between Reference(length:%r) and Identified output(length:%r) : %r" % (
len(input_ref), len(input_iden),
nlsp.snr(ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput()))
def robustness_excitation_evaluation(input_generator,
branches,
iden_method,
Plot,
reference=None):
excitation_signal_amp = [0.5, 1.0, 2.0]
sample_signal_amp = [0.5, 1.0, 2.0]
input_s = input_generator.GetOutput()
sample_signal = sumpf.modules.NoiseGenerator(
distribution=sumpf.modules.NoiseGenerator.UniformDistribution(),
samplingrate=input_s.GetSamplingRate(),
length=len(input_s)).GetSignal()
sample_signal = nlsp.RemoveOutliers(thresholds=[-1.0, 1.0],
signal=sample_signal,
value=0.0)
sample_signal = sample_signal.GetOutput()
for excitation_amp, sample_amp in itertools.product(
excitation_signal_amp, sample_signal_amp):
input_generator.SetFactor(excitation_amp)
input_signal = input_generator.GetOutput()
sample_signal = sumpf.modules.AmplifySignal(
input=sample_signal, factor=sample_amp).GetOutput()
filter_spec_tofind = nlsp.log_bpfilter(branches=branches,
input=input_signal)
filter_spec_tofind = [i for i in reversed(filter_spec_tofind)]
filter_length = len(filter_spec_tofind[0])
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
found_filter_spec, nl_functions = iden_method(input_generator,
ref_nlsystem.GetOutput(),
branches)
found_filter_spec = nlsp.change_length_filterkernels(
found_filter_spec, length=filter_length)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=sample_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
ref_nlsystem.SetInput(sample_signal)
if Plot is True:
nlsp.relabelandplotphase(
sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference Output Scaled", False)
nlsp.relabelandplot(
sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Output", True)
print "SNR between Scaled Identified with(amp:%r) and Tested with(amp:%r) output: %r" % (
excitation_amp, sample_amp,
nlsp.snr(ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput()))
def computationtime_evaluation(input_generator,
branches,
iden_method,
Plot,
rangevalue=10,
save=False):
inputgenerator = input_generator
branch = reversed(range(2, branches + 1))
length = reversed([2**14, 2**15, 2**16])
for branches, signal_length in itertools.product(branch, length):
sim = []
iden = []
reference = nlsp.WhiteGaussianGenerator(
sampling_rate=input_generator.GetOutput().GetSamplingRate(),
length=signal_length,
distribution=sumpf.modules.NoiseGenerator.LaplaceDistribution())
reference = reference.GetOutput()
for i in range(rangevalue):
inputgenerator.SetLength(signal_length)
input_signal = inputgenerator.GetOutput()
filter_spec_tofind = nlsp.log_bpfilter(branches=branches,
input=input_signal)
nl_func = nlsp.nl_branches(nlsp.function_factory.power_series,
branches)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_func,
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
identification_time_start = time.clock()
found_filter_spec, nl_functions = iden_method(
input_generator, ref_nlsystem.GetOutput(), branches)
identification_time_stop = time.clock()
if save is True:
found_filter_spec_save, nl_functions_save = nlsp.systemidentification(
"powerhgmweight", iden_method, branches, inputgenerator,
ref_nlsystem.GetOutput())
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
iden_nlsystem.GetOutput()
simulation_time_start = time.clock()
iden_nlsystem.SetInput(reference)
iden_nlsystem.GetOutput()
simulation_time_stop = time.clock()
simulation_time = simulation_time_stop - simulation_time_start
identification_time = identification_time_stop - identification_time_start
iden.append(identification_time)
sim.append(simulation_time)
print "Signal length: %r, branches: %r, simulation time: %r, identification time: %r" % (
signal_length, branches, numpy.average(sim), numpy.average(iden))
def hgmallpass_evaluation(input_generator,
branches,
nlfunction,
Plot,
reference=None):
input_signal = input_generator.GetOutput()
allpass = sumpf.modules.ImpulseGenerator(
samplingrate=input_signal.GetSamplingRate(),
length=len(input_signal)).GetSignal()
filter_spec_tofind = [
allpass,
] * branches
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(nlfunction, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
sweep = nlsp.NovakSweepGenerator_Sine(
sampling_rate=input_signal.GetSamplingRate(), length=len(input_signal))
ref_nlsystem.SetInput(sweep.GetOutput())
init_coeffs, non = nlsp.nonlinearconvolution_powerseries_temporalreversal(
sweep, ref_nlsystem.GetOutput(), branches=branches)
init_coeffs = nlsp.change_length_filterkernels(init_coeffs, filter_length)
ref_nlsystem.SetInput(input_signal)
found_filter_spec, nl_functions = nlsp.adaptive_identification_legendre(
input_generator=input_generator,
outputs=ref_nlsystem.GetOutput(),
branches=branches,
init_coeffs=init_coeffs)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_signal))
ref_nlsystem.SetInput(reference)
iden_nlsystem.SetInput(reference)
if Plot is True:
plot.relabelandplot(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference System",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified System",
show=True)
print "SNR between Reference and Identified output with all pass filters: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
def construct_hgm(kernelfile):
path, file = os.path.split(kernelfile)
filter_impulse_response = sumpf.modules.SignalFile(
filename=kernelfile,
format=sumpf.modules.SignalFile.NUMPY_NPZ).GetSignal()
filter_ir = nlsp.multichanneltoarray(filter_impulse_response)
branches = len(filter_ir)
if "powerseries" in file:
nl_functions = nlsp.nl_branches(nlsp.function_factory.power_series,
branches)
elif "chebyshev" in file:
nl_functions = nlsp.nl_branches(
nlsp.function_factory.chebyshev1_polynomial, branches)
elif "legendre" in file:
nl_functions = nlsp.nl_branches(
nlsp.function_factory.legrendre_polynomial, branches)
elif "hermite" in file:
nl_functions = nlsp.nl_branches(
nlsp.function_factory.hermite_polynomial, branches)
hgm = nlsp.HammersteinGroupModel_up(nonlinear_functions=nl_functions,
filter_irs=filter_ir)
return hgm
def puretone_evaluation(input_generator,
branches,
iden_method,
Plot,
reference=None):
input_signal = input_generator.GetOutput()
filter_spec_tofind = nlsp.log_bpfilter(branches=branches,
input=input_signal)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
found_filter_spec, nl_functions = iden_method(input_generator,
ref_nlsystem.GetOutput(),
branches)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
if Plot is True:
plot.relabelandplot(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference System",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified System",
show=True)
print "SNR between Reference and Identified output sweep: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
pure_tones = nlsp.generate_puretones([200, 1000, 3000, 5000, 10000, 20000],
input_signal.GetSamplingRate(),
length=len(input_signal))
ref_nlsystem.SetInput(pure_tones)
iden_nlsystem.SetInput(pure_tones)
if Plot is True:
plot.relabelandplot(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference System",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified System",
show=True)
print "SNR between Reference and Identified output puretone: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
def hgmallpass_evaluation(input_generator,
branches,
nlfunction,
iden_method,
Plot,
reference=None):
"""
Evaluation of System Identification method by hgm virtual nl system
nonlinear system - virtual hammerstein group model with power series polynomials as nl function and allpass filters
as linear functions
plot - the original filter spectrum and the identified filter spectrum, the reference output and identified output
expectation - utmost similarity between the two spectrums
"""
input_signal = input_generator.GetOutput()
allpass = sumpf.modules.ImpulseGenerator(
samplingrate=input_signal.GetSamplingRate(),
length=len(input_signal)).GetSignal()
filter_spec_tofind = [
allpass,
] * branches
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(nlfunction, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
found_filter_spec, nl_functions = iden_method(input_generator,
ref_nlsystem.GetOutput(),
branches)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_signal))
ref_nlsystem.SetInput(reference)
iden_nlsystem.SetInput(reference)
if Plot is True:
plot.relabelandplot(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference System",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified System",
show=True)
print "SNR between Reference and Identified output with all pass filters: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
def hgmwithoverlapfilter_evaluation(input_generator,
branches,
nlfunction,
iden_method,
Plot,
reference=None):
"""
Evaluation of System Identification method by hgm virtual nl system
nonlinear system - virtual hammerstein group model with power series polynomials as nl function and overlapping
bandpass filters as linear functions
plot - the original filter spectrum and the identified filter spectrum, the reference output and identified output
expectation - utmost similarity between the two spectrums
"""
frequencies = [500, 3000, 5000, 7000, 20000]
input_signal = input_generator.GetOutput()
filter_spec_tofind = nlsp.create_bpfilter(frequencies, input_signal)
length_kernel = len(filter_spec_tofind[0])
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(nlfunction, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
found_filter_spec, nl_functions = iden_method(input_generator,
ref_nlsystem.GetOutput(),
branches)
found_filter_spec = nlsp.change_length_filterkernels(found_filter_spec,
length=length_kernel)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_signal))
ref_nlsystem.SetInput(reference)
iden_nlsystem.SetInput(reference)
if Plot is True:
plot.relabelandplot(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference System",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified System",
show=True)
print "SNR between Reference and Identified output with overlapping filters: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
def uniqueness_evaluation_adaptive():
for input_generator in excitation:
print "adaptive identification"
print input_generator
for nlfunc_ref, nlfunc_iden in itertools.product(
nl_functions_all, nl_functions_all):
print "ref nl function %r" % nlfunc_ref
print "iden nl function %r" % nlfunc_iden
input_signal = input_generator.GetOutput()
filter_spec_tofind = nlsp.log_bpfilter(branches=branches,
input=input_signal)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(nlfunc_ref, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
found_filter_spec, nl_functions = nlsp.adaptive_identification(
input_generator,
ref_nlsystem.GetOutput(),
branches,
nonlinear_func=nlfunc_iden)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
nlsp.filterkernel_evaluation_sum(filter_spec_tofind,
found_filter_spec)
nlsp.filterkernel_evaluation_plot(filter_spec_tofind,
found_filter_spec)
if Plot is True:
plot.relabelandplot(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference Output",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Output",
show=True)
print "SNR between Reference and Identified output without overlapping filters: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
print
print
print
def computationtime_adaptive_evaluation(input_generator, branches):
identification = [nlsp.adaptive_identification_powerseries]
nlfunctions = [
nlsp.function_factory.power_series,
nlsp.function_factory.chebyshev1_polynomial,
nlsp.function_factory.hermite_polynomial,
nlsp.function_factory.legrendre_polynomial
]
for identification_alg, nl_function in itertools.product(
identification, nlfunctions):
sim = []
iden = []
print identification_alg
print nl_function
for i in range(5):
input_signal = input_generator.GetOutput()
filter_spec_tofind = nlsp.log_bpfilter(branches=branches,
input=input_signal)
nl_func = nlsp.nl_branches(nlsp.function_factory.power_series,
branches)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_func,
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
simulation_time_start = time.clock()
identification_time_start = time.clock()
found_filter_spec, nl_functions = identification_alg(
input_generator, ref_nlsystem.GetOutput(), branches,
nl_function)
identification_time_stop = time.clock()
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
iden_nlsystem.GetOutput()
simulation_time_stop = time.clock()
simulation_time = simulation_time_stop - simulation_time_start
identification_time = identification_time_stop - identification_time_start
sim.append(simulation_time)
iden.append(identification_time)
print "simulation time: %r, identification time: %r" % (
numpy.average(sim), numpy.average(iden))
def differentbranches_evaluation(input_generator,
branches,
iden_method,
Plot,
reference=None):
ref_branches = 3
for branches in range(1, branches):
input_signal = input_generator.GetOutput()
filter_spec_tofind = nlsp.log_weightingfilter(branches=ref_branches,
input=input_signal)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(
nlsp.function_factory.power_series, ref_branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, ref_branches + 1))
found_filter_spec, nl_functions = iden_method(input_generator,
ref_nlsystem.GetOutput(),
branches)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_signal))
ref_nlsystem.SetInput(reference)
iden_nlsystem.SetInput(reference)
if Plot is True:
plot.relabelandplotphase(
sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference Output", False)
plot.relabelandplotphase(
sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Output", True)
print "SNR between Reference and Identified output : %r, with number of ref_branches: %r and iden_branches: %r" % (
nlsp.snr(ref_nlsystem.GetOutput(),
iden_nlsystem.GetOutput()), ref_branches, branches)
def sweep_aliasing_evaluation():
input_signal = input_generator.GetOutput()
lin = sumpf.modules.ImpulseGenerator(
samplingrate=input_signal.GetSamplingRate(), length=100).GetSignal()
nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
filter_irs=[
lin,
] * degree,
nonlinear_functions=nlsp.nl_branches(
nlsp.function_factory.power_series, degree),
max_harmonics=range(1, degree + 1))
harmonics_ir = nlsp.get_nl_impulse_response(input_generator,
nlsystem.GetOutput())
harmonics = nlsp.get_nl_harmonics(input_generator, nlsystem.GetOutput(),
degree)
print "Harmonics to total harmonics ratio %r" % nlsp.harmonicsvsall_energyratio_nl(
input_generator, nlsystem.GetOutput(), degree)
plot.plot(harmonics_ir)
plot.plot(harmonics)
def uniqueness_evaluation_allexceptadaptive():
for method, input_generator, label in zip(iden_method, excitation, labels):
print method, input_generator
for nlfunc in nl_functions_all:
print nlfunc
input_signal = input_generator.GetOutput()
filter_spec_tofind = nlsp.log_bpfilter(branches=branches,
input=input_signal)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(nlfunc, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
found_filter_spec, nl_functions = method(input_generator,
ref_nlsystem.GetOutput(),
branches)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
nlsp.filterkernel_evaluation_sum(filter_spec_tofind,
found_filter_spec)
nlsp.filterkernel_evaluation_plot(filter_spec_tofind,
found_filter_spec)
if Plot is True:
plot.relabelandplot(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference Output",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Output",
show=True)
print "SNR between Reference and Identified output without overlapping filters: %r" % nlsp.snr(
ref_nlsystem.GetOutput(),
iden_nlsystem.GetOutput(),
label=label)
print
print
print
def hgmwithalphafilter_evaluation(input_generator,
branches,
nlfunction,
iden_method,
Plot,
label=None,
reference=None):
input_signal = input_generator.GetOutput()
filter_spec_tofind = nlsp.log_weightingfilter(branches=branches,
input=input_signal)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(nlfunction, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
found_filter_spec, nl_functions = iden_method(input_generator,
ref_nlsystem.GetOutput(),
branches)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_signal))
ref_nlsystem.SetInput(reference)
iden_nlsystem.SetInput(reference)
if Plot is True:
plot.relabelandplot(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference Output",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Output",
show=True)
print "SNR between Reference and Identified output with weighted filtering: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
def adaptive_polynomial_evaluation_virtual():
for input_generator, nlfunc in itertools.product(excitation, nl_functions):
print input_generator
print nlfunc
input_signal = input_generator.GetOutput()
filter_spec_tofind = nlsp.log_weightingfilter(branches=branches,
input=input_signal)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
found_filter_spec, nl_func = nlsp.adaptive_identification(
input_generator,
ref_nlsystem.GetOutput(),
branches,
nonlinear_func=nlfunc)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_func,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
ref_nlsystem.SetInput(wgn_pink.GetOutput())
iden_nlsystem.SetInput(wgn_pink.GetOutput())
if Plot is True:
plot.relabelandplot(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference Output",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Output",
show=True)
print "SNR between Reference and Identified output without overlapping filters: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
print
print
def wiener_g_identification(input_gen, output, branches):
"""
System identification using Wiener G functionals.
:param input_gen: the input generator or the input signal
:param output: the response of the nonlinear system
:param branches: the total number of branches
:return: the filter kernels and the nonlinear functions
"""
kernel_length = len(output) / 2
if hasattr(input_gen, "GetOutput"):
excitation = input_gen.GetOutput()
else:
excitation = input_gen
response = output
variance = sumpf.modules.SignalMean(input_gen.GetOutput() *
input_gen.GetOutput()).GetMean()[0]
kernels = []
for branch in range(1, branches + 1):
k = []
for i in range(0, kernel_length):
shifted = sumpf.modules.ShiftSignal(signal=excitation,
shift=-i,
circular=False).GetOutput()
power = nlsp.NonlinearFunction(
signal=shifted,
nonlin_func=nlsp.function_factory.hermite_polynomial(branch))
product = response * power.GetOutput()
mean = sumpf.modules.SignalMean(signal=product).GetMean()[0]
factor = 1.0 / (math.factorial(branch) * (variance**branch))
k.append(mean * factor)
k = sumpf.Signal(channels=(k, ),
samplingrate=output.GetSamplingRate(),
labels=())
kernels.append(k)
nl_func = nlsp.nl_branches(nlsp.function_factory.power_series, branches)
return kernels, nl_func
def doublehgm_same_evaluation(input_generator,
branches,
iden_method,
Plot,
reference=None):
"""
Evaluation of System Identification method by double hgm virtual nl system with same nonlinear degree and filters
nonlinear system - two virtual hammerstein group model with power series polynomials as nl function and bandpass
filters as linear functions
plot - the original filter spectrum and the identified filter spectrum, the reference output and identified output
expectation - utmost similarity between the two spectrums
"""
input_signal = input_generator.GetOutput()
filter_spec_tofind = nlsp.log_bpfilter(branches=branches,
input=input_signal)
ref_nlsystem = nlsp.HammersteinGroup_Series(
input_signal=input_signal,
nonlinear_functions=(nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
nlsp.nl_branches(
nlsp.function_factory.power_series,
branches)),
filter_irs=(filter_spec_tofind, filter_spec_tofind),
max_harmonics=(range(1, branches + 1), range(1, branches + 1)),
hgm_type=(nlsp.HammersteinGroupModel_up,
nlsp.HammersteinGroupModel_up))
found_filter_spec, nl_functions = iden_method(input_generator,
ref_nlsystem.GetOutput(2),
branches)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_signal))
ref_nlsystem = nlsp.HammersteinGroup_Series(
input_signal=reference,
nonlinear_functions=(nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
nlsp.nl_branches(
nlsp.function_factory.power_series,
branches)),
filter_irs=(filter_spec_tofind, filter_spec_tofind),
max_harmonics=(range(1, branches + 1), range(1, branches + 1)),
hgm_type=(nlsp.HammersteinGroupModel_up,
nlsp.HammersteinGroupModel_up))
iden_nlsystem.SetInput(reference)
if Plot is True:
plot.relabelandplotphase(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput(2)).GetSpectrum(),
"Reference System",
show=False)
plot.relabelandplotphase(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified System",
show=True)
print "SNR between Reference and Identified output for double hgm all same: %r" % nlsp.snr(
ref_nlsystem.GetOutput(2), iden_nlsystem.GetOutput())
def hgmwithfilter_evaluation_sweepadaptive(input_generator,
branches,
nlfuntion,
Plot,
reference=None):
input_signal = input_generator.GetOutput()
# filter_spec_tofind = nlsp.create_bpfilter([2000,8000,30000],input_signal)
filter_spec_tofind = nlsp.log_bpfilter(branches=branches,
input=input_signal)
# filter_spec_tofind = nlsp.log_chebyfilter(branches=branches,input=input_signal)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nlsp.nl_branches(nlfuntion, branches),
filter_irs=filter_spec_tofind,
max_harmonics=range(1, branches + 1))
sweep = nlsp.NovakSweepGenerator_Sine(
sampling_rate=input_signal.GetSamplingRate(), length=len(input_signal))
ref_nlsystem.SetInput(sweep.GetOutput())
sweep_start = time.clock()
init_coeffs, non = nlsp.nonlinearconvolution_powerseries_temporalreversal(
sweep, ref_nlsystem.GetOutput(), branches=branches)
sweep_stop = time.clock()
init_coeffs = nlsp.change_length_filterkernels(init_coeffs, filter_length)
ref_nlsystem.SetInput(input_signal)
adapt_sweep_start = time.clock()
found_filter_spec, nl_functions = nlsp.adaptive_identification_legendre(
input_generator=input_generator,
outputs=ref_nlsystem.GetOutput(),
branches=branches,
init_coeffs=init_coeffs,
filtertaps=filter_length)
adapt_sweep_stop = time.clock()
adapt_start = time.clock()
found_filter_spec, nl_functions = nlsp.adaptive_identification_legendre(
input_generator=input_generator,
outputs=ref_nlsystem.GetOutput(),
branches=branches,
filtertaps=filter_length)
adapt_stop = time.clock()
print "sweep_identification time %r" % (sweep_start - sweep_stop)
print "sweep_adapt_identification time %r" % (adapt_sweep_start -
adapt_sweep_stop)
print "adapt_identification time %r" % (adapt_start - adapt_stop)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
# nlsp.filterkernel_evaluation_plot(filter_spec_tofind,found_filter_spec)
# nlsp.filterkernel_evaluation_sum(filter_spec_tofind,found_filter_spec)
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_signal))
ref_nlsystem.SetInput(reference)
iden_nlsystem.SetInput(reference)
if Plot is True:
plot.relabelandplot(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput()).GetSpectrum(),
"Reference Output",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Output",
show=True)
print "SNR between Reference and Identified output without overlapping filters: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
def doublehgm_different_evaluation(input_generator,
branches,
Plot,
reference=None):
input_signal = input_generator.GetOutput()
filter_spec_tofind1 = nlsp.log_bpfilter(branches=branches,
input=input_signal)
filter_spec_tofind2 = nlsp.log_chebyfilter(branches=branches,
input=input_signal)
sweep = nlsp.NovakSweepGenerator_Sine(
sampling_rate=input_signal.GetSamplingRate(), length=len(input_signal))
ref_nlsystem = nlsp.HammersteinGroup_Series(
input_signal=sweep.GetOutput(),
nonlinear_functions=(nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
nlsp.nl_branches(
nlsp.function_factory.chebyshev1_polynomial,
branches)),
filter_irs=(filter_spec_tofind1, filter_spec_tofind2),
max_harmonics=(range(1, branches + 1), range(1, branches + 1)),
hgm_type=(nlsp.HammersteinGroupModel_up,
nlsp.HammersteinGroupModel_up))
init_coeffs, non = nlsp.nonlinearconvolution_powerseries_temporalreversal(
sweep, ref_nlsystem.GetOutput(2), branches=branches)
init_coeffs = nlsp.change_length_filterkernels(init_coeffs, filter_length)
ref_nlsystem = nlsp.HammersteinGroup_Series(
input_signal=input_signal,
nonlinear_functions=(nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
nlsp.nl_branches(
nlsp.function_factory.chebyshev1_polynomial,
branches)),
filter_irs=(filter_spec_tofind1, filter_spec_tofind2),
max_harmonics=(range(1, branches + 1), range(1, branches + 1)),
hgm_type=(nlsp.HammersteinGroupModel_up,
nlsp.HammersteinGroupModel_up))
found_filter_spec, nl_functions = nlsp.adaptive_identification_legendre(
input_generator=input_generator,
outputs=ref_nlsystem.GetOutput(2),
branches=branches,
init_coeffs=init_coeffs)
iden_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_signal))
ref_nlsystem = nlsp.HammersteinGroup_Series(
input_signal=reference,
nonlinear_functions=(
nlsp.nl_branches(nlsp.function_factory.power_series, branches),
nlsp.nl_branches(nlsp.function_factory.chebyshev1_polynomial,
branches)),
filter_irs=(filter_spec_tofind1, filter_spec_tofind2),
max_harmonics=(range(1, branches + 1), range(1, branches + 1)),
hgm_type=(nlsp.HammersteinGroupModel_up,
nlsp.HammersteinGroupModel_up))
iden_nlsystem.SetInput(reference)
if Plot is True:
plot.relabelandplotphase(sumpf.modules.FourierTransform(
ref_nlsystem.GetOutput(2)).GetSpectrum(),
"Reference System",
show=False)
plot.relabelandplotphase(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified System",
show=True)
print "SNR between Reference and Identified output for double hgm different: %r" % nlsp.snr(
ref_nlsystem.GetOutput(2), iden_nlsystem.GetOutput())
def wgnasreference():
branches = 3
sampling_rate = 48000.0
length = 2**18
start_freq = 100.0
stop_freq = 20000.0
fade_out = 0.00
fade_in = 0.00
filter_taps = 2**11
# input generator
sine_g = nlsp.NovakSweepGenerator_Sine(sampling_rate=sampling_rate,
length=length,
start_frequency=start_freq,
stop_frequency=stop_freq,
fade_out=fade_out,
fade_in=fade_in)
cos_g = nlsp.NovakSweepGenerator_Cosine(sampling_rate=sampling_rate,
length=length,
start_frequency=start_freq,
stop_frequency=stop_freq,
fade_out=fade_out,
fade_in=fade_in)
# real world reference system, load input and output noise and sweeps
load_noise = sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_ls/Noise18.npz",
format=sumpf.modules.SignalFile.WAV_FLOAT)
load_sine = sumpf.modules.SignalFile(
filename="C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_ls/sine.npz",
format=sumpf.modules.SignalFile.WAV_FLOAT)
load_cosine = sumpf.modules.SignalFile(
filename="C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_ls/cos.npz",
format=sumpf.modules.SignalFile.WAV_FLOAT)
output_noise = sumpf.modules.SplitSignal(data=load_noise.GetSignal(),
channels=[1]).GetOutput()
input_noise = sumpf.modules.SplitSignal(data=load_noise.GetSignal(),
channels=[0]).GetOutput()
output_sine = sumpf.modules.SplitSignal(data=load_sine.GetSignal(),
channels=[1]).GetOutput()
output_cos = sumpf.modules.SplitSignal(data=load_cosine.GetSignal(),
channels=[1]).GetOutput()
impulse = sumpf.modules.ImpulseGenerator(
length=filter_taps, samplingrate=sampling_rate).GetSignal()
# initialize hgm
iden_nlsystem = nlsp.HammersteinGroupModel_up(
max_harmonics=range(1, branches + 1),
nonlinear_functions=nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
filter_irs=[
impulse,
] * branches)
# only sine based system identification
found_filter_spec_sine, nl_function_sine = nlsp.nonlinearconvolution_powerseries_temporalreversal(
sine_g, output_sine, branches)
iden_nlsystem.SetInput(signal=input_noise)
iden_nlsystem.SetNLFunctions(nl_function_sine)
iden_nlsystem.SetFilterIRS(found_filter_spec_sine)
plot.relabelandplotphase(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified power noise",
show=False)
print "SNR between Reference and Identified output Sine: %r" % nlsp.snr(
output_noise, iden_nlsystem.GetOutput())
# only cosine based system identification
found_filter_spec_cos, nl_function_cos = nlsp.nonlinearconvolution_chebyshev_temporalreversal(
cos_g, output_cos, branches)
iden_nlsystem.SetInput(signal=input_noise)
iden_nlsystem.SetNLFunctions(nl_function_cos)
iden_nlsystem.SetFilterIRS(found_filter_spec_cos)
plot.relabelandplotphase(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified cheby noise",
show=False)
print "SNR between Reference and Identified output Cos: %r" % nlsp.snr(
output_noise, iden_nlsystem.GetOutput())
# only noise based system identification
found_filter_spec_adapt, nl_function_adapt = nlsp.adaptive_identification(
input_generator=input_noise,
outputs=output_noise,
iterations=1,
branches=branches,
step_size=0.1,
filtertaps=filter_taps,
algorithm=nlsp.multichannel_nlms,
Plot=False)
iden_nlsystem.SetInput(signal=input_noise)
iden_nlsystem.SetNLFunctions(nl_function_adapt)
iden_nlsystem.SetFilterIRS(found_filter_spec_adapt)
plot.relabelandplotphase(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Adapt noise",
show=False)
print "SNR between Reference and Identified output Adapt: %r" % nlsp.snr(
output_noise, iden_nlsystem.GetOutput())
# sine based as init coeff for noise based system identification
found_filter_spec_sine_reducedlength = nlsp.change_length_filterkernels(
found_filter_spec_sine, length=filter_taps)
found_filter_spec_sineadapt, nl_function_sineadapt = nlsp.adaptive_identification(
input_generator=input_noise,
outputs=output_noise,
iterations=1,
branches=branches,
step_size=0.1,
filtertaps=filter_taps,
algorithm=nlsp.multichannel_nlms,
Plot=False,
init_coeffs=found_filter_spec_sine_reducedlength)
iden_nlsystem.SetInput(signal=input_noise)
iden_nlsystem.SetNLFunctions(nl_function_sineadapt)
iden_nlsystem.SetFilterIRS(found_filter_spec_sineadapt)
plot.relabelandplotphase(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified power Adapt noise",
show=False)
print "SNR between Reference and Identified output Sine Adapt: %r" % nlsp.snr(
output_noise, iden_nlsystem.GetOutput())
# cos based as init coeff for noise based system identification
found_filter_spec_cos_reducedlength = nlsp.change_length_filterkernels(
found_filter_spec_cos, length=filter_taps)
found_filter_spec_cosadapt, nl_function_cosadapt = nlsp.adaptive_identification(
input_generator=input_noise,
outputs=output_noise,
iterations=1,
branches=branches,
step_size=0.1,
filtertaps=filter_taps,
algorithm=nlsp.multichannel_nlms,
Plot=False,
init_coeffs=found_filter_spec_cos_reducedlength,
nonlinear_func=nlsp.function_factory.chebyshev1_polynomial)
iden_nlsystem.SetInput(signal=input_noise)
iden_nlsystem.SetNLFunctions(nl_function_cosadapt)
iden_nlsystem.SetFilterIRS(found_filter_spec_cosadapt)
plot.relabelandplotphase(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified chebyshev Adapt noise",
show=False)
print "SNR between Reference and Identified output Cos Adapt: %r" % nlsp.snr(
output_noise, iden_nlsystem.GetOutput())
plot.relabelandplotphase(
sumpf.modules.FourierTransform(output_noise).GetSpectrum(),
"Reference Noise",
show=True)
def loudspeaker_model_adaptive():
"""
Realworld nonlinear system(Loudspeaker) Model using adaptive system identification
"""
branches = 5
filter_taps = 2**11
# real world reference system, load input and output noise
load_noise = sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_db/Noise18.npz",
format=sumpf.modules.SignalFile.WAV_FLOAT)
output_noise = sumpf.modules.SplitSignal(data=load_noise.GetSignal(),
channels=[1]).GetOutput()
input_noise = sumpf.modules.SplitSignal(data=load_noise.GetSignal(),
channels=[0]).GetOutput()
impulse = sumpf.modules.ImpulseGenerator(
length=filter_taps,
samplingrate=input_noise.GetSamplingRate()).GetSignal()
# initialize hgm
iden_nlsystem = nlsp.HammersteinGroupModel_up(
max_harmonics=range(1, branches + 1),
nonlinear_functions=nlsp.nl_branches(
nlsp.function_factory.power_series, branches),
filter_irs=[
impulse,
] * branches)
# only noise based adaptive system identification
found_filter_spec_adapt, nl_function_adapt = nlsp.adaptive_identification(
input_generator=input_noise,
outputs=output_noise,
iterations=1,
branches=branches,
step_size=0.1,
filtertaps=filter_taps,
algorithm=nlsp.multichannel_nlms,
Plot=False)
iden_nlsystem.SetInput(input_noise)
iden_nlsystem.SetNLFunctions(nl_function_adapt)
iden_nlsystem.SetFilterIRS(found_filter_spec_adapt)
plot.relabelandplotphase(sumpf.modules.FourierTransform(
iden_nlsystem.GetOutput()).GetSpectrum(),
"Identified Adapt sine",
show=False)
print "SNR between Reference and Identified output Noise signal: %r" % nlsp.snr(
output_noise, iden_nlsystem.GetOutput())
plot.relabelandplotphase(
sumpf.modules.FourierTransform(output_noise).GetSpectrum(),
"Reference Noise",
show=True)
load_sample = sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_db/Speech1.npz",
format=sumpf.modules.SignalFile.WAV_FLOAT)
output_sample = sumpf.modules.SplitSignal(data=load_sample.GetSignal(),
channels=[1]).GetOutput()
input_sample = sumpf.modules.SplitSignal(data=load_sample.GetSignal(),
channels=[0]).GetOutput()
iden_nlsystem.SetInput(input_sample)
# save the output to the directory
iden = sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_db/sim/identified",
signal=iden_nlsystem.GetOutput(),
format=sumpf.modules.SignalFile.WAV_FLOAT)
ref = sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_db/sim/reference",
signal=output_sample,
format=sumpf.modules.SignalFile.WAV_FLOAT)
inp = sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_db/sim/input",
signal=input_sample,
format=sumpf.modules.SignalFile.WAV_FLOAT)
print "Distortion box, SNR between Reference and Identified output Sample,nl: %r" % nlsp.snr(
output_sample, iden_nlsystem.GetOutput())
def sine_sweepbased_spectralinversion(sweep_generator,
output_sweep,
branches=5):
"""
Sweep-based system identification using spectral inversion technique and using sine sweep signal.
:param sweep_generator: the sweep generator object
:param output_sweep: the output sweep of the nonlinear system
:param branches: the total number of output branches
:return: the parameters of HGM (filter kernels and nonlinear functions)
"""
sweep_length = sweep_generator.GetLength()
sweep_start_freq = sweep_generator.GetStartFrequency()
sweep_stop_freq = sweep_generator.GetStopFrequency()
input_sweep = sweep_generator.GetOutput()
if isinstance(input_sweep, (sumpf.Signal)):
ip_signal = input_sweep
ip_spectrum = sumpf.modules.FourierTransform(
signal=input_sweep).GetSpectrum()
else:
ip_signal = sumpf.modules.InverseFourierTransform(
spectrum=input_sweep).GetSignal()
ip_spectrum = input_sweep
if isinstance(output_sweep, (sumpf.Signal)):
op_spectrum = sumpf.modules.FourierTransform(
signal=output_sweep).GetSpectrum()
else:
op_spectrum = output_sweep
inversed_ip = sumpf.modules.RegularizedSpectrumInversion(
spectrum=ip_spectrum,
start_frequency=sweep_start_freq + 50,
stop_frequency=sweep_stop_freq - 100).GetOutput()
tf_sweep = sumpf.modules.MultiplySpectrums(
spectrum1=inversed_ip, spectrum2=op_spectrum).GetOutput()
ir_sweep = sumpf.modules.InverseFourierTransform(
spectrum=tf_sweep).GetSignal()
# nlsp.common.plots.plot(ir_sweep)
ir_sweep_direct = sumpf.modules.CutSignal(signal=ir_sweep,
start=0,
stop=int(sweep_length /
4)).GetOutput()
ir_sweep_direct = nlsp.append_zeros(ir_sweep_direct)
ir_merger = sumpf.modules.MergeSignals(
on_length_conflict=sumpf.modules.MergeSignals.FILL_WITH_ZEROS)
ir_merger.AddInput(ir_sweep_direct)
for i in range(branches - 1):
split_harm = nlsp.FindHarmonicImpulseResponse_Novak(
impulse_response=ir_sweep,
harmonic_order=i + 2,
sweep_generator=sweep_generator).GetHarmonicImpulseResponse()
ir_merger.AddInput(
sumpf.Signal(channels=split_harm.GetChannels(),
samplingrate=ir_sweep.GetSamplingRate(),
labels=split_harm.GetLabels()))
ir_merger = ir_merger.GetOutput()
tf_harmonics_all = sumpf.modules.FourierTransform(
signal=ir_merger).GetSpectrum()
harmonics_tf = []
for i in range(len(tf_harmonics_all.GetChannels())):
tf_harmonics = sumpf.modules.SplitSpectrum(data=tf_harmonics_all,
channels=[i]).GetOutput()
harmonics_tf.append(tf_harmonics)
A_matrix = numpy.zeros((branches, branches), dtype=numpy.complex128)
for n in range(0, branches):
for m in range(0, branches):
if ((n >= m) and ((n + m) % 2 == 0)):
A_matrix[m][n] = (((-1 + 0j)**(2 * (n + 1) - m / 2)) /
(2**n)) * nlsp.binomial((n + 1), (n - m) / 2)
else:
A_matrix[m][n] = 0
A_inverse = numpy.linalg.inv(A_matrix)
for row in range(0, len(A_inverse)):
if row % 2 != 0.0:
A_inverse[row] = A_inverse[row] * (0 + 1j)
B = []
for row in range(0, branches):
A = sumpf.modules.ConstantSpectrumGenerator(
value=0.0,
resolution=harmonics_tf[0].GetResolution(),
length=len(harmonics_tf[0])).GetSpectrum()
for column in range(0, branches):
temp = sumpf.modules.AmplifySpectrum(
input=harmonics_tf[column],
factor=A_inverse[row][column]).GetOutput()
A = A + temp
B_temp = nlsp.relabel(
sumpf.modules.InverseFourierTransform(A).GetSignal(),
"%r harmonic identified psi" % str(row + 1))
B.append(B_temp)
nl_func = nlsp.nl_branches(nlsp.function_factory.power_series, branches)
return B, nl_func
